cddata.c File Reference

#include "cdprocs.h"

Include dependency graph for cddata.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_CDDATA)

Functions
	_IRQL_requires_max_ (APC_LEVEL)
LONG	CdExceptionFilter (_Inout_ PIRP_CONTEXT IrpContext, _In_ PEXCEPTION_POINTERS ExceptionPointer)
	_Requires_lock_held_ (_Global_critical_region_)
VOID	CdCompleteRequest (_Inout_opt_ PIRP_CONTEXT IrpContext, _Inout_opt_ PIRP Irp, _In_ NTSTATUS Status)
VOID	CdSetThreadContext (_Inout_ PIRP_CONTEXT IrpContext, _In_ PTHREAD_CONTEXT ThreadContext)
	_Function_class_ (FAST_IO_CHECK_IF_POSSIBLE)
ULONG	CdSerial32 (_In_reads_bytes_(ByteCount) PCHAR Buffer, _In_ ULONG ByteCount)

Variables
CD_DATA	CdData
FAST_IO_DISPATCH	CdFastIoDispatch
WCHAR	CdUnicodeSelfArray [] = { L'.' }
WCHAR	CdUnicodeParentArray [] = { L'.', L'.' }
UNICODE_STRING	CdUnicodeDirectoryNames []
CHAR	CdHsgId [] = { 'C', 'D', 'R', 'O', 'M' }
CHAR	CdIsoId [] = { 'C', 'D', '0', '0', '1' }
CHAR	CdXaId [] = { 'C', 'D', '-', 'X', 'A', '0', '0', '1' }
WCHAR	CdAudioLabel [] = { L'A', L'u', L'd', L'i', L'o', L' ', L'C', L'D' }
USHORT	CdAudioLabelLength = sizeof( CdAudioLabel )
CHAR	CdAudioFileName [] = { 'T', 'r', 'a', 'c', 'k', '0', '0', '.', 'c', 'd', 'a' }
UCHAR	CdAudioFileNameLength = sizeof( CdAudioFileName )
ULONG	CdAudioDirentSize = FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName ) + sizeof( SYSTEM_USE_XA )
ULONG	CdAudioDirentsPerSector = SECTOR_SIZE / (FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName ) + sizeof( SYSTEM_USE_XA ))
ULONG	CdAudioSystemUseOffset = FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName )
PCHAR	CdJolietEscape [] = { "%/@", "%/C", "%/E" }
LONG	CdAudioPlayHeader []
LONG	CdXAAudioPhileHeader []
LONG	CdXAFileHeader []

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_CDDATA)

Definition at line 36 of file cddata.c.

Function Documentation

_Function_class_()

_Function_class_

(

FAST_IO_CHECK_IF_POSSIBLE

)

Definition at line 1090 of file cddata.c.

{
    PFCB Fcb;
    TYPE_OF_OPEN TypeOfOpen;
    LARGE_INTEGER LargeLength;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( Wait );
    UNREFERENCED_PARAMETER( DeviceObject );
 
    //
    //  Decode the type of file object we're being asked to process and
    //  make sure that is is only a user file open.
    //
 
    TypeOfOpen = CdFastDecodeFileObject( FileObject, &Fcb );
 
    if ((TypeOfOpen != UserFileOpen) || !CheckForReadOperation) {
 
        IoStatus->Status = STATUS_INVALID_PARAMETER;
        return TRUE;
    }
 
    LargeLength.QuadPart = Length;
 
    //
    //  Check whether the file locks will allow for fast io.
    //
 
    if ((Fcb->FileLock == NULL) ||
        FsRtlFastCheckLockForRead( Fcb->FileLock,
                                   FileOffset,
                                   &LargeLength,
                                   LockKey,
                                   FileObject,
                                   PsGetCurrentProcess() )) {
 
        return TRUE;
    }
 
    return FALSE;
}

_IRQL_requires_max_()

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 197 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;
 
#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif
 
    NTSTATUS Status;
 
#if DBG
 
    KIRQL SaveIrql = KeGetCurrentIrql();
 
#endif
 
    ASSERT_OPTIONAL_IRP( Irp );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif
 
    //
    //  Loop until this request has been completed or posted.
    //
 
    do {
 
        //
        //  Use a try-except to handle the exception cases.
        //
 
        _SEH2_TRY {
 
            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //
 
            if (IrpContext == NULL) {
 
                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //
 
                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
 
                    Wait = TRUE;
 
                } else {
 
                    Wait = CanFsdWait( Irp );
                }
 
                IrpContext = CdCreateIrpContext( Irp, Wait );
 
                //
                //  Update the thread context information.
                //
 
                CdSetThreadContext( IrpContext, &ThreadContext );
 
#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
 
            //
            //  Otherwise cleanup the IrpContext for the retry.
            //
 
            } else {
 
                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }
 
            //
            //  Case on the major irp code.
            //
 
            switch (IrpContext->MajorFunction) {
 
            case IRP_MJ_CREATE :
 
                Status = CdCommonCreate( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLOSE :
 
                Status = CdCommonClose( IrpContext, Irp );
                break;
 
            case IRP_MJ_READ :
 
                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //
 
                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
 
                    Status = CdCompleteMdl( IrpContext, Irp );
 
                } else {
 
                    Status = CdCommonRead( IrpContext, Irp );
                }
 
                break;
 
            case IRP_MJ_WRITE :
 
                Status = CdCommonWrite( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_INFORMATION :
 
                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_SET_INFORMATION :
 
                Status = CdCommonSetInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_VOLUME_INFORMATION :
 
                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_DIRECTORY_CONTROL :
 
                Status = CdCommonDirControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_FILE_SYSTEM_CONTROL :
 
                Status = CdCommonFsControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_DEVICE_CONTROL :
 
                Status = CdCommonDevControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_LOCK_CONTROL :
 
                Status = CdCommonLockControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLEANUP :
 
                Status = CdCommonCleanup( IrpContext, Irp );
                break;
 
            case IRP_MJ_PNP :
 
                Status = CdCommonPnp( IrpContext, Irp );
                break;
 
            case IRP_MJ_SHUTDOWN :
 
                Status = CdCommonShutdown( IrpContext, Irp );
                break;
 
            default :
 
                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }
 
        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;
 
    } while (Status == STATUS_CANT_WAIT);
 
#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
 
    FsRtlExitFileSystem();
 
    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
 
    return Status;
}

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 615 of file cddata.c.

{
    PDEVICE_OBJECT Device = NULL;
    PVPB Vpb;
    PETHREAD Thread;
 
    ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
    ASSERT_IRP( Irp );
 
    //
    //  If there is not an irp context, then complete the request with the
    //  current status code.
    //
 
    if (!ARGUMENT_PRESENT( IrpContext )) {
 
        CdCompleteRequest( NULL, Irp, ExceptionCode );
        return ExceptionCode;
    }
 
    //
    //  Get the real exception status from the IrpContext.
    //
 
    ExceptionCode = IrpContext->ExceptionStatus;
 
    //
    //  Check if we are posting this request.  One of the following must be true
    //  if we are to post a request.
    //
    //      - Status code is STATUS_CANT_WAIT and the request is asynchronous
    //          or we are forcing this to be posted.
    //
    //      - Status code is STATUS_VERIFY_REQUIRED and we are at APC level
    //          or higher, or within a guarded region.  Can't wait for IO in
    //          the verify path in this case.
    //
    //  Set the MORE_PROCESSING flag in the IrpContext to keep if from being
    //  deleted if this is a retryable condition.
    //
    //
    //  Note that (children of) CdFsdPostRequest can raise (Mdl allocation).
    //
 
    _SEH2_TRY {
 
        if (ExceptionCode == STATUS_CANT_WAIT) {
 
            if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST )) {
 
                ExceptionCode = CdFsdPostRequest( IrpContext, Irp );
            }
        }
        else if ((ExceptionCode == STATUS_VERIFY_REQUIRED) &&
                 FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) &&
                 KeAreAllApcsDisabled()) {
 
            ExceptionCode = CdFsdPostRequest( IrpContext, Irp );
        }
    }
    _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() ))  {
 
        ExceptionCode = _SEH2_GetExceptionCode();
    } _SEH2_END;
    //
    //  If we posted the request or our caller will retry then just return here.
    //
 
    if ((ExceptionCode == STATUS_PENDING) ||
        (ExceptionCode == STATUS_CANT_WAIT)) {
 
        return ExceptionCode;
    }
 
    ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
 
    //
    //  If we are not a top level request then we just complete the request
    //  with the current status code.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) {
 
        CdCompleteRequest( IrpContext, Irp, ExceptionCode );
        return ExceptionCode;
    }
 
    //
    //  Store this error into the Irp for posting back to the Io system.
    //
 
    Irp->IoStatus.Status = ExceptionCode;
 
    if (IoIsErrorUserInduced( ExceptionCode )) {
 
        //
        //  Check for the various error conditions that can be caused by,
        //  and possibly resolved my the user.
        //
 
        if (ExceptionCode == STATUS_VERIFY_REQUIRED) {
 
            //
            //  Now we are at the top level file system entry point.
            //
            //  If we have already posted this request then the device to
            //  verify is in the original thread.  Find this via the Irp.
            //
 
            Device = IoGetDeviceToVerify( Irp->Tail.Overlay.Thread );
            IoSetDeviceToVerify( Irp->Tail.Overlay.Thread, NULL );
 
            //
            //  If there is no device in that location then check in the
            //  current thread.
            //
 
            if (Device == NULL) {
 
                Device = IoGetDeviceToVerify( PsGetCurrentThread() );
                IoSetDeviceToVerify( PsGetCurrentThread(), NULL );
 
                NT_ASSERT( Device != NULL );
 
            }
 
            //
            //  It turns out some storage drivers really do set invalid non-NULL device
            //  objects to verify.
            //
            //  To work around this, completely ignore the device to verify in the thread,
            //  and just use our real device object instead.
            //
 
            if (IrpContext->Vcb) {
 
                Device = IrpContext->Vcb->Vpb->RealDevice;
            }
 
            //
            //  Let's not BugCheck just because the device to verify is somehow still NULL.
            //
 
            if (Device == NULL) {
 
                ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR;
 
                CdCompleteRequest( IrpContext, Irp, ExceptionCode );
 
                return ExceptionCode;
            }
 
            //
            //  CdPerformVerify() will do the right thing with the Irp.
            //  If we return STATUS_CANT_WAIT then the current thread
            //  can retry the request.
            //
 
            return CdPerformVerify( IrpContext, Irp, Device );
        }
 
        //
        //  The other user induced conditions generate an error unless
        //  they have been disabled for this request.
        //
 
        if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_POPUPS )) {
 
            CdCompleteRequest( IrpContext, Irp, ExceptionCode );
 
            return ExceptionCode;
 
        }
        //
        //  Generate a pop-up.
        //
        else {
 
            if (IoGetCurrentIrpStackLocation( Irp )->FileObject != NULL) {
 
                Vpb = IoGetCurrentIrpStackLocation( Irp )->FileObject->Vpb;
 
            } else {
 
                Vpb = NULL;
            }
 
 
            //
            //  The device to verify is either in my thread local storage
            //  or that of the thread that owns the Irp.
            //
 
            Thread = Irp->Tail.Overlay.Thread;
            Device = IoGetDeviceToVerify( Thread );
 
            if (Device == NULL) {
 
                Thread = PsGetCurrentThread();
                Device = IoGetDeviceToVerify( Thread );
 
                NT_ASSERT( Device != NULL );
            }
 
            //
            //  It turns out some storage drivers really do set invalid non-NULL device
            //  objects to verify.
            //
            //  To work around this, completely ignore the device to verify in the thread,
            //  and just use our real device object instead.
            //
 
            if (IrpContext->Vcb) {
 
                Device = IrpContext->Vcb->Vpb->RealDevice;
            }
 
            //
            //  Let's not BugCheck just because the device to verify is somehow still NULL.
            //
 
            if (Device == NULL) {
 
                CdCompleteRequest( IrpContext, Irp, ExceptionCode );
 
                return ExceptionCode;
            }
 
            //
            //  This routine actually causes the pop-up.  It usually
            //  does this by queuing an APC to the callers thread,
            //  but in some cases it will complete the request immediately,
            //  so it is very important to IoMarkIrpPending() first.
            //
 
            IoMarkIrpPending( Irp );
            IoRaiseHardError( Irp, Vpb, Device );
 
            //
            //  We will be handing control back to the caller here, so
            //  reset the saved device object.
            //
 
            IoSetDeviceToVerify( Thread, NULL );
 
            //
            //  The Irp will be completed by Io or resubmitted.  In either
            //  case we must clean up the IrpContext here.
            //
 
            CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
            return STATUS_PENDING;
        }
    }
 
    //
    //  This is just a run of the mill error.
    //
 
    CdCompleteRequest( IrpContext, Irp, ExceptionCode );
 
    return ExceptionCode;
}

CdCompleteRequest()

VOID CdCompleteRequest	(	_Inout_opt_ PIRP_CONTEXT	IrpContext,
		_Inout_opt_ PIRP	Irp,
		_In_ NTSTATUS	Status
	)

Definition at line 914 of file cddata.c.

{
    ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
    ASSERT_OPTIONAL_IRP( Irp );
 
    //
    //  Cleanup the IrpContext if passed in here.
    //
 
    if (ARGUMENT_PRESENT( IrpContext )) {
 
        CdCleanupIrpContext( IrpContext, FALSE );
    }
 
    //
    //  If we have an Irp then complete the irp.
    //
 
    if (ARGUMENT_PRESENT( Irp )) {
 
        //
        //  Clear the information field in case we have used this Irp
        //  internally.
        //
 
        if (NT_ERROR( Status ) &&
            FlagOn( Irp->Flags, IRP_INPUT_OPERATION )) {
 
            Irp->IoStatus.Information = 0;
        }
 
        Irp->IoStatus.Status = Status;
 
        AssertVerifyDeviceIrp( Irp );
 
        IoCompleteRequest( Irp, IO_CD_ROM_INCREMENT );
    }
 
    return;
}

Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), _Success_(), CdAllowExtendedDasdIo(), CdCommonDevControl(), CdCommonLockControl(), CdCompleteMdl(), CdFspDispatch(), CdIsPathnameValid(), CdIsVolumeDirty(), CdIsVolumeMounted(), and CdQueueClose().

CdExceptionFilter()

LONG CdExceptionFilter	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_In_ PEXCEPTION_POINTERS	ExceptionPointer
	)

Definition at line 525 of file cddata.c.

{
    NTSTATUS ExceptionCode;
    BOOLEAN TestStatus = TRUE;
 
    ASSERT_OPTIONAL_IRP_CONTEXT( IrpContext );
 
    ExceptionCode = ExceptionPointer->ExceptionRecord->ExceptionCode;
 
    //
    // If the exception is STATUS_IN_PAGE_ERROR, get the I/O error code
    // from the exception record.
    //
 
    if ((ExceptionCode == STATUS_IN_PAGE_ERROR) &&
        (ExceptionPointer->ExceptionRecord->NumberParameters >= 3)) {
 
        ExceptionCode =
            (NTSTATUS)ExceptionPointer->ExceptionRecord->ExceptionInformation[2];
    }
 
    //
    //  If there is an Irp context then check which status code to use.
    //
 
    if (ARGUMENT_PRESENT( IrpContext )) {
 
        if (IrpContext->ExceptionStatus == STATUS_SUCCESS) {
 
            //
            //  Store the real status into the IrpContext.
            //
 
            IrpContext->ExceptionStatus = ExceptionCode;
 
        } else {
 
            //
            //  No need to test the status code if we raised it ourselves.
            //
 
            TestStatus = FALSE;
        }
    }
 
    AssertVerifyDevice( IrpContext, IrpContext->ExceptionStatus );
 
    //
    //  Bug check if this status is not supported.
    //
 
    if (TestStatus && !FsRtlIsNtstatusExpected( ExceptionCode )) {
 
#ifdef _MSC_VER
#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "We're corrupted." )
#endif
        CdBugCheck( (ULONG_PTR) ExceptionPointer->ExceptionRecord,
                    (ULONG_PTR) ExceptionPointer->ContextRecord,
                    (ULONG_PTR) ExceptionPointer->ExceptionRecord->ExceptionAddress );
 
    }
 
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by _IRQL_requires_max_(), _Requires_lock_held_(), and CdFspDispatch().

CdSerial32()

ULONG CdSerial32	(	_In_reads_bytes_(ByteCount) PCHAR	Buffer,
		_In_ ULONG	ByteCount
	)

Definition at line 1185 of file cddata.c.

{
    union {
        UCHAR   Bytes[4];
        ULONG   SerialId;
    } Checksum;
 
    PAGED_CODE();
 
    //
    //  Initialize the serial number.
    //
 
    Checksum.SerialId = 0;
 
    //
    //  Continue while there are more bytes to use.
    //
 
    while (ByteCount--) {
 
        //
        //  Increment this sub-checksum.
        //
 
        Checksum.Bytes[ByteCount & 0x3] += *(Buffer++);
    }
 
    //
    //  Return the checksums as a ULONG.
    //
 
    return Checksum.SerialId;
}

Referenced by CdFindActiveVolDescriptor().

CdSetThreadContext()

VOID CdSetThreadContext	(	_Inout_ PIRP_CONTEXT	IrpContext,
		_In_ PTHREAD_CONTEXT	ThreadContext
	)

Definition at line 981 of file cddata.c.

{
    PTHREAD_CONTEXT CurrentThreadContext;
#ifdef __REACTOS__
    ULONG_PTR StackTop;
    ULONG_PTR StackBottom;
#endif
 
    PAGED_CODE();
 
    ASSERT_IRP_CONTEXT( IrpContext );
 
    //
    //  Get the current top-level irp out of the thread storage.
    //  If NULL then this is the top-level request.
    //
 
    CurrentThreadContext = (PTHREAD_CONTEXT) IoGetTopLevelIrp();
 
    if (CurrentThreadContext == NULL) {
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL );
    }
 
    //
    //  Initialize the input context unless we are using the current
    //  thread context block.  We use the new block if our caller
    //  specified this or the existing block is invalid.
    //
    //  The following must be true for the current to be a valid Cdfs context.
    //
    //      Structure must lie within current stack.
    //      Address must be ULONG aligned.
    //      Cdfs signature must be present.
    //
    //  If this is not a valid Cdfs context then use the input thread
    //  context and store it in the top level context.
    //
 
#ifdef __REACTOS__
    IoGetStackLimits( &StackTop, &StackBottom);
#endif
 
#ifdef _MSC_VER
#pragma warning(suppress: 6011) // Bug in PREFast around bitflag operations
#endif
    if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) ||
#ifndef __REACTOS__
        (!IoWithinStackLimits( (ULONG_PTR)CurrentThreadContext, sizeof( THREAD_CONTEXT ) ) ||
#else
        (((ULONG_PTR) CurrentThreadContext > StackBottom - sizeof( THREAD_CONTEXT )) ||
         ((ULONG_PTR) CurrentThreadContext <= StackTop) ||
#endif
         FlagOn( (ULONG_PTR) CurrentThreadContext, 0x3 ) ||
         (CurrentThreadContext->Cdfs != 0x53464443))) {
 
        ThreadContext->Cdfs = 0x53464443;
        ThreadContext->SavedTopLevelIrp = (PIRP) CurrentThreadContext;
        ThreadContext->TopLevelIrpContext = IrpContext;
        IoSetTopLevelIrp( (PIRP) ThreadContext );
 
        IrpContext->TopLevel = IrpContext;
        IrpContext->ThreadContext = ThreadContext;
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS );
 
    //
    //  Otherwise use the IrpContext in the thread context.
    //
 
    } else {
 
        IrpContext->TopLevel = CurrentThreadContext->TopLevelIrpContext;
    }
 
    return;
}

Referenced by _IRQL_requires_max_(), and CdFspDispatch().

Variable Documentation

CdAudioDirentSize

ULONG CdAudioDirentSize = FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName ) + sizeof( SYSTEM_USE_XA )

Definition at line 78 of file cddata.c.

Referenced by _When_(), and CdUpdateVcbFromVolDescriptor().

CdAudioDirentsPerSector

ULONG CdAudioDirentsPerSector = SECTOR_SIZE / (FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName ) + sizeof( SYSTEM_USE_XA ))

Definition at line 79 of file cddata.c.

Referenced by _When_().

CdAudioFileName

CHAR CdAudioFileName[] = { 'T', 'r', 'a', 'c', 'k', '0', '0', '.', 'c', 'd', 'a' }

Definition at line 76 of file cddata.c.

Referenced by _When_().

CdAudioFileNameLength

UCHAR CdAudioFileNameLength = sizeof( CdAudioFileName )

Definition at line 77 of file cddata.c.

Referenced by _When_().

CdAudioLabel

WCHAR CdAudioLabel[] = { L'A', L'u', L'd', L'i', L'o', L' ', L'C', L'D' }

Definition at line 69 of file cddata.c.

Referenced by CdUpdateVcbFromVolDescriptor().

CdAudioLabelLength

USHORT CdAudioLabelLength = sizeof( CdAudioLabel )

Definition at line 70 of file cddata.c.

Referenced by CdUpdateVcbFromVolDescriptor().

CdAudioPlayHeader

LONG CdAudioPlayHeader[]

Initial value:

= {
    0x46464952,                         
    4 * 11 - 8,                         
    0x41444443,                         
    0x20746d66,                         
    24,                                 
    0x00000001,                         
    0x00000000,                         
    0x00000000,                         
    0x00000000,                         
    0x00000000,                         
    0x00000000                          
}

Definition at line 102 of file cddata.c.

CdAudioSystemUseOffset

ULONG CdAudioSystemUseOffset = FIELD_OFFSET( RAW_DIRENT, FileId ) + sizeof( CdAudioFileName )

Definition at line 80 of file cddata.c.

Referenced by _When_().

CdData

CD_DATA CdData

Definition at line 42 of file cddata.c.

Referenced by _Requires_lock_held_(), _Success_(), CdCleanupIrpContext(), CdCreateInternalStream(), CdCreateIrpContext(), CdInitializeGlobalData(), CdInitializeVcb(), CdQueueClose(), CdRemoveClose(), and CdUnload().

CdFastIoDispatch

FAST_IO_DISPATCH CdFastIoDispatch

Definition at line 43 of file cddata.c.

Referenced by CdInitializeGlobalData(), and DriverEntry().

CdHsgId

CHAR CdHsgId[] = { 'C', 'D', 'R', 'O', 'M' }

Definition at line 61 of file cddata.c.

Referenced by _Success_().

CdIsoId

CHAR CdIsoId[] = { 'C', 'D', '0', '0', '1' }

Definition at line 62 of file cddata.c.

Referenced by _Success_(), and CdFindActiveVolDescriptor().

CdJolietEscape

PCHAR CdJolietEscape[] = { "%/@", "%/C", "%/E" }

Definition at line 86 of file cddata.c.

Referenced by CdFindActiveVolDescriptor().

CdUnicodeDirectoryNames

UNICODE_STRING CdUnicodeDirectoryNames[]

Initial value:

= {
    { 2, 2, CdUnicodeSelfArray},
    { 4, 4, CdUnicodeParentArray}
}

Definition at line 52 of file cddata.c.

Referenced by CdUpdateDirentName(), and CdUpdatePathEntryName().

CdUnicodeParentArray

WCHAR CdUnicodeParentArray[] = { L'.', L'.' }

Definition at line 50 of file cddata.c.

CdUnicodeSelfArray

WCHAR CdUnicodeSelfArray[] = { L'.' }

Definition at line 49 of file cddata.c.

Referenced by CdCreateInternalStream().

CdXAAudioPhileHeader

LONG CdXAAudioPhileHeader[]

Initial value:

= {
    0x46464952,                         
    -8,                                 
    0x45564157,                         
    0x20746d66,                         
    16,                                 
    0x00020001,                         
    44100,                              
    2352 * 75,                          
    0x00100004,                         
    0x61746164,                         
    -44                                 
}

Definition at line 136 of file cddata.c.

CdXAFileHeader

LONG CdXAFileHeader[]

Initial value:

= {
    0x46464952,                         
    -8,                                 
    0x41584443,                         
    0x20746d66,                         
    16,                                 
    0,                                  
    0x41580000,                         
                                        
                                        
    0,                                  
    0,                                  
    0x61746164,                         
    -44                                 
}

Definition at line 165 of file cddata.c.

CdXaId

CHAR CdXaId[] = { 'C', 'D', '-', 'X', 'A', '0', '0', '1' }

Definition at line 63 of file cddata.c.

Referenced by CdUpdateVcbFromVolDescriptor().