ReactOS  0.4.13-dev-464-g6b95727
iso.c
Go to the documentation of this file.
1 /*
2  * FreeLoader
3  * Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>
4  * Copyright (C) 2009 Hervé Poussineau <hpoussin@reactos.org>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20 
21 #ifndef _M_ARM
22 #include <freeldr.h>
23 #include <debug.h>
24 
25 #define SECTORSIZE 2048
26 #define TAG_ISO_BUFFER 'BosI'
27 #define TAG_ISO_FILE 'FosI'
28 
29 DBG_DEFAULT_CHANNEL(FILESYSTEM);
30 
31 static BOOLEAN IsoSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectoryLength, PCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
32 {
34  ULONG Offset;
35  ULONG i;
36  CHAR Name[32];
37 
38  TRACE("IsoSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x DirectoryLength = %d FileName = %s\n", DirectoryBuffer, DirectoryLength, FileName);
39 
40  RtlZeroMemory(Name, 32 * sizeof(UCHAR));
41 
42  Offset = 0;
43  Record = (PDIR_RECORD)DirectoryBuffer;
44  while (TRUE)
45  {
46  Offset = Offset + Record->RecordLength;
47  Record = (PDIR_RECORD)((ULONG_PTR)DirectoryBuffer + Offset);
48 
49  if (Record->RecordLength == 0)
50  {
52  Record = (PDIR_RECORD)((ULONG_PTR)DirectoryBuffer + Offset);
53  }
54 
55  if (Offset >= DirectoryLength)
56  return FALSE;
57 
58  if (Record->FileIdLength == 1 && Record->FileId[0] == 0)
59  {
60  TRACE("Name '.'\n");
61  }
62  else if (Record->FileIdLength == 1 && Record->FileId[0] == 1)
63  {
64  TRACE("Name '..'\n");
65  }
66  else
67  {
68  for (i = 0; i < Record->FileIdLength && Record->FileId[i] != ';'; i++)
69  Name[i] = Record->FileId[i];
70  Name[i] = 0;
71  TRACE("Name '%s'\n", Name);
72 
73  if (strlen(FileName) == strlen(Name) && _stricmp(FileName, Name) == 0)
74  {
75  IsoFileInfoPointer->FileStart = Record->ExtentLocationL;
76  IsoFileInfoPointer->FileSize = Record->DataLengthL;
77  IsoFileInfoPointer->FilePointer = 0;
78  IsoFileInfoPointer->Directory = (Record->FileFlags & 0x02)?TRUE:FALSE;
79 
80  return TRUE;
81  }
82 
83  }
84 
85  RtlZeroMemory(Name, 32 * sizeof(UCHAR));
86  }
87 
88  return FALSE;
89 }
90 
91 
92 /*
93  * IsoBufferDirectory()
94  * This function allocates a buffer, reads the specified directory
95  * and returns a pointer to that buffer into pDirectoryBuffer. The
96  * function returns an ARC error code. The directory is specified
97  * by its starting sector and length.
98  */
99 static ARC_STATUS IsoBufferDirectory(ULONG DeviceId, ULONG DirectoryStartSector, ULONG DirectoryLength,
100  PVOID* pDirectoryBuffer)
101 {
102  PVOID DirectoryBuffer;
105  ULONG Count;
107 
108  TRACE("IsoBufferDirectory() DirectoryStartSector = %d DirectoryLength = %d\n", DirectoryStartSector, DirectoryLength);
109 
110  SectorCount = ROUND_UP(DirectoryLength, SECTORSIZE) / SECTORSIZE;
111  TRACE("Trying to read (DirectoryCount) %d sectors.\n", SectorCount);
112 
113  //
114  // Attempt to allocate memory for directory buffer
115  //
116  TRACE("Trying to allocate (DirectoryLength) %d bytes.\n", DirectoryLength);
117  DirectoryBuffer = FrLdrTempAlloc(DirectoryLength, TAG_ISO_BUFFER);
118  if (!DirectoryBuffer)
119  return ENOMEM;
120 
121  //
122  // Now read directory contents into DirectoryBuffer
123  //
124  Position.HighPart = 0;
125  Position.LowPart = DirectoryStartSector * SECTORSIZE;
126  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
127  if (Status != ESUCCESS)
128  {
129  FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
130  return Status;
131  }
132  Status = ArcRead(DeviceId, DirectoryBuffer, SectorCount * SECTORSIZE, &Count);
133  if (Status != ESUCCESS || Count != SectorCount * SECTORSIZE)
134  {
135  FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
136  return EIO;
137  }
138 
139  *pDirectoryBuffer = DirectoryBuffer;
140  return ESUCCESS;
141 }
142 
143 
144 /*
145  * IsoLookupFile()
146  * This function searches the file system for the
147  * specified filename and fills in an ISO_FILE_INFO structure
148  * with info describing the file, etc. returns ARC error code
149  */
150 static ARC_STATUS IsoLookupFile(PCSTR FileName, ULONG DeviceId, PISO_FILE_INFO IsoFileInfoPointer)
151 {
153  PPVD Pvd = (PPVD)Buffer;
154  UINT32 i;
155  ULONG NumberOfPathParts;
156  CHAR PathPart[261];
157  PVOID DirectoryBuffer;
158  ULONG DirectorySector;
159  ULONG DirectoryLength;
160  ISO_FILE_INFO IsoFileInfo;
162  ULONG Count;
164 
165  TRACE("IsoLookupFile() FileName = %s\n", FileName);
166 
167  RtlZeroMemory(IsoFileInfoPointer, sizeof(ISO_FILE_INFO));
168  RtlZeroMemory(&IsoFileInfo, sizeof(ISO_FILE_INFO));
169 
170  //
171  // Read The Primary Volume Descriptor
172  //
173  Position.HighPart = 0;
174  Position.LowPart = 16 * SECTORSIZE;
175  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
176  if (Status != ESUCCESS)
177  return Status;
178  Status = ArcRead(DeviceId, Pvd, SECTORSIZE, &Count);
179  if (Status != ESUCCESS || Count < sizeof(PVD))
180  return EIO;
181 
182  DirectorySector = Pvd->RootDirRecord.ExtentLocationL;
183  DirectoryLength = Pvd->RootDirRecord.DataLengthL;
184 
185  //
186  // Figure out how many sub-directories we are nested in
187  //
188  NumberOfPathParts = FsGetNumPathParts(FileName);
189 
190  //
191  // Loop once for each part
192  //
193  for (i=0; i<NumberOfPathParts; i++)
194  {
195  //
196  // Get first path part
197  //
198  FsGetFirstNameFromPath(PathPart, FileName);
199 
200  //
201  // Advance to the next part of the path
202  //
203  for (; (*FileName != '\\') && (*FileName != '/') && (*FileName != '\0'); FileName++)
204  {
205  }
206  FileName++;
207 
208  //
209  // Buffer the directory contents
210  //
211  Status = IsoBufferDirectory(DeviceId, DirectorySector, DirectoryLength, &DirectoryBuffer);
212  if (Status != ESUCCESS)
213  return Status;
214 
215  //
216  // Search for file name in directory
217  //
218  if (!IsoSearchDirectoryBufferForFile(DirectoryBuffer, DirectoryLength, PathPart, &IsoFileInfo))
219  {
220  FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
221  return ENOENT;
222  }
223 
224  FrLdrTempFree(DirectoryBuffer, TAG_ISO_BUFFER);
225 
226  //
227  // If we have another sub-directory to go then
228  // grab the start sector and file size
229  //
230  if ((i+1) < NumberOfPathParts)
231  {
232  DirectorySector = IsoFileInfo.FileStart;
233  DirectoryLength = IsoFileInfo.FileSize;
234  }
235 
236  }
237 
238  RtlCopyMemory(IsoFileInfoPointer, &IsoFileInfo, sizeof(ISO_FILE_INFO));
239 
240  return ESUCCESS;
241 }
242 
244 {
246 
248 
249  return ESUCCESS;
250 }
251 
253 {
255 
256  TRACE("IsoGetFileInformation() FileSize = %d\n", FileHandle->FileSize);
257  TRACE("IsoGetFileInformation() FilePointer = %d\n", FileHandle->FilePointer);
258 
260  Information->EndingAddress.LowPart = FileHandle->FileSize;
261  Information->CurrentAddress.LowPart = FileHandle->FilePointer;
262 
263  return ESUCCESS;
264 }
265 
266 ARC_STATUS IsoOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
267 {
268  ISO_FILE_INFO TempFileInfo;
270  ULONG DeviceId;
272 
273  if (OpenMode != OpenReadOnly)
274  return EACCES;
275 
276  DeviceId = FsGetDeviceId(*FileId);
277 
278  TRACE("IsoOpen() FileName = %s\n", Path);
279 
280  RtlZeroMemory(&TempFileInfo, sizeof(TempFileInfo));
281  Status = IsoLookupFile(Path, DeviceId, &TempFileInfo);
282  if (Status != ESUCCESS)
283  return ENOENT;
284 
286  if (!FileHandle)
287  return ENOMEM;
288 
289  RtlCopyMemory(FileHandle, &TempFileInfo, sizeof(ISO_FILE_INFO));
290 
292  return ESUCCESS;
293 }
294 
296 {
298  UCHAR SectorBuffer[SECTORSIZE];
300  ULONG DeviceId;
301  ULONG FilePointer;
302  ULONG SectorNumber;
303  ULONG OffsetInSector;
304  ULONG LengthInSector;
305  ULONG NumberOfSectors;
308 
309  TRACE("IsoRead() Buffer = %p, N = %lu\n", Buffer, N);
310 
311  DeviceId = FsGetDeviceId(FileId);
312  *Count = 0;
313 
314  //
315  // If they are trying to read past the
316  // end of the file then return success
317  // with Count == 0
318  //
319  FilePointer = FileHandle->FilePointer;
320  if (FilePointer >= FileHandle->FileSize)
321  {
322  return ESUCCESS;
323  }
324 
325  //
326  // If they are trying to read more than there is to read
327  // then adjust the amount to read
328  //
329  if (FilePointer + N > FileHandle->FileSize)
330  {
331  N = FileHandle->FileSize - FilePointer;
332  }
333 
334  //
335  // Ok, now we have to perform at most 3 calculations
336  // I'll draw you a picture (using nifty ASCII art):
337  //
338  // CurrentFilePointer -+
339  // |
340  // +----------------+
341  // |
342  // +-----------+-----------+-----------+-----------+
343  // | Sector 1 | Sector 2 | Sector 3 | Sector 4 |
344  // +-----------+-----------+-----------+-----------+
345  // | |
346  // +---------------+--------------------+
347  // |
348  // N -----------------+
349  //
350  // 1 - The first calculation (and read) will align
351  // the file pointer with the next sector
352  // boundary (if we are supposed to read that much)
353  // 2 - The next calculation (and read) will read
354  // in all the full sectors that the requested
355  // amount of data would cover (in this case
356  // sectors 2 & 3).
357  // 3 - The last calculation (and read) would read
358  // in the remainder of the data requested out of
359  // the last sector.
360  //
361 
362 
363  //
364  // Only do the first read if we
365  // aren't aligned on a cluster boundary
366  //
367  if (FilePointer % SECTORSIZE)
368  {
369  //
370  // Do the math for our first read
371  //
372  SectorNumber = FileHandle->FileStart + (FilePointer / SECTORSIZE);
373  OffsetInSector = FilePointer % SECTORSIZE;
374  LengthInSector = (N > (SECTORSIZE - OffsetInSector)) ? (SECTORSIZE - OffsetInSector) : N;
375 
376  //
377  // Now do the read and update Count, N, FilePointer, & Buffer
378  //
379  Position.HighPart = 0;
380  Position.LowPart = SectorNumber * SECTORSIZE;
381  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
382  if (Status != ESUCCESS)
383  {
384  return Status;
385  }
386  Status = ArcRead(DeviceId, SectorBuffer, SECTORSIZE, &BytesRead);
387  if (Status != ESUCCESS || BytesRead != SECTORSIZE)
388  {
389  return EIO;
390  }
391  RtlCopyMemory(Buffer, SectorBuffer + OffsetInSector, LengthInSector);
392  *Count += LengthInSector;
393  N -= LengthInSector;
394  FilePointer += LengthInSector;
395  Buffer = (PVOID)((ULONG_PTR)Buffer + LengthInSector);
396  }
397 
398  //
399  // Do the math for our second read (if any data left)
400  //
401  if (N > 0)
402  {
403  //
404  // Determine how many full clusters we need to read
405  //
406  NumberOfSectors = (N / SECTORSIZE);
407 
408  SectorNumber = FileHandle->FileStart + (FilePointer / SECTORSIZE);
409 
410  //
411  // Now do the read and update Count, N, FilePointer, & Buffer
412  //
413  Position.HighPart = 0;
414  Position.LowPart = SectorNumber * SECTORSIZE;
415  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
416  if (Status != ESUCCESS)
417  {
418  return Status;
419  }
420  Status = ArcRead(DeviceId, Buffer, NumberOfSectors * SECTORSIZE, &BytesRead);
421  if (Status != ESUCCESS || BytesRead != NumberOfSectors * SECTORSIZE)
422  {
423  return EIO;
424  }
425 
426  *Count += NumberOfSectors * SECTORSIZE;
427  N -= NumberOfSectors * SECTORSIZE;
428  FilePointer += NumberOfSectors * SECTORSIZE;
429  Buffer = (PVOID)((ULONG_PTR)Buffer + NumberOfSectors * SECTORSIZE);
430  }
431 
432  //
433  // Do the math for our third read (if any data left)
434  //
435  if (N > 0)
436  {
437  SectorNumber = FileHandle->FileStart + (FilePointer / SECTORSIZE);
438 
439  //
440  // Now do the read and update Count, N, FilePointer, & Buffer
441  //
442  Position.HighPart = 0;
443  Position.LowPart = SectorNumber * SECTORSIZE;
444  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
445  if (Status != ESUCCESS)
446  {
447  return Status;
448  }
449  Status = ArcRead(DeviceId, SectorBuffer, SECTORSIZE, &BytesRead);
450  if (Status != ESUCCESS || BytesRead != SECTORSIZE)
451  {
452  return EIO;
453  }
454  RtlCopyMemory(Buffer, SectorBuffer, N);
455  *Count += N;
456  FilePointer += N;
457  }
458 
459  TRACE("IsoRead() done\n");
460 
461  return ESUCCESS;
462 }
463 
465 {
467 
468  TRACE("IsoSeek() NewFilePointer = %lu\n", Position->LowPart);
469 
470  if (SeekMode != SeekAbsolute)
471  return EINVAL;
472  if (Position->HighPart != 0)
473  return EINVAL;
474  if (Position->LowPart >= FileHandle->FileSize)
475  return EINVAL;
476 
477  FileHandle->FilePointer = Position->LowPart;
478  return ESUCCESS;
479 }
480 
482 {
483  IsoClose,
485  IsoOpen,
486  IsoRead,
487  IsoSeek,
488  L"cdfs",
489 };
490 
491 const DEVVTBL* IsoMount(ULONG DeviceId)
492 {
494  PPVD Pvd = (PPVD)Buffer;
496  ULONG Count;
498 
499  //
500  // Read The Primary Volume Descriptor
501  //
502  Position.HighPart = 0;
503  Position.LowPart = 16 * SECTORSIZE;
504  Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
505  if (Status != ESUCCESS)
506  return NULL;
507  Status = ArcRead(DeviceId, Pvd, SECTORSIZE, &Count);
508  if (Status != ESUCCESS || Count < sizeof(PVD))
509  return NULL;
510 
511  //
512  // Check if PVD is valid. If yes, return ISO9660 function table
513  //
514  if (Pvd->VdType == 1 && RtlEqualMemory(Pvd->StandardId, "CD001", 5))
515  return &Iso9660FuncTable;
516  else
517  return NULL;
518 }
519 
520 #endif
521 
signed char * PCHAR
Definition: retypes.h:7
const DEVVTBL * IsoMount(ULONG DeviceId)
Definition: iso.c:491
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define ROUND_UP(n, align)
Definition: eventvwr.h:31
VOID FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path)
Definition: fs.c:414
Definition: arc.h:32
static ARC_STATUS IsoLookupFile(PCSTR FileName, ULONG DeviceId, PISO_FILE_INFO IsoFileInfoPointer)
Definition: iso.c:150
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
Definition: arc.h:39
static COORD Position
Definition: mouse.c:34
char CHAR
Definition: xmlstorage.h:175
DIR_RECORD RootDirRecord
Definition: iso.h:80
Definition: fs.h:22
ULONG FsGetNumPathParts(PCSTR Path)
Definition: fs.c:386
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
ULONG ARC_STATUS
Definition: arc.h:4
BOOLEAN Directory
Definition: iso.h:97
#define _stricmp
Definition: cat.c:22
VOID * FsGetDeviceSpecific(ULONG FileId)
Definition: fs.c:474
#define TAG_ISO_FILE
Definition: iso.c:27
Definition: arc.h:48
uint32_t ULONG_PTR
Definition: typedefs.h:63
DBG_DEFAULT_CHANNEL(FILESYSTEM)
HANDLE FileHandle
Definition: stats.c:38
_In_ struct _KBUGCHECK_REASON_CALLBACK_RECORD * Record
Definition: ketypes.h:256
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
unsigned int UINT32
Definition: iso.h:59
ULONG FileStart
Definition: iso.h:94
FORCEINLINE PVOID FrLdrTempAlloc(_In_ SIZE_T Size, _In_ ULONG Tag)
Definition: mm.h:177
ARC_STATUS IsoSeek(ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
Definition: iso.c:464
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
ARC_STATUS IsoRead(ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
Definition: iso.c:295
enum _SEEKMODE SEEKMODE
Definition: bufpool.h:45
void * PVOID
Definition: retypes.h:9
struct _DIR_RECORD * PDIR_RECORD
Definition: iso.h:45
#define TAG_ISO_BUFFER
Definition: iso.c:26
ARC_STATUS IsoGetFileInformation(ULONG FileId, FILEINFORMATION *Information)
Definition: iso.c:252
CHAR StandardId[5]
Definition: iso.h:62
#define TRACE(s)
Definition: solgame.cpp:4
NTSYSAPI ULONG NTAPI RtlEqualMemory(CONST VOID *Source1, CONST VOID *Source2, ULONG Length)
VOID FsSetDeviceSpecific(ULONG FileId, VOID *Specific)
Definition: fs.c:467
#define SECTORSIZE
Definition: iso.c:25
ULONG FilePointer
Definition: iso.h:96
ARC_STATUS ArcRead(ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
Definition: fs.c:237
unsigned char UCHAR
Definition: xmlstorage.h:181
Definition: arc.h:34
static const WCHAR L[]
Definition: oid.c:1250
ARC_STATUS IsoClose(ULONG FileId)
Definition: iso.c:243
struct _PVD * PPVD
Definition: iso.h:88
ARC_STATUS ArcSeek(ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
Definition: fs.c:244
ULONG SectorCount
Definition: part_xbox.c:32
static BOOLEAN IsoSearchDirectoryBufferForFile(PVOID DirectoryBuffer, ULONG DirectoryLength, PCHAR FileName, PISO_FILE_INFO IsoFileInfoPointer)
Definition: iso.c:31
Status
Definition: gdiplustypes.h:24
ULONG ExtentLocationL
Definition: iso.h:27
PRTL_UNICODE_STRING_BUFFER Path
Definition: arc.h:46
ARC_STATUS IsoOpen(CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
Definition: iso.c:266
Definition: arc.h:40
ULONG FsGetDeviceId(ULONG FileId)
Definition: fs.c:481
unsigned int ULONG
Definition: retypes.h:1
ULONG FileSize
Definition: iso.h:95
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
const char * PCSTR
Definition: typedefs.h:51
ULONG DataLengthL
Definition: iso.h:29
enum _OPENMODE OPENMODE
UCHAR VdType
Definition: iso.h:61
static ARC_STATUS IsoBufferDirectory(ULONG DeviceId, ULONG DirectoryStartSector, ULONG DirectoryLength, PVOID *pDirectoryBuffer)
Definition: iso.c:99
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesRead
Definition: fltkernel.h:1255
Iosb Information
Definition: create.c:4377
const DEVVTBL Iso9660FuncTable
Definition: iso.c:481
FORCEINLINE VOID FrLdrTempFree(PVOID Allocation, ULONG Tag)
Definition: mm.h:186