iso.c File Reference

#include <freeldr.h>
#include <debug.h>

Include dependency graph for iso.c:

Go to the source code of this file.

Classes
struct	_ISO_VOLUME_INFO

Macros
#define	SECTORSIZE   2048
#define	TAG_ISO_VOLUME   'VosI'
#define	TAG_ISO_BUFFER   'BosI'
#define	TAG_ISO_FILE   'FosI'

Typedefs
typedef struct _ISO_VOLUME_INFO	ISO_VOLUME_INFO
typedef struct _ISO_VOLUME_INFO *	PISO_VOLUME_INFO

Functions
	DBG_DEFAULT_CHANNEL (FILESYSTEM)
static PCSTR	IsoLastPathSeparator (_In_ PCSTR Path)
static BOOLEAN	IsoSearchDirectoryBufferForFile (PVOID DirectoryBuffer, ULONG DirectoryLength, PCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
static ARC_STATUS	IsoBufferDirectory (ULONG DeviceId, ULONG DirectoryStartSector, ULONG DirectoryLength, PVOID *pDirectoryBuffer)
static ARC_STATUS	IsoLookupFile (PCSTR FileName, ULONG DeviceId, PISO_FILE_INFO IsoFileInfo)
static ARC_STATUS	IsoClose (ULONG FileId)
static ARC_STATUS	IsoGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
static ARC_STATUS	IsoOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
static ARC_STATUS	IsoRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
static ARC_STATUS	IsoSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
ULONGLONG	IsoGetVolumeSize (_In_ ULONG DeviceId)
	Returns the size of the ISO-9660 volume laid on the storage media device opened via DeviceId.
const DEVVTBL *	IsoMount (ULONG DeviceId)

Variables
static PISO_VOLUME_INFO	IsoVolumes [MAX_FDS]
static const DEVVTBL	Iso9660FuncTable

Macro Definition Documentation

SECTORSIZE

#define SECTORSIZE   2048

Definition at line 27 of file iso.c.

TAG_ISO_BUFFER

#define TAG_ISO_BUFFER   'BosI'

Definition at line 29 of file iso.c.

TAG_ISO_FILE

#define TAG_ISO_FILE   'FosI'

Definition at line 30 of file iso.c.

TAG_ISO_VOLUME

#define TAG_ISO_VOLUME   'VosI'

Definition at line 28 of file iso.c.

Typedef Documentation

ISO_VOLUME_INFO

typedef struct _ISO_VOLUME_INFO ISO_VOLUME_INFO

PISO_VOLUME_INFO

typedef struct _ISO_VOLUME_INFO * PISO_VOLUME_INFO

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

FILESYSTEM

)

IsoBufferDirectory()

static ARC_STATUS IsoBufferDirectory ( ULONG  DeviceId, ULONG  DirectoryStartSector, ULONG  DirectoryLength, PVOID *  pDirectoryBuffer  )

static

Definition at line 128 of file iso.c.

{
    PVOID DirectoryBuffer;
    ULONG SectorCount;
    LARGE_INTEGER Position;
    ULONG Count;
    ARC_STATUS Status;
 
    TRACE("IsoBufferDirectory() DirectoryStartSector = %d DirectoryLength = %d\n", DirectoryStartSector, DirectoryLength);
 
    SectorCount = ROUND_UP(DirectoryLength, SECTORSIZE) / SECTORSIZE;
    TRACE("Trying to read (DirectoryCount) %d sectors.\n", SectorCount);
 
    //
    // Attempt to allocate memory for directory buffer
    //
    TRACE("Trying to allocate (DirectoryLength) %d bytes.\n", DirectoryLength);
    DirectoryBuffer = FrLdrTempAlloc(DirectoryLength, TAG_ISO_BUFFER);
    if (!DirectoryBuffer)
        return ENOMEM;
 
    //
    // Now read directory contents into DirectoryBuffer
    //
    Position.HighPart = 0;
    Position.LowPart = DirectoryStartSector * SECTORSIZE;
    Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
    {
        FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
        return Status;
    }
    Status = ArcRead(DeviceId, DirectoryBuffer, SectorCount * SECTORSIZE, &Count);
    if (Status != ESUCCESS || Count != SectorCount * SECTORSIZE)
    {
        FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
        return EIO;
    }
 
    *pDirectoryBuffer = DirectoryBuffer;
    return ESUCCESS;
}

Referenced by IsoLookupFile().

IsoClose()

static ARC_STATUS IsoClose ( ULONG  FileId )

static

Definition at line 320 of file iso.c.

{
    PISO_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    FrLdrTempFree(FileHandle, TAG_ISO_FILE);
    return ESUCCESS;
}

IsoGetFileInformation()

static ARC_STATUS IsoGetFileInformation ( ULONG  FileId, FILEINFORMATION *  Information  )

static

Definition at line 328 of file iso.c.

{
    PISO_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
 
    RtlZeroMemory(Information, sizeof(*Information));
    Information->EndingAddress.LowPart = FileHandle->FileSize;
    Information->CurrentAddress.LowPart = FileHandle->FilePointer;
 
    /* Set the ARC file attributes */
    Information->Attributes = FileHandle->Attributes;
 
    /* Copy the file name, perhaps truncated, and NUL-terminated */
    Information->FileNameLength = min(FileHandle->FileNameLength, sizeof(Information->FileName) - 1);
    RtlCopyMemory(Information->FileName, FileHandle->FileName, Information->FileNameLength);
    Information->FileName[Information->FileNameLength] = ANSI_NULL;
 
    TRACE("IsoGetFileInformation(%lu) -> FileSize = %lu, FilePointer = 0x%lx\n",
          FileId, Information->EndingAddress.LowPart, Information->CurrentAddress.LowPart);
 
    return ESUCCESS;
}

IsoGetVolumeSize()

ULONGLONG IsoGetVolumeSize

(

_In_ ULONG

DeviceId

)

Returns the size of the ISO-9660 volume laid on the storage media device opened via DeviceId.

This routine is in particular used to determine the useful (volume) size of a CD-ROM media.

Definition at line 583 of file iso.c.

{
    PISO_VOLUME_INFO Volume = IsoVolumes[DeviceId];
    ASSERT(Volume);
    return (ULONGLONG)Volume->VolumeSizeLBN * Volume->LogicalBlockSize;
}

Referenced by FsGetVolumeSize().

IsoLastPathSeparator()

static PCSTR IsoLastPathSeparator ( _In_ PCSTR  Path )

static

Definition at line 48 of file iso.c.

{
    PCSTR Last = NULL;
 
    ASSERT(Path != NULL);
 
    while (*Path != ANSI_NULL)
    {
        if (*Path == '\\' || *Path == '/')
            Last = Path;
 
        ++Path;
    }
 
    return Last;
}

Referenced by IsoLookupFile().

IsoLookupFile()

static ARC_STATUS IsoLookupFile ( PCSTR  FileName, ULONG  DeviceId, PISO_FILE_INFO  IsoFileInfo  )

static

Definition at line 178 of file iso.c.

{
    PCSTR FullPath = FileName;
    PISO_VOLUME_INFO Volume;
    PCSTR FileNameStr;
    ULONG i, DirectoryPathLength, DirectorySector, DirectoryLength;
    PVOID DirectoryBuffer;
    ULONG NumberOfPathParts;
    CHAR PathBuffer[261];
    CHAR* PathPart;
    ARC_STATUS Status;
    BOOLEAN DoFullLookup;
    UCHAR FileAttributes;
 
    TRACE("IsoLookupFile() FileName = %s\n", FileName);
 
    Volume = IsoVolumes[DeviceId];
 
    /*
     * Extract the file name
     * '\test.ini' --> 'test.ini'
     * '\folder\app.exe' --> 'app.exe'
     */
    FileNameStr = IsoLastPathSeparator(FileName) + 1;
 
    /*
     * Extract the directory path, including trailing slash
     * '\test.ini' --> '\'
     * '\folder\app.exe' --> '\folder\'
     */
    DirectoryPathLength = FileNameStr - FileName;
 
    /* See if this directory has been buffered before */
    DoFullLookup = (DirectoryPathLength != Volume->DirectoryPathLength) ||
                   !RtlEqualMemory(FileName, Volume->DirectoryPath, DirectoryPathLength);
    if (!DoFullLookup)
    {
        PathPart = (CHAR*)FileNameStr;
        DirectoryBuffer = Volume->DirectoryBuffer;
        DirectoryLength = Volume->DirectoryLength;
 
        NumberOfPathParts = 1;
    }
    else
    {
        PathPart = PathBuffer;
        DirectorySector = Volume->PvdDirectorySector;
        DirectoryLength = Volume->PvdDirectoryLength;
 
        /* Skip leading path separator, if any */
        if (*FileName == '\\' || *FileName == '/')
            ++FileName;
        PathPart[0] = ANSI_NULL;
 
        /* Figure out how many sub-directories we are nested in */
        NumberOfPathParts = FsGetNumPathParts(FileName);
    }
 
    //
    // Loop once for each part
    //
    for (i=0; i<NumberOfPathParts; i++)
    {
        if (DoFullLookup)
        {
            /* Get first path part */
            FsGetFirstNameFromPath(PathPart, FileName);
 
            /* Advance to the next part of the path */
            while ((*FileName != ANSI_NULL) && (*FileName != '\\') && (*FileName != '/'))
            {
                FileName++;
            }
            FileName++;
 
            /* Buffer the directory contents */
            Status = IsoBufferDirectory(DeviceId,
                                        DirectorySector,
                                        DirectoryLength,
                                        &DirectoryBuffer);
            if (Status != ESUCCESS)
                return Status;
 
            /* Save the directory buffer */
            if ((i + 1) >= NumberOfPathParts)
            {
                if (Volume->DirectoryBuffer)
                    FrLdrTempFree(Volume->DirectoryBuffer, TAG_ISO_BUFFER);
 
                Volume->DirectoryPathLength = DirectoryPathLength;
                Volume->DirectoryBuffer = DirectoryBuffer;
                Volume->DirectoryLength = DirectoryLength;
 
                RtlCopyMemory(Volume->DirectoryPath, FullPath, DirectoryPathLength);
            }
        }
 
        /* Search for file name in directory */
        if (!IsoSearchDirectoryBufferForFile(DirectoryBuffer,
                                             DirectoryLength,
                                             PathPart,
                                             IsoFileInfo))
        {
            /* Free the directory buffer that wasn't cached */
            if ((i + 1) < NumberOfPathParts)
            {
                ASSERT(DirectoryBuffer != Volume->DirectoryBuffer);
                FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
            }
            return ENOENT;
        }
 
        //
        // If we have another sub-directory to go then
        // grab the start sector and file size
        //
        if ((i+1) < NumberOfPathParts)
        {
            FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
 
            DirectorySector = IsoFileInfo->FileStart;
            DirectoryLength = IsoFileInfo->FileSize;
        }
    }
 
    /* Re-map the attributes to ARC file attributes */
    FileAttributes = IsoFileInfo->Attributes;
    IsoFileInfo->Attributes = ReadOnlyFile;
    if (FileAttributes & ISO_ATTR_HIDDEN)
        IsoFileInfo->Attributes |= HiddenFile;
    if (FileAttributes & ISO_ATTR_DIRECTORY)
        IsoFileInfo->Attributes |= DirectoryFile;
 
    /* Copy the file name, perhaps truncated */
    IsoFileInfo->FileNameLength = (ULONG)strlen(PathPart);
    IsoFileInfo->FileNameLength = min(IsoFileInfo->FileNameLength, sizeof(IsoFileInfo->FileName) - 1);
    RtlCopyMemory(IsoFileInfo->FileName, PathPart, IsoFileInfo->FileNameLength);
 
    return ESUCCESS;
}

Referenced by IsoOpen().

IsoMount()

const DEVVTBL * IsoMount

(

ULONG

DeviceId

)

Definition at line 602 of file iso.c.

{
    UCHAR Buffer[SECTORSIZE];
    PPVD Pvd = (PPVD)Buffer;
    LARGE_INTEGER Position;
    ULONG Count;
    ARC_STATUS Status;
    PISO_VOLUME_INFO Volume;
 
    TRACE("Enter IsoMount(%lu)\n", DeviceId);
 
    /* Read the ISO Primary Volume Descriptor */
    Position.QuadPart = 16 * SECTORSIZE;
    Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
        return NULL;
    Status = ArcRead(DeviceId, Pvd, SECTORSIZE, &Count);
    if (Status != ESUCCESS || Count < sizeof(PVD))
        return NULL;
 
    /* Check whether the PVD is valid */
    if (!(Pvd->VdType == 1 && RtlEqualMemory(Pvd->StandardId, "CD001", 5) && Pvd->VdVersion == 1))
    {
        WARN("Unrecognized CD-ROM format\n");
        return NULL;
    }
    if (Pvd->LogicalBlockSizeL != SECTORSIZE)
    {
        ERR("Unsupported LogicalBlockSize %u\n", Pvd->LogicalBlockSizeL);
        return NULL;
    }
 
    Count = (ULONG)((ULONGLONG)Pvd->VolumeSpaceSizeL * SECTORSIZE / 1024 / 1024);
    TRACE("Recognized ISO9660 drive, size %lu MB (%lu sectors)\n",
          Count, Pvd->VolumeSpaceSizeL);
 
    Volume = FrLdrTempAlloc(sizeof(*Volume), TAG_ISO_VOLUME);
    if (!Volume)
        return NULL;
    RtlZeroMemory(Volume, sizeof(*Volume));
 
    /*
     * This is equivalent to using the RAW_ISO_VD::VolSpaceI field:
     * https://github.com/reactos/reactos/blob/435482912c6dc0aaa4371e37b7336b2b1291e65f/drivers/filesystems/cdfs/cd.h#L126
     * and also what MS CDFS does with the CdRvdVolSz() macro,
     * in cdfs/strucsup.c!CdUpdateVcbFromVolDescriptor().
     */
    Volume->VolumeSizeLBN = Pvd->VolumeSpaceSizeL;
    Volume->LogicalBlockSize = Pvd->LogicalBlockSizeL;
 
    /* Cache some useful PVD information */
    Volume->PvdDirectorySector = Pvd->RootDirRecord.ExtentLocationL;
    Volume->PvdDirectoryLength = Pvd->RootDirRecord.DataLengthL;
 
    IsoVolumes[DeviceId] = Volume;
 
    /* Everything OK, return the ISO9660 function table */
    return &Iso9660FuncTable;
}

IsoOpen()

static ARC_STATUS IsoOpen ( CHAR *  Path, OPENMODE  OpenMode, ULONG *  FileId  )

static

Definition at line 351 of file iso.c.

{
    PISO_FILE_INFO FileHandle;
    ULONG DeviceId;
    ARC_STATUS Status;
 
    if (OpenMode != OpenReadOnly)
        return EACCES;
 
    DeviceId = FsGetDeviceId(*FileId);
 
    TRACE("IsoOpen() FileName = %s\n", Path);
 
    FileHandle = FrLdrTempAlloc(sizeof(*FileHandle), TAG_ISO_FILE);
    if (!FileHandle)
        return ENOMEM;
 
    Status = IsoLookupFile(Path, DeviceId, FileHandle);
    if (Status != ESUCCESS)
    {
        FrLdrTempFree(FileHandle, TAG_ISO_FILE);
        return ENOENT;
    }
 
    FsSetDeviceSpecific(*FileId, FileHandle);
    return ESUCCESS;
}

IsoRead()

static ARC_STATUS IsoRead ( ULONG  FileId, VOID *  Buffer, ULONG  N, ULONG *  Count  )

static

Definition at line 380 of file iso.c.

{
    ARC_STATUS Status;
    PISO_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    UCHAR SectorBuffer[SECTORSIZE];
    LARGE_INTEGER Position;
    ULONG DeviceId;
    ULONG SectorNumber;
    ULONG OffsetInSector;
    ULONG LengthInSector;
    ULONG NumberOfSectors;
    ULONG BytesRead;
 
    TRACE("IsoRead() Buffer = %p, N = %lu\n", Buffer, N);
 
    DeviceId = FsGetDeviceId(FileId);
    *Count = 0;
 
    //
    // If the user is trying to read past the end of
    // the file then return success with Count == 0.
    //
    if (FileHandle->FilePointer >= FileHandle->FileSize)
    {
        return ESUCCESS;
    }
 
    //
    // If the user is trying to read more than there is to read
    // then adjust the amount to read.
    //
    if (FileHandle->FilePointer + N > FileHandle->FileSize)
    {
        N = FileHandle->FileSize - FileHandle->FilePointer;
    }
 
    //
    // Ok, now we have to perform at most 3 calculations
    // I'll draw you a picture (using nifty ASCII art):
    //
    // CurrentFilePointer -+
    //                     |
    //    +----------------+
    //    |
    // +-----------+-----------+-----------+-----------+
    // | Sector  1 | Sector  2 | Sector  3 | Sector  4 |
    // +-----------+-----------+-----------+-----------+
    //    |                                    |
    //    +---------------+--------------------+
    //                    |
    // N -----------------+
    //
    // 1 - The first calculation (and read) will align
    //     the file pointer with the next sector
    //     boundary (if we are supposed to read that much)
    // 2 - The next calculation (and read) will read
    //     in all the full sectors that the requested
    //     amount of data would cover (in this case
    //     sectors 2 & 3).
    // 3 - The last calculation (and read) would read
    //     in the remainder of the data requested out of
    //     the last sector.
    //
 
 
    //
    // Only do the first read if we
    // aren't aligned on a cluster boundary
    //
    if (FileHandle->FilePointer % SECTORSIZE)
    {
        //
        // Do the math for our first read
        //
        SectorNumber = FileHandle->FileStart + (FileHandle->FilePointer / SECTORSIZE);
        OffsetInSector = FileHandle->FilePointer % SECTORSIZE;
        LengthInSector = min(N, SECTORSIZE - OffsetInSector);
 
        //
        // Now do the read and update Count, N, FilePointer, & Buffer
        //
        Position.HighPart = 0;
        Position.LowPart = SectorNumber * SECTORSIZE;
        Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
        if (Status != ESUCCESS)
        {
            return Status;
        }
        Status = ArcRead(DeviceId, SectorBuffer, SECTORSIZE, &BytesRead);
        if (Status != ESUCCESS || BytesRead != SECTORSIZE)
        {
            return EIO;
        }
        RtlCopyMemory(Buffer, SectorBuffer + OffsetInSector, LengthInSector);
        *Count += LengthInSector;
        N -= LengthInSector;
        FileHandle->FilePointer += LengthInSector;
        Buffer = (PVOID)((ULONG_PTR)Buffer + LengthInSector);
    }
 
    //
    // Do the math for our second read (if any data left)
    //
    if (N > 0)
    {
        //
        // Determine how many full clusters we need to read
        //
        NumberOfSectors = (N / SECTORSIZE);
 
        SectorNumber = FileHandle->FileStart + (FileHandle->FilePointer / SECTORSIZE);
 
        //
        // Now do the read and update Count, N, FilePointer, & Buffer
        //
        Position.HighPart = 0;
        Position.LowPart = SectorNumber * SECTORSIZE;
        Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
        if (Status != ESUCCESS)
        {
            return Status;
        }
        Status = ArcRead(DeviceId, Buffer, NumberOfSectors * SECTORSIZE, &BytesRead);
        if (Status != ESUCCESS || BytesRead != NumberOfSectors * SECTORSIZE)
        {
            return EIO;
        }
 
        *Count += NumberOfSectors * SECTORSIZE;
        N -= NumberOfSectors * SECTORSIZE;
        FileHandle->FilePointer += NumberOfSectors * SECTORSIZE;
        Buffer = (PVOID)((ULONG_PTR)Buffer + NumberOfSectors * SECTORSIZE);
    }
 
    //
    // Do the math for our third read (if any data left)
    //
    if (N > 0)
    {
        SectorNumber = FileHandle->FileStart + (FileHandle->FilePointer / SECTORSIZE);
 
        //
        // Now do the read and update Count, N, FilePointer, & Buffer
        //
        Position.HighPart = 0;
        Position.LowPart = SectorNumber * SECTORSIZE;
        Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
        if (Status != ESUCCESS)
        {
            return Status;
        }
        Status = ArcRead(DeviceId, SectorBuffer, SECTORSIZE, &BytesRead);
        if (Status != ESUCCESS || BytesRead != SECTORSIZE)
        {
            return EIO;
        }
        RtlCopyMemory(Buffer, SectorBuffer, N);
        *Count += N;
        FileHandle->FilePointer += N;
    }
 
    TRACE("IsoRead() done\n");
 
    return ESUCCESS;
}

IsoSearchDirectoryBufferForFile()

static BOOLEAN IsoSearchDirectoryBufferForFile ( PVOID  DirectoryBuffer, ULONG  DirectoryLength, PCHAR  FileName, PISO_FILE_INFO  IsoFileInfoPointer  )

static

Definition at line 66 of file iso.c.

{
    PDIR_RECORD    Record;
    ULONG        Offset;
    ULONG i;
    CHAR Name[32];
 
    TRACE("IsoSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x DirectoryLength = %d FileName = %s\n", DirectoryBuffer, DirectoryLength, FileName);
 
    Offset = 0;
    Record = (PDIR_RECORD)DirectoryBuffer;
    while (TRUE)
    {
        Offset = Offset + Record->RecordLength;
        Record = (PDIR_RECORD)((ULONG_PTR)DirectoryBuffer + Offset);
 
        if (Record->RecordLength == 0)
        {
            Offset = ROUND_UP(Offset, SECTORSIZE);
            Record = (PDIR_RECORD)((ULONG_PTR)DirectoryBuffer + Offset);
        }
 
        if (Offset >= DirectoryLength)
            return FALSE;
 
        if (Record->FileIdLength == 1 && Record->FileId[0] == 0)
        {
            TRACE("Name '.'\n");
        }
        else if (Record->FileIdLength == 1 && Record->FileId[0] == 1)
        {
            TRACE("Name '..'\n");
        }
        else
        {
            for (i = 0; i < Record->FileIdLength && Record->FileId[i] != ';'; i++)
                Name[i] = Record->FileId[i];
            Name[i] = ANSI_NULL;
            TRACE("Name '%s'\n", Name);
 
            if (_stricmp(FileName, Name) == 0)
            {
                IsoFileInfoPointer->FileStart = Record->ExtentLocationL;
                IsoFileInfoPointer->FileSize = Record->DataLengthL;
                IsoFileInfoPointer->FilePointer = 0;
                IsoFileInfoPointer->Attributes = Record->FileFlags;
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by IsoLookupFile().

IsoSeek()

static ARC_STATUS IsoSeek ( ULONG  FileId, LARGE_INTEGER *  Position, SEEKMODE  SeekMode  )

static

Definition at line 547 of file iso.c.

{
    PISO_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    LARGE_INTEGER NewPosition = *Position;
 
    switch (SeekMode)
    {
        case SeekAbsolute:
            break;
        case SeekRelative:
            NewPosition.QuadPart += (ULONGLONG)FileHandle->FilePointer;
            break;
        default:
            ASSERT(FALSE);
            return EINVAL;
    }
 
    if (NewPosition.HighPart != 0)
        return EINVAL;
    if (NewPosition.LowPart >= FileHandle->FileSize)
        return EINVAL;
 
    FileHandle->FilePointer = NewPosition.LowPart;
    return ESUCCESS;
}

Variable Documentation

Iso9660FuncTable

const DEVVTBL Iso9660FuncTable

static

Initial value:

=
{
    IsoClose,
    IsoGetFileInformation,
    IsoOpen,
    IsoRead,
    IsoSeek,
    L"cdfs",
}

Definition at line 592 of file iso.c.

Referenced by IsoMount().

IsoVolumes

PISO_VOLUME_INFO IsoVolumes[MAX_FDS]

static

Definition at line 44 of file iso.c.

Referenced by IsoGetVolumeSize(), IsoLookupFile(), and IsoMount().