etfs.c File Reference

#include <bl.h>
#include <cdfs/cd.h>

Include dependency graph for etfs.c:

Go to the source code of this file.

Classes
struct	_RAW_ET_VD
struct	_BL_ETFS_DEVICE
struct	_BL_ETFS_FILE

Typedefs
typedef struct _RAW_ET_VD	RAW_ET_VD
typedef struct _RAW_ET_VD *	PRAW_ET_VD
typedef struct _BL_ETFS_DEVICE	BL_ETFS_DEVICE
typedef struct _BL_ETFS_DEVICE *	PBL_ETFS_DEVICE
typedef struct _BL_ETFS_FILE	BL_ETFS_FILE
typedef struct _BL_ETFS_FILE *	PBL_ETFS_FILE

Functions
NTSTATUS	EtfsOpen (_In_ PBL_FILE_ENTRY Directory, _In_ PWCHAR FileName, _In_ ULONG Flags, _Out_ PBL_FILE_ENTRY *FileEntry)
NTSTATUS	EtfsGetInformation (_In_ PBL_FILE_ENTRY FileEntry, _Out_ PBL_FILE_INFORMATION FileInfo)
NTSTATUS	EtfsSetInformation (_In_ PBL_FILE_ENTRY FileEntry, _In_ PBL_FILE_INFORMATION FileInfo)
NTSTATUS	EtfsRead (_In_ PBL_FILE_ENTRY FileEntry, _In_ PVOID Buffer, _In_ ULONG Size, _Out_opt_ PULONG BytesReturned)
VOID	EtfspGetDirectoryInfo (_In_ PBL_ETFS_DEVICE EtfsDevice, _In_ PRAW_DIR_REC DirEntry, _Out_ PULONG FileOffset, _Out_ PULONG FileSize, _Out_opt_ PBOOLEAN IsDirectory)
USHORT	EtfspGetDirentNameLength (_In_ PRAW_DIR_REC DirEntry)
LONG	EtfspCompareNames (__in PSTRING Name1, __in PUNICODE_STRING Name2)
BOOLEAN	EtfspFileMatch (_In_ PRAW_DIR_REC DirEntry, _In_ PUNICODE_STRING FileName)
NTSTATUS	EtfspGetDirent (_In_ PBL_FILE_ENTRY DirectoryEntry, _Out_ PRAW_DIR_REC *DirEntry, _Inout_ PULONG DirentOffset)
NTSTATUS	EtfspSearchForDirent (_In_ PBL_FILE_ENTRY DirectoryEntry, _In_ PWCHAR FileName, _Out_ PRAW_DIR_REC *DirEntry, _Out_ PULONG DirentOffset)
NTSTATUS	EtfspCachedSearchForDirent (_In_ PBL_FILE_ENTRY DirectoryEntry, _In_ PWCHAR FileName, _Out_ PRAW_DIR_REC *DirEntry, _Out_ PULONG DirOffset, _In_ BOOLEAN KeepOffset)
NTSTATUS	EtfspCheckCdfs (_In_ PBL_ETFS_DEVICE EtfsDevice, _In_ ULONG DeviceId, _Out_ PRAW_ISO_VD *VolumeDescriptor, _Out_ PBOOLEAN VolumeIsIso)
NTSTATUS	EtfspCheckEtfs (_In_ PBL_ETFS_DEVICE EtfsDevice, _In_ ULONG DeviceId, _Out_ PRAW_ISO_VD *VolumeDescriptor, _Out_ PBOOLEAN VolumeIsIso)
NTSTATUS	EtfspDeviceContextDestroy (_In_ PBL_ETFS_DEVICE EtfsDevice)
NTSTATUS	EtfspCreateContext (_In_ ULONG DeviceId, _Out_ PBL_ETFS_DEVICE *EtfsDevice)
NTSTATUS	EtfspDeviceTableDestroyEntry (_In_ PBL_ETFS_DEVICE EtfsDevice, _In_ ULONG Index)
NTSTATUS	EtfsMount (_In_ ULONG DeviceId, _In_ ULONG Unknown, _Out_ PBL_FILE_ENTRY *FileEntry)
NTSTATUS	EtfsInitialize (VOID)

Variables
ULONG	EtfsDeviceTableEntries
PVOID *	EtfsDeviceTable
BL_FILE_CALLBACKS	EtfsFunctionTable

Typedef Documentation

BL_ETFS_DEVICE

typedef struct _BL_ETFS_DEVICE BL_ETFS_DEVICE

BL_ETFS_FILE

typedef struct _BL_ETFS_FILE BL_ETFS_FILE

PBL_ETFS_DEVICE

typedef struct _BL_ETFS_DEVICE * PBL_ETFS_DEVICE

PBL_ETFS_FILE

typedef struct _BL_ETFS_FILE * PBL_ETFS_FILE

PRAW_ET_VD

typedef struct _RAW_ET_VD * PRAW_ET_VD

RAW_ET_VD

typedef struct _RAW_ET_VD RAW_ET_VD

Function Documentation

EtfsGetInformation()

NTSTATUS EtfsGetInformation	(	_In_ PBL_FILE_ENTRY	FileEntry,
		_Out_ PBL_FILE_INFORMATION	FileInfo
	)

Definition at line 522 of file etfs.c.

{
    PBL_ETFS_FILE EtfsFile;
 
    /* Get the underlying ETFS file data structure */
    EtfsFile = (PBL_ETFS_FILE)FileEntry->FsSpecificData;
 
    /* Copy the cached information structure within it */
    RtlCopyMemory(FileInfo, &EtfsFile->Size, sizeof(*FileInfo));
    return STATUS_SUCCESS;
}

EtfsInitialize()

NTSTATUS EtfsInitialize

(

VOID

)

Definition at line 969 of file etfs.c.

{
    NTSTATUS Status;
 
    /* Allocate the device table with 2 entries*/
    EtfsDeviceTableEntries = 2;
    EtfsDeviceTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) *
                                       EtfsDeviceTableEntries);
    if (EtfsDeviceTable)
    {
        /* Zero it out */
        RtlZeroMemory(EtfsDeviceTable,
                      sizeof(PBL_FILE_ENTRY) * EtfsDeviceTableEntries);
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* No memory, fail */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return back to caller */
    return Status;
}

EtfsMount()

NTSTATUS EtfsMount	(	_In_ ULONG	DeviceId,
		_In_ ULONG	Unknown,
		_Out_ PBL_FILE_ENTRY *	FileEntry
	)

Definition at line 874 of file etfs.c.

{
    PBL_ETFS_DEVICE EtfsDevice = NULL;
    PBL_FILE_ENTRY RootEntry;
    NTSTATUS Status;
    PBL_ETFS_FILE EtfsFile;
 
    EfiPrintf(L"Trying to mount as ETFS...\r\n");
 
    Status = EtfspCreateContext(DeviceId, &EtfsDevice);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"ETFS context failed: %lx\r\n");
        return Status;
    }
 
    Status = BlTblSetEntry(&EtfsDeviceTable,
                           &EtfsDeviceTableEntries,
                           EtfsDevice,
                           &DeviceId,
                           TblDoNotPurgeEntry);
    if (!NT_SUCCESS(Status))
    {
        EtfspDeviceContextDestroy(EtfsDevice);
        return Status;
    }
 
    RootEntry = BlMmAllocateHeap(sizeof(*RootEntry));
    if (!RootEntry)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    RtlZeroMemory(RootEntry, sizeof(*RootEntry));
 
    RootEntry->FilePath = BlMmAllocateHeap(4);
    if (!RootEntry->FilePath)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    wcsncpy(RootEntry->FilePath, L"\\", 1);
 
    RootEntry->DeviceId = DeviceId;
    RtlCopyMemory(&RootEntry->Callbacks,
                  &EtfsFunctionTable,
                  sizeof(RootEntry->Callbacks));
 
    EtfsFile = (PBL_ETFS_FILE)BlMmAllocateHeap(sizeof(*EtfsFile));
    if (!EtfsFile)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    RootEntry->Flags |= 0x10000;
 
    RtlZeroMemory(EtfsFile, sizeof(*EtfsFile));
    RootEntry->FsSpecificData = EtfsFile;
    EtfsFile->DeviceId = DeviceId;
    EtfsFile->Flags |= 1;
    EtfsFile->DiskOffset = EtfsDevice->RootDirOffset;
    EtfsFile->DirOffset = 0;
    EtfsFile->Size = EtfsDevice->RootDirSize;
    EtfsFile->FsName = L"cdfs";
    *FileEntry = RootEntry;
 
    return STATUS_SUCCESS;
 
Quickie:
    if (RootEntry->FilePath)
    {
        BlMmFreeHeap(RootEntry->FilePath);
    }
    if (RootEntry->FsSpecificData)
    {
        BlMmFreeHeap(RootEntry->FsSpecificData);
    }
    if (RootEntry)
    {
        BlMmFreeHeap(RootEntry);
    }
 
    EtfspDeviceTableDestroyEntry(EtfsDevice, DeviceId);
 
    return Status;
}

EtfsOpen()

NTSTATUS EtfsOpen	(	_In_ PBL_FILE_ENTRY	Directory,
		_In_ PWCHAR	FileName,
		_In_ ULONG	Flags,
		_Out_ PBL_FILE_ENTRY *	FileEntry
	)

Definition at line 538 of file etfs.c.

{
    PBL_ETFS_DEVICE EtfsDevice;
    NTSTATUS Status;
    PBL_FILE_ENTRY NewFile;
    PWCHAR FilePath, FormatString;
    PBL_ETFS_FILE EtfsFile;
    ULONG DeviceId, FileSize, DirOffset, FileOffset;
    SIZE_T Size;
    PRAW_DIR_REC DirEntry;
    BOOLEAN IsDirectory;
 
    EtfsFile = Directory->FsSpecificData;
    DeviceId = EtfsFile->DeviceId;
    EtfsDevice = EtfsDeviceTable[DeviceId];
 
    /* Find the given file (or directory) in the given directory */
    Status = EtfspCachedSearchForDirent(Directory,
                                        FileName,
                                        &DirEntry,
                                        &DirOffset,
                                        FALSE);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Find out information about the file (or directory) we found */
    EtfspGetDirectoryInfo(EtfsDevice,
                          DirEntry,
                          &FileOffset,
                          &FileSize,
                          &IsDirectory);
 
    /* Allocate a file entry */
    NewFile = BlMmAllocateHeap(sizeof(*NewFile));
    if (!NewFile)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Zero it out */
    RtlZeroMemory(NewFile, sizeof(*NewFile));
 
    /* Figure out the size of the path and filename plus a slash and NUL */
    Size = wcslen(Directory->FilePath) + wcslen(FileName) + 2;
    FilePath = BlMmAllocateHeap(Size * sizeof(WCHAR));
    if (!FilePath)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Allocate an ETFS file entry */
    EtfsFile = (PBL_ETFS_FILE)BlMmAllocateHeap(sizeof(*EtfsFile));
    if (!EtfsFile)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Zero it out */
    RtlZeroMemory(EtfsFile, sizeof(*EtfsFile));
 
    /* Capture the device ID of the directory */
    NewFile->DeviceId = Directory->DeviceId;
 
    /* Check if this is the root or a filename\directory under */
    FormatString = L"%ls%ls";
    if (Directory->FilePath[1])
    {
        FormatString = L"%ls\\%ls";
    }
 
    /* Combine the paths, and save the final path in the file entry */
    _snwprintf(FilePath, Size, FormatString, Directory->FilePath, FileName);
    NewFile->FilePath = FilePath;
 
    /* Copy the ETFS function callbacks into the file netry */
    RtlCopyMemory(&NewFile->Callbacks,
                  &EtfsFunctionTable,
                  sizeof(NewFile->Callbacks));
 
    /* Fill out the rest of the details */
    EtfsFile->DiskOffset = FileOffset;
    EtfsFile->DirOffset = DirOffset;
    EtfsFile->Size = FileSize;
    EtfsFile->DeviceId = DeviceId;
 
    /* Check if this is a directory */
    if (IsDirectory)
    {
        EtfsFile->Flags |= BL_ETFS_FILE_ENTRY_DIRECTORY;
        NewFile->Flags |= BL_FILE_ENTRY_DIRECTORY;
    }
 
    /* Write down the name of the filesystem */
    EtfsFile->FsName = L"cdfs";
 
    /* All done, return the file entry, and save the ETFS side */
    NewFile->FsSpecificData = EtfsFile;
    *FileEntry = NewFile;
    return Status;
 
Quickie:
    /* Failure path -- free the file path if we had one */
    if (NewFile->FilePath)
    {
        BlMmFreeHeap(NewFile->FilePath);
    }
 
    /* Free the ETFS file entry if we had one */
    if (NewFile->FsSpecificData)
    {
        BlMmFreeHeap(NewFile->FsSpecificData);
    }
 
    /* Free the file entry itself, and return the error code */
    BlMmFreeHeap(NewFile);
    return Status;
}

EtfspCachedSearchForDirent()

NTSTATUS EtfspCachedSearchForDirent	(	_In_ PBL_FILE_ENTRY	DirectoryEntry,
		_In_ PWCHAR	FileName,
		_Out_ PRAW_DIR_REC *	DirEntry,
		_Out_ PULONG	DirOffset,
		_In_ BOOLEAN	KeepOffset
	)

Definition at line 370 of file etfs.c.

{
    PBL_ETFS_FILE EtfsFile;
    PBL_ETFS_DEVICE EtfsDevice;
    NTSTATUS Status;
    ULONG DirentOffset;
    PRAW_DIR_REC Dirent;
    UNICODE_STRING Name;
 
    EtfsFile = DirectoryEntry->FsSpecificData;
    EtfsDevice = EtfsDeviceTable[EtfsFile->DeviceId];
    RtlInitUnicodeString(&Name, FileName);
    DirentOffset = EtfsFile->DirEntOffset;
 
    if ((KeepOffset) ||
        (ALIGN_DOWN_BY((DirentOffset + EtfsFile->DiskOffset), CD_SECTOR_SIZE) ==
         EtfsDevice->Offset))
    {
        Status = EtfspGetDirent(DirectoryEntry, &Dirent, &DirentOffset);
        if (NT_SUCCESS(Status))
        {
            if (!EtfspFileMatch(Dirent, &Name))
            {
                *DirEntry = Dirent;
                *DirOffset = DirentOffset;
                return STATUS_SUCCESS;
            }
        }
        else
        {
            DirentOffset = 0;
        }
    }
    else
    {
        DirentOffset = 0;
    }
 
    Status = EtfspSearchForDirent(DirectoryEntry,
                                  FileName,
                                  DirEntry,
                                  &DirentOffset);
    if (!(NT_SUCCESS(Status)) && (DirentOffset))
    {
        DirentOffset = 0;
        Status = EtfspSearchForDirent(DirectoryEntry,
                                      FileName,
                                      DirEntry,
                                      &DirentOffset);
    }
 
    if (NT_SUCCESS(Status))
    {
        *DirOffset = DirentOffset;
    }
 
    return Status;
}

Referenced by EtfsOpen().

EtfspCheckCdfs()

NTSTATUS EtfspCheckCdfs	(	_In_ PBL_ETFS_DEVICE	EtfsDevice,
		_In_ ULONG	DeviceId,
		_Out_ PRAW_ISO_VD *	VolumeDescriptor,
		_Out_ PBOOLEAN	VolumeIsIso
	)

Definition at line 666 of file etfs.c.

{
    EfiPrintf(L"Raw Cdfs not implemented\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by EtfspCreateContext().

EtfspCheckEtfs()

NTSTATUS EtfspCheckEtfs	(	_In_ PBL_ETFS_DEVICE	EtfsDevice,
		_In_ ULONG	DeviceId,
		_Out_ PRAW_ISO_VD *	VolumeDescriptor,
		_Out_ PBOOLEAN	VolumeIsIso
	)

Definition at line 678 of file etfs.c.

{
    PRAW_ISO_VD IsoVd;
    PRAW_ET_VD EtVd;
    NTSTATUS Status;
    BOOLEAN IsIso;
    BL_DEVICE_INFORMATION DeviceInformation;
    ULONG Unknown, BytesRead;
    ANSI_STRING CompareString, String;
 
    /* Save our static buffer pointer */
    IsoVd = (PRAW_ISO_VD)EtfsDevice->MemoryBlock;
    EtVd = (PRAW_ET_VD)IsoVd;
 
    /* First, read the El Torito Volume Descriptor */
    BlDeviceGetInformation(DeviceId, &DeviceInformation);
    Unknown = DeviceInformation.BlockDeviceInfo.Unknown;
    DeviceInformation.BlockDeviceInfo.Unknown |= 1;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
    Status = BlDeviceReadAtOffset(DeviceId,
                                  CD_SECTOR_SIZE,
                                  (FIRST_VD_SECTOR + 1) * CD_SECTOR_SIZE,
                                  EtfsDevice->MemoryBlock,
                                  &BytesRead);
    DeviceInformation.BlockDeviceInfo.Unknown = Unknown;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L" read failed\r\n");
        return Status;
    }
 
    /* Remember that's where we last read */
    EtfsDevice->Offset = (FIRST_VD_SECTOR + 1) * CD_SECTOR_SIZE;
 
    /* Check if it's EL TORITO! */
    RtlInitString(&String, "EL TORITO SPECIFICATION");
    CompareString.Buffer = (PCHAR)EtVd->SystemId;
    CompareString.Length = 23;
    CompareString.MaximumLength = 23;
    if (!RtlEqualString(&CompareString, &String, TRUE))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Check the version and boot indicator */
    if ((EtVd->Version != 1) || (EtVd->BootIndicator))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Check if it has the CD0001 identifier */
    RtlInitString(&String, ISO_VOL_ID);
    CompareString.Buffer = (PCHAR)EtVd->StandardId;
    CompareString.Length = 5;
    CompareString.MaximumLength = 5;
    if (!RtlEqualString(&CompareString, &String, TRUE))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Step two, we now want to read the ISO Volume Descriptor */
    DeviceInformation.BlockDeviceInfo.Unknown |= 1u;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
    Status = BlDeviceReadAtOffset(DeviceId,
                                  CD_SECTOR_SIZE,
                                  FIRST_VD_SECTOR * CD_SECTOR_SIZE,
                                  EtfsDevice->MemoryBlock,
                                  &BytesRead);
    DeviceInformation.BlockDeviceInfo.Unknown = Unknown;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Remember where we left off */
    EtfsDevice->Offset = FIRST_VD_SECTOR  * CD_SECTOR_SIZE;
 
    /* This should also say CD0001 */
    CompareString.Buffer = (PCHAR)IsoVd->StandardId;
    CompareString.Length = 5;
    CompareString.MaximumLength = 5;
    IsIso = RtlEqualString(&CompareString, &String, TRUE);
    if (!IsIso)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* And should be a version we support */
    if ((IsoVd->Version != VERSION_1) || (IsoVd->DescType != VD_PRIMARY))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Return back to the caller */
    *VolumeDescriptor = IsoVd;
    *VolumeIsIso = IsIso;
    return STATUS_SUCCESS;
}

Referenced by EtfspCreateContext().

EtfspCompareNames()

LONG EtfspCompareNames	(	__in PSTRING	Name1,
		__in PUNICODE_STRING	Name2
	)

Definition at line 160 of file etfs.c.

{
    ULONG i, l1, l2, l;
 
    l1 = Name1->Length;
    l2 = Name2->Length / sizeof(WCHAR);
    l = min(l1, l2);
 
    for (i = 0; i < l; i++)
    {
        if (toupper(Name1->Buffer[i]) != toupper(Name2->Buffer[i]))
        {
            return toupper(Name1->Buffer[i]) - toupper(Name2->Buffer[i]);
        }
    }
 
    if (l2 <= l1)
    {
        return l2 < l1;
    }
    else
    {
        return -1;
    }
}

Referenced by EtfspFileMatch().

EtfspCreateContext()

NTSTATUS EtfspCreateContext	(	_In_ ULONG	DeviceId,
		_Out_ PBL_ETFS_DEVICE *	EtfsDevice
	)

Definition at line 800 of file etfs.c.

{
    PBL_ETFS_DEVICE NewContext;
    PVOID MemoryBlock;
    NTSTATUS Status;
    BOOLEAN IsIso;
    PRAW_ISO_VD RawVd;
 
    NewContext = (PBL_ETFS_DEVICE)BlMmAllocateHeap(sizeof(*NewContext));
    if (!NewContext)
    {
        return STATUS_NO_MEMORY;
    }
    RtlZeroMemory(NewContext, sizeof(*NewContext));
 
    MemoryBlock = BlMmAllocateHeap(CD_SECTOR_SIZE);
    NewContext->MemoryBlock = MemoryBlock;
    if (!MemoryBlock)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    Status = EtfspCheckEtfs(NewContext, DeviceId, &RawVd, &IsIso);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Drive not EDFS. Checking for CDFS: %lx\r\n");
        Status = EtfspCheckCdfs(NewContext, DeviceId, &RawVd, &IsIso);
    }
 
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Drive not CDFS. Failing: %lx\r\n");
        goto Quickie;
    }
 
    NewContext->IsIso = IsIso;
    NewContext->BlockSize = RVD_LB_SIZE(RawVd, IsIso);
    NewContext->VolumeSize = RVD_VOL_SIZE(RawVd, IsIso);
 
    EtfspGetDirectoryInfo(NewContext,
                          (PRAW_DIR_REC)RVD_ROOT_DE(RawVd, IsIso),
                          &NewContext->RootDirOffset,
                          &NewContext->RootDirSize,
                          0);
    Status = STATUS_SUCCESS;
 
Quickie:
    if (!NT_SUCCESS(Status))
    {
        EtfspDeviceContextDestroy(NewContext);
        NewContext = NULL;
    }
 
    *EtfsDevice = NewContext;
    return Status;
}

Referenced by EtfsMount().

EtfspDeviceContextDestroy()

NTSTATUS EtfspDeviceContextDestroy

(

_In_ PBL_ETFS_DEVICE

EtfsDevice

)

Definition at line 785 of file etfs.c.

{
    if (EtfsDevice->MemoryBlock)
    {
        BlMmFreeHeap(EtfsDevice->MemoryBlock);
    }
 
    BlMmFreeHeap(EtfsDevice);
 
    return STATUS_SUCCESS;
}

Referenced by EtfsMount(), EtfspCreateContext(), and EtfspDeviceTableDestroyEntry().

EtfspDeviceTableDestroyEntry()

NTSTATUS EtfspDeviceTableDestroyEntry	(	_In_ PBL_ETFS_DEVICE	EtfsDevice,
		_In_ ULONG	Index
	)

Definition at line 862 of file etfs.c.

{
    EtfspDeviceContextDestroy(EtfsDevice);
    EtfsDeviceTable[Index] = NULL;
 
    return STATUS_SUCCESS;
}

Referenced by EtfsMount().

EtfspFileMatch()

BOOLEAN EtfspFileMatch	(	_In_ PRAW_DIR_REC	DirEntry,
		_In_ PUNICODE_STRING	FileName
	)

Definition at line 190 of file etfs.c.

{
    BOOLEAN Match;
    USHORT Length;
    ANSI_STRING DirName;
 
    if ((DirEntry->FileIdLen != 1) ||
        ((DirEntry->FileId[0] != 0) && (DirEntry->FileId[0] != 1)))
    {
        Length = EtfspGetDirentNameLength(DirEntry);
        DirName.Length = Length;
        DirName.MaximumLength = Length;
        DirName.Buffer = (PCHAR)DirEntry->FileId;
 
        Match = EtfspCompareNames(&DirName, FileName);
    }
    else
    {
        Match = -1;
    }
    return Match;
}

Referenced by EtfspCachedSearchForDirent(), and EtfspSearchForDirent().

EtfspGetDirectoryInfo()

VOID EtfspGetDirectoryInfo	(	_In_ PBL_ETFS_DEVICE	EtfsDevice,
		_In_ PRAW_DIR_REC	DirEntry,
		_Out_ PULONG	FileOffset,
		_Out_ PULONG	FileSize,
		_Out_opt_ PBOOLEAN	IsDirectory
	)

Definition at line 93 of file etfs.c.

{
    ULONG SectorOffset;
    BOOLEAN IsDir;
 
    *FileOffset = *(PULONG)DirEntry->FileLoc * EtfsDevice->BlockSize;
    *FileOffset += (DirEntry->XarLen * EtfsDevice->BlockSize);
 
    SectorOffset = ALIGN_DOWN_BY(*FileOffset, CD_SECTOR_SIZE);
 
    *FileSize = *(PULONG)DirEntry->DataLen;
 
    IsDir = DE_FILE_FLAGS(EtfsDevice->IsIso, DirEntry) & ISO_ATTR_DIRECTORY;
    if (IsDir)
    {
        *FileSize += ALIGN_UP_BY(SectorOffset, CD_SECTOR_SIZE) - SectorOffset;
    }
 
    if (IsDirectory)
    {
        *IsDirectory = IsDir;
    }
}

Referenced by EtfsOpen(), and EtfspCreateContext().

EtfspGetDirent()

NTSTATUS EtfspGetDirent	(	_In_ PBL_FILE_ENTRY	DirectoryEntry,
		_Out_ PRAW_DIR_REC *	DirEntry,
		_Inout_ PULONG	DirentOffset
	)

Definition at line 217 of file etfs.c.

{
    PBL_ETFS_FILE EtfsFile;
    ULONG FileOffset, DirectoryOffset, AlignedOffset, RemainderOffset;
    ULONG DeviceId, ReadSize, DirLen;
    PBL_ETFS_DEVICE EtfsDevice;
    BOOLEAN NeedRead, IsMulti;
    NTSTATUS result;
    PRAW_DIR_REC DirEnt;
    PUCHAR MemoryBlock;
 
    EtfsFile = DirectoryEntry->FsSpecificData;
    DeviceId = EtfsFile->DeviceId;
    FileOffset = EtfsFile->DiskOffset;
    EtfsDevice = EtfsDeviceTable[DeviceId];
 
    DirectoryOffset = *DirentOffset;
    MemoryBlock = EtfsDevice->MemoryBlock;
 
    IsMulti = 0;
 
    AlignedOffset = (FileOffset + *DirentOffset) & ~CD_SECTOR_SIZE;
    RemainderOffset = *DirentOffset + FileOffset - AlignedOffset;
 
    ReadSize = 2048 - RemainderOffset;
    NeedRead = AlignedOffset == EtfsDevice->Offset ? 0 : 1;
 
ReadAgain:
    if (DirectoryOffset >= EtfsFile->Size)
    {
        return STATUS_NO_SUCH_FILE;
    }
 
    while (ReadSize < MIN_DIR_REC_SIZE)
    {
        DirectoryOffset += ReadSize;
        AlignedOffset += 2048;
        ReadSize = 2048;
        RemainderOffset = 0;
        NeedRead = 1;
        if (DirectoryOffset >= EtfsFile->Size)
        {
            return STATUS_NO_SUCH_FILE;
        }
    }
 
    if (NeedRead)
    {
        result = BlDeviceReadAtOffset(DirectoryEntry->DeviceId,
                                      CD_SECTOR_SIZE,
                                      AlignedOffset,
                                      MemoryBlock,
                                      NULL);
        if (!NT_SUCCESS(result))
        {
            EfiPrintf(L"Device read failed %lx\r\n", result);
            return result;
        }
 
        NeedRead = FALSE;
        EtfsDevice->Offset = AlignedOffset;
    }
 
    if (!*(MemoryBlock + RemainderOffset))
    {
        AlignedOffset += 2048;
        NeedRead = TRUE;
 
        RemainderOffset = 0;
        DirectoryOffset += ReadSize;
        ReadSize = 2048;
        goto ReadAgain;
    }
 
    DirEnt = (PRAW_DIR_REC)(MemoryBlock + RemainderOffset);
    DirLen = DirEnt->DirLen;
    if (DirLen > ReadSize)
    {
        EfiPrintf(L"Dir won't fit %lx %lx\r\n", DirLen, ReadSize);
        return STATUS_NO_SUCH_FILE;
    }
 
    if (IsMulti)
    {
        if (!(DE_FILE_FLAGS(EtfsDevice->IsIso, DirEnt) & ISO_ATTR_MULTI))
        {
            IsMulti = TRUE;
        }
    }
    else if (DE_FILE_FLAGS(EtfsDevice->IsIso, DirEnt) & ISO_ATTR_MULTI)
    {
        IsMulti = TRUE;
    }
    else
    {
        if ((DirEnt->FileIdLen != 1) ||
            ((DirEnt->FileId[0] != 0) && (DirEnt->FileId[0] != 1)))
        {
            goto Quickie;
        }
    }
 
    RemainderOffset += DirLen;
    DirectoryOffset += DirLen;
    ReadSize -= DirLen;
    goto ReadAgain;
 
Quickie:
    *DirEntry = DirEnt;
    *DirentOffset = DirectoryOffset;
    return STATUS_SUCCESS;
}

Referenced by EtfspCachedSearchForDirent(), and EtfspSearchForDirent().

EtfspGetDirentNameLength()

USHORT EtfspGetDirentNameLength

(

_In_ PRAW_DIR_REC

DirEntry

)

Definition at line 124 of file etfs.c.

{
    USHORT Length, RealLength;
    PUCHAR Pos;
 
    RealLength = Length = DirEntry->FileIdLen;
    for (Pos = DirEntry->FileId + Length - 1; Length; --Pos)
    {
        --Length;
 
        if (*Pos == ';')
        {
            RealLength = Length;
            break;
        }
    }
 
    Length = RealLength;
    for (Pos = DirEntry->FileId + Length - 1; Length; --Pos)
    {
        --Length;
 
        if (*Pos != '.')
        {
            break;
        }
 
        RealLength = Length;
    }
 
    return RealLength;
}

Referenced by EtfspFileMatch().

EtfspSearchForDirent()

NTSTATUS EtfspSearchForDirent	(	_In_ PBL_FILE_ENTRY	DirectoryEntry,
		_In_ PWCHAR	FileName,
		_Out_ PRAW_DIR_REC *	DirEntry,
		_Out_ PULONG	DirentOffset
	)

Definition at line 335 of file etfs.c.

{
    UNICODE_STRING Name;
    ULONG NextOffset;
    PRAW_DIR_REC DirEnt;
    NTSTATUS Status;
 
    RtlInitUnicodeString(&Name, FileName);
    for (NextOffset = *DirentOffset;
         ;
         NextOffset = NextOffset + DirEnt->DirLen)
    {
        Status = EtfspGetDirent(DirectoryEntry, &DirEnt, &NextOffset);
        if (!NT_SUCCESS(Status))
        {
            return STATUS_NO_SUCH_FILE;
        }
 
        if (!EtfspFileMatch(DirEnt, &Name))
        {
            break;
        }
    }
 
    *DirEntry = DirEnt;
    *DirentOffset = NextOffset;
    return 0;
}

Referenced by EtfspCachedSearchForDirent().

EtfsRead()

NTSTATUS EtfsRead	(	_In_ PBL_FILE_ENTRY	FileEntry,
		_In_ PVOID	Buffer,
		_In_ ULONG	Size,
		_Out_opt_ PULONG	BytesReturned
	)

Definition at line 436 of file etfs.c.

{
    ULONG BytesRead;
    PBL_ETFS_FILE EtfsFile;
    NTSTATUS Status;
 
    /* Assume failure for now */
    BytesRead = 0;
 
    /* Make sure that the read is within the file's boundaries */
    EtfsFile = FileEntry->FsSpecificData;
    if ((Size + EtfsFile->Offset) > EtfsFile->Size)
    {
        /* Bail out otherwise */
        Status = STATUS_INVALID_PARAMETER;
    }
    else
    {
        /* Read the offset that matches this file's offset, on the disk */
        Status = BlDeviceReadAtOffset(FileEntry->DeviceId,
                                      Size,
                                      EtfsFile->Offset + EtfsFile->DiskOffset,
                                      Buffer,
                                      &BytesRead);
        if (NT_SUCCESS(Status))
        {
            /* Update the file offset and return the size as having been read */
            EtfsFile->Offset += Size;
            BytesRead = Size;
        }
    }
 
    /* Check if caller wanted to know how many bytes were read */
    if (BytesReturned)
    {
        /* Return the value */
        *BytesReturned = BytesRead;
    }
 
    /* All done */
    return Status;
}

EtfsSetInformation()

NTSTATUS EtfsSetInformation	(	_In_ PBL_FILE_ENTRY	FileEntry,
		_In_ PBL_FILE_INFORMATION	FileInfo
	)

Definition at line 485 of file etfs.c.

{
    PBL_ETFS_FILE EtfsFile;
    BL_FILE_INFORMATION LocalFileInfo;
 
    /* Get the underlying ETFS file data structure */
    EtfsFile = (PBL_ETFS_FILE)FileEntry->FsSpecificData;
 
    /* Make a copy of the incoming attributes, but ignore the new offset */
    LocalFileInfo = *FileInfo;
    LocalFileInfo.Offset = EtfsFile->Offset;
 
    /* Check if these match exactly the current file */
    if (!RtlEqualMemory(&LocalFileInfo, &EtfsFile->Size, sizeof(*FileInfo)))
    {
        /* Nope -- which means caller is trying to change an immutable */
        EfiPrintf(L"Incorrect information change\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Is the offset past the end of the file? */
    if (FileInfo->Offset >= EtfsFile->Size)
    {
        /* Don't allow EOF */
        EfiPrintf(L"Offset too large: %lx vs %lx\r\n", FileInfo->Offset, EtfsFile->Size);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Update the offset */
    EtfsFile->Offset = FileInfo->Offset;
    return STATUS_SUCCESS;
}

Variable Documentation

EtfsDeviceTable

PVOID* EtfsDeviceTable

Definition at line 49 of file etfs.c.

Referenced by EtfsInitialize(), EtfsMount(), EtfsOpen(), EtfspCachedSearchForDirent(), EtfspDeviceTableDestroyEntry(), and EtfspGetDirent().

EtfsDeviceTableEntries

ULONG EtfsDeviceTableEntries

Definition at line 48 of file etfs.c.

Referenced by EtfsInitialize(), and EtfsMount().

EtfsFunctionTable

BL_FILE_CALLBACKS EtfsFunctionTable

Initial value:

=
{
    EtfsOpen,
    NULL,
    EtfsRead,
    NULL,
    NULL,
    EtfsGetInformation,
    EtfsSetInformation
}

Definition at line 79 of file etfs.c.

Referenced by EtfsMount(), and EtfsOpen().