ioctl.c File Reference

#include "stddef.h"
#include "string.h"
#include "ntddk.h"
#include "ntddstor.h"
#include "cdrom.h"
#include "ioctl.h"
#include "scratch.h"
#include "mmc.h"

Include dependency graph for ioctl.c:

Go to the source code of this file.

Macros
#define	FirstDriveLetter   'C'
#define	LastDriveLetter   'Z'

Functions
	_IRQL_requires_max_ (APC_LEVEL)
NTSTATUS	RequestHandleGetInquiryData (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleGetMediaTypeEx (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateRawRead (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateReadTocEx (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateReadToc (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateGetLastSession (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateReadQChannel (_In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateDvdReadStructure (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateDvdStartSession (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateDvdSendKey (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateGetConfiguration (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateSetSpeed (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsReadMediaKeyBlock (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsStartSession (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsSendCertificate (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsGetCertificate (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsGetChallengeKey (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsSendChallengeKey (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsReadVolumeId (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsReadSerialNumber (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsReadMediaId (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsBindingNonce (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateExclusiveAccess (_In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleQueryPropertyRetrieveCachedData (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleQueryPropertyDeviceUniqueId (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestHandleQueryPropertyWriteCache (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestValidateDvdReadKey (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateDvdEndSession (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateAacsEndSession (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateEnableStreaming (_In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateSendOpcInformation (_In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestValidateGetPerformance (_In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleMountQueryUniqueId (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleMountQueryDeviceName (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleMountQuerySuggestedLinkName (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
NTSTATUS	RequestHandleGetDeviceNumber (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleGetHotPlugInfo (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestHandleSetHotPlugInfo (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
BOOLEAN	RequestIsRealtimeStreaming (_In_ WDFREQUEST Request, _In_ BOOLEAN IsReadRequest)
NTSTATUS	RequestValidateReadWrite (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
NTSTATUS	RequestHandleReadWrite (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
static BOOLEAN	ValidPersistentReserveScope (UCHAR Scope)
static BOOLEAN	ValidPersistentReserveType (UCHAR Type)
NTSTATUS	RequestValidatePersistentReserve (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)

Macro Definition Documentation

FirstDriveLetter

#define FirstDriveLetter   'C'

Definition at line 40 of file ioctl.c.

LastDriveLetter

#define LastDriveLetter   'Z'

Definition at line 41 of file ioctl.c.

Function Documentation

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 54 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_UNSUCCESSFUL;
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(Device);
    PCDROM_REQUEST_CONTEXT      requestContext = RequestGetContext(Request);
    BOOLEAN                     syncRequired = requestContext->SyncRequired;
 
    ULONG                       sendOptionsFlags = 0;
    BOOLEAN                     requestSent = FALSE;
 
    WdfRequestFormatRequestUsingCurrentType(Request);
 
    if (syncRequired)
    {
        sendOptionsFlags = WDF_REQUEST_SEND_OPTION_SYNCHRONOUS;
    }
    else
    {
        WdfRequestSetCompletionRoutine(Request, RequestDummyCompletionRoutine, NULL);
    }
 
    status = RequestSend(deviceExtension,
                         Request,
                         deviceExtension->IoTarget,
                         sendOptionsFlags,
                         &requestSent);
 
    if (requestSent)
    {
        if (syncRequired)
        {
            // the request needs to be completed here.
            RequestCompletion(deviceExtension, Request, status, WdfRequestGetInformation(Request));
        }
    }
    else
    {
        // failed to send the request to IoTarget
        RequestCompletion(deviceExtension, Request, status, WdfRequestGetInformation(Request));
    }
 
    return status;
}

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 4831 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    VOID*               outputBuffer = NULL;
 
    PAGED_CODE ();
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveOutputBuffer(Request,
                                            RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                            &outputBuffer,
                                            NULL);
 
    // Issue ReadCapacity to update device extension
    // with information for current media.
    if (NT_SUCCESS(status))
    {
        status = MediaReadCapacity(DeviceExtension->Device);
    }
 
    if (NT_SUCCESS(status))
    {
        switch(RequestParameters.Parameters.DeviceIoControl.IoControlCode)
        {
            case IOCTL_DISK_GET_LENGTH_INFO:
            {
                PGET_LENGTH_INFORMATION lengthInfo = (PGET_LENGTH_INFORMATION)outputBuffer;
 
                lengthInfo->Length = DeviceExtension->PartitionLength;
                *DataLength = sizeof(GET_LENGTH_INFORMATION);
                break;
            }
            case IOCTL_DISK_GET_DRIVE_GEOMETRY:
            case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
            {
                PDISK_GEOMETRY geometry = (PDISK_GEOMETRY)outputBuffer;
 
                *geometry = DeviceExtension->DiskGeometry;
                *DataLength = sizeof(DISK_GEOMETRY);
                break;
            }
            case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
            case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX:
            {
                PDISK_GEOMETRY_EX geometryEx = (PDISK_GEOMETRY_EX)outputBuffer;
 
                geometryEx->DiskSize = DeviceExtension->PartitionLength;
                geometryEx->Geometry = DeviceExtension->DiskGeometry;
                *DataLength = FIELD_OFFSET(DISK_GEOMETRY_EX, Data);
                break;
            }
            case IOCTL_STORAGE_READ_CAPACITY:
            {
                PSTORAGE_READ_CAPACITY readCapacity = (PSTORAGE_READ_CAPACITY)outputBuffer;
 
                readCapacity->Version = sizeof(STORAGE_READ_CAPACITY);
                readCapacity->Size = sizeof(STORAGE_READ_CAPACITY);
 
                readCapacity->BlockLength = DeviceExtension->DiskGeometry.BytesPerSector;
                if (readCapacity->BlockLength > 0)
                {
                    readCapacity->NumberOfBlocks.QuadPart = DeviceExtension->PartitionLength.QuadPart/readCapacity->BlockLength;
                }
                else
                {
                    readCapacity->NumberOfBlocks.QuadPart = 0;
                }
 
                readCapacity->DiskLength = DeviceExtension->PartitionLength;
 
                *DataLength = sizeof(STORAGE_READ_CAPACITY);
                break;
            }
            default:
            {
                NT_ASSERT(FALSE);
                break;
            }
        } // end of switch()
    }
 
    return status;
}

RequestHandleGetDeviceNumber()

NTSTATUS RequestHandleGetDeviceNumber	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 5280 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength >=
       sizeof(STORAGE_DEVICE_NUMBER))
    {
        PSTORAGE_DEVICE_NUMBER deviceNumber = NULL;
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &deviceNumber,
                                                NULL);
        if (NT_SUCCESS(status))
        {
            deviceNumber->DeviceType = DeviceExtension->DeviceObject->DeviceType;
            deviceNumber->DeviceNumber = DeviceExtension->DeviceNumber;
            deviceNumber->PartitionNumber = (ULONG)-1; // legacy reason, return (-1) for this IOCTL.
 
            status = STATUS_SUCCESS;
            *DataLength = sizeof(STORAGE_DEVICE_NUMBER);
        }
    }
    else
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(STORAGE_DEVICE_NUMBER);
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleGetHotPlugInfo()

NTSTATUS RequestHandleGetHotPlugInfo	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 5337 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength >=
       sizeof(STORAGE_HOTPLUG_INFO))
    {
        PSTORAGE_HOTPLUG_INFO info = NULL;
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &info,
                                                NULL);
        if (NT_SUCCESS(status))
        {
            *info = DeviceExtension->PrivateFdoData->HotplugInfo;
 
            status = STATUS_SUCCESS;
            *DataLength = sizeof(STORAGE_HOTPLUG_INFO);
        }
    }
    else
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(STORAGE_HOTPLUG_INFO);
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleGetInquiryData()

NTSTATUS RequestHandleGetInquiryData	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 270 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
    PCDROM_DATA cdData = &(DeviceExtension->DeviceAdditionalData);
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength == 0)
    {
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else
    {
        PVOID outputBuffer = NULL;
 
        *DataLength = min(cdData->CachedInquiryDataByteCount,
                          RequestParameters.Parameters.DeviceIoControl.OutputBufferLength);
 
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &outputBuffer,
                                                NULL);
 
        if (NT_SUCCESS(status) &&
            (outputBuffer != NULL))
        {
            // Always copy as much data as possible
            RtlCopyMemory(outputBuffer,
                          cdData->CachedInquiryData,
                          *DataLength);
        }
 
        // and finally decide between two possible status values
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < cdData->CachedInquiryDataByteCount)
        {
            status = STATUS_BUFFER_OVERFLOW;
        }
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleGetMediaTypeEx()

NTSTATUS RequestHandleGetMediaTypeEx	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_Out_ size_t *	DataLength
	)

Definition at line 336 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    PCDROM_DATA         cdData = &(DeviceExtension->DeviceAdditionalData);
 
    PGET_MEDIA_TYPES        mediaTypes = NULL;
    PDEVICE_MEDIA_INFO      mediaInfo = NULL; //&mediaTypes->MediaInfo[0];
    ULONG                   sizeNeeded = 0;
    PZERO_POWER_ODD_INFO    zpoddInfo = DeviceExtension->ZeroPowerODDInfo;
 
    *DataLength = 0;
 
    // Must run below dispatch level.
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
    {
        NT_ASSERT(FALSE);
        return STATUS_INVALID_LEVEL;
    }
 
    sizeNeeded = sizeof(GET_MEDIA_TYPES);
 
    // IsMmc is static...
    if (cdData->Mmc.IsMmc)
    {
        sizeNeeded += sizeof(DEVICE_MEDIA_INFO) * 1; // return two media types
    }
 
    status = WdfRequestRetrieveOutputBuffer(Request,
                                            sizeNeeded,
                                            (PVOID*)&mediaTypes,
                                            NULL);
 
    if (NT_SUCCESS(status) &&
        (mediaTypes != NULL))
    {
        mediaInfo = &mediaTypes->MediaInfo[0];
 
        RtlZeroMemory(mediaTypes, sizeNeeded);
 
        // ISSUE-2000/5/11-henrygab - need to update GET_MEDIA_TYPES_EX
 
        mediaTypes->DeviceType = cdData->DriveDeviceType;
 
        mediaTypes->MediaInfoCount = 1;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = CD_ROM;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = 1;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_ONLY;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = DeviceExtension->DiskGeometry.Cylinders.QuadPart;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = DeviceExtension->DiskGeometry.TracksPerCylinder;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = DeviceExtension->DiskGeometry.SectorsPerTrack;
        mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = DeviceExtension->DiskGeometry.BytesPerSector;
 
        if (cdData->Mmc.IsMmc)
        {
            // also report a removable disk
            mediaTypes->MediaInfoCount += 1;
 
            mediaInfo++;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaType = (STORAGE_MEDIA_TYPE)RemovableMedia;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.NumberMediaSides = 1;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics = MEDIA_READ_WRITE;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.Cylinders.QuadPart = DeviceExtension->DiskGeometry.Cylinders.QuadPart;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.TracksPerCylinder = DeviceExtension->DiskGeometry.TracksPerCylinder;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.SectorsPerTrack = DeviceExtension->DiskGeometry.SectorsPerTrack;
            mediaInfo->DeviceSpecific.RemovableDiskInfo.BytesPerSector = DeviceExtension->DiskGeometry.BytesPerSector;
            mediaInfo--;
 
        }
 
        // Status will either be success, if media is present, or no media.
        // It would be optimal to base from density code and medium type, but not all devices
        // have values for these fields.
 
        // Send a TUR to determine if media is present, only if the device is not in ZPODD mode.
        if ((!EXCLUSIVE_MODE(cdData) ||
             EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request))) &&
            ((zpoddInfo == NULL) ||
             (zpoddInfo->InZeroPowerState == FALSE)))
        {
            SCSI_REQUEST_BLOCK  srb;
            PCDB                cdb = (PCDB)srb.Cdb;
 
            RtlZeroMemory(&srb,sizeof(SCSI_REQUEST_BLOCK));
 
            srb.CdbLength = 6;
            cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
 
            srb.TimeOutValue = CDROM_TEST_UNIT_READY_TIMEOUT;
 
            status = DeviceSendSrbSynchronously(DeviceExtension->Device,
                                                &srb,
                                                NULL,
                                                0,
                                                FALSE,
                                                Request);
 
            if (NT_SUCCESS(status))
            {
                // set the disk's media as current if we can write to it.
                if (cdData->Mmc.IsMmc && cdData->Mmc.WriteAllowed)
                {
                    mediaInfo++;
                    SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics,
                             MEDIA_CURRENTLY_MOUNTED);
                    mediaInfo--;
                }
                else
                {
                    SET_FLAG(mediaInfo->DeviceSpecific.RemovableDiskInfo.MediaCharacteristics,
                             MEDIA_CURRENTLY_MOUNTED);
                }
            }
            else
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                           "RequestHandleGetMediaTypeEx: GET_MEDIA_TYPES status of TUR - %lx\n", status));
            }
        }
 
        // per legacy cdrom behavior, always return success
        status = STATUS_SUCCESS;
    }
 
    *DataLength = sizeNeeded;
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleMountQueryDeviceName()

NTSTATUS RequestHandleMountQueryDeviceName	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 4015 of file ioctl.c.

{
    NTSTATUS        status = STATUS_SUCCESS;
    PMOUNTDEV_NAME  name = NULL;
 
    *DataLength = 0;
 
    NT_ASSERT(DeviceExtension->DeviceName.Buffer);
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTDEV_NAME))
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(MOUNTDEV_NAME);
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &name,
                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(name, RequestParameters.Parameters.DeviceIoControl.OutputBufferLength);
        name->NameLength = DeviceExtension->DeviceName.Length;
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            (sizeof(USHORT) + DeviceExtension->DeviceName.Length))
        {
            status = STATUS_BUFFER_OVERFLOW;
            *DataLength = sizeof(MOUNTDEV_NAME);
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlCopyMemory(name->Name,
                      DeviceExtension->DeviceName.Buffer,
                      name->NameLength);
 
        status = STATUS_SUCCESS;
        *DataLength = sizeof(USHORT) + name->NameLength;
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleMountQuerySuggestedLinkName()

NTSTATUS RequestHandleMountQuerySuggestedLinkName	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 4088 of file ioctl.c.

{
    NTSTATUS        status = STATUS_SUCCESS;
 
    PMOUNTDEV_SUGGESTED_LINK_NAME suggestedName = NULL;
 
    WCHAR                    driveLetterNameBuffer[10] = {0};
    RTL_QUERY_REGISTRY_TABLE queryTable[2] = {0};
    PWSTR                    valueName = NULL;
    UNICODE_STRING           driveLetterName = {0};
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(MOUNTDEV_SUGGESTED_LINK_NAME))
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
    }
 
    if (NT_SUCCESS(status))
    {
        valueName = ExAllocatePoolWithTag(PagedPool,
                                          DeviceExtension->DeviceName.Length + sizeof(WCHAR),
                                          CDROM_TAG_STRINGS);
        if (valueName == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlCopyMemory(valueName,
                      DeviceExtension->DeviceName.Buffer,
                      DeviceExtension->DeviceName.Length);
        valueName[DeviceExtension->DeviceName.Length/sizeof(WCHAR)] = 0;
 
        driveLetterName.Buffer = driveLetterNameBuffer;
        driveLetterName.MaximumLength = sizeof(driveLetterNameBuffer);
        driveLetterName.Length = 0;
 
        queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK;
        queryTable[0].Name = valueName;
        queryTable[0].EntryContext = &driveLetterName;
        queryTable[0].DefaultType = (REG_SZ << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_NONE;
 
        status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                        L"\\Registry\\Machine\\System\\DISK", // why hard coded?
                                        queryTable, NULL, NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if ((driveLetterName.Length == 4) &&
            (driveLetterName.Buffer[0] == '%') &&
            (driveLetterName.Buffer[1] == ':'))
        {
            driveLetterName.Buffer[0] = 0xFF;
        }
        else if ((driveLetterName.Length != 4) ||
                 (driveLetterName.Buffer[0] < FirstDriveLetter) ||
                 (driveLetterName.Buffer[0] > LastDriveLetter) ||
                 (driveLetterName.Buffer[1] != ':'))
        {
            status = STATUS_NOT_FOUND;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &suggestedName,
                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(suggestedName, RequestParameters.Parameters.DeviceIoControl.OutputBufferLength);
        suggestedName->UseOnlyIfThereAreNoOtherLinks = TRUE;
        suggestedName->NameLength = 28;
 
        *DataLength = FIELD_OFFSET(MOUNTDEV_SUGGESTED_LINK_NAME, Name) + 28;
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < *DataLength)
        {
            *DataLength = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
            status = STATUS_BUFFER_OVERFLOW;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                               L"\\Registry\\Machine\\System\\DISK",
                               valueName);
 
        RtlCopyMemory(suggestedName->Name, L"\\DosDevices\\", 24);
        suggestedName->Name[12] = driveLetterName.Buffer[0];
        suggestedName->Name[13] = ':';
    }
 
    FREE_POOL(valueName);
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleMountQueryUniqueId()

NTSTATUS RequestHandleMountQueryUniqueId	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3939 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    PMOUNTDEV_UNIQUE_ID uniqueId = NULL;
 
    *DataLength = 0;
 
    if (!DeviceExtension->MountedDeviceInterfaceName.Buffer)
    {
        status = STATUS_INVALID_PARAMETER;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTDEV_UNIQUE_ID))
    {
        *DataLength = sizeof(MOUNTDEV_UNIQUE_ID);
        status = STATUS_BUFFER_TOO_SMALL;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &uniqueId,
                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(uniqueId, RequestParameters.Parameters.DeviceIoControl.OutputBufferLength);
 
        uniqueId->UniqueIdLength = DeviceExtension->MountedDeviceInterfaceName.Length;
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            (sizeof(USHORT) + DeviceExtension->MountedDeviceInterfaceName.Length))
        {
            *DataLength = sizeof(MOUNTDEV_UNIQUE_ID);
            status = STATUS_BUFFER_OVERFLOW;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlCopyMemory(uniqueId->UniqueId,
                      DeviceExtension->MountedDeviceInterfaceName.Buffer,
                      uniqueId->UniqueIdLength);
 
        *DataLength = sizeof(USHORT) + uniqueId->UniqueIdLength;
        status = STATUS_SUCCESS;
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestHandleQueryPropertyDeviceUniqueId()

NTSTATUS RequestHandleQueryPropertyDeviceUniqueId	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request
	)

Definition at line 2799 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(Device);
    PSTORAGE_PROPERTY_QUERY     inputBuffer = NULL;
    PSTORAGE_DESCRIPTOR_HEADER  descHeader = NULL;
    size_t                      outLength = 0;
    WDF_REQUEST_PARAMETERS      requestParameters;
 
    // Get the Request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           requestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &inputBuffer,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        BOOLEAN overflow = FALSE;
        BOOLEAN infoFound = FALSE;
 
        // Must run at less then dispatch.
        if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
        {
            NT_ASSERT(FALSE);
            outLength = 0;
            status = STATUS_INVALID_LEVEL;
        }
        else if (inputBuffer->QueryType == PropertyExistsQuery)
        {
            outLength = 0;
            status = STATUS_SUCCESS;
        }
        else if (inputBuffer->QueryType != PropertyStandardQuery)
        {
            outLength = 0;
            status = STATUS_NOT_SUPPORTED;
        }
        else
        {
            // Check AdditionalParameters validity.
            if (inputBuffer->AdditionalParameters[0] == DUID_INCLUDE_SOFTWARE_IDS)
            {
                // Do nothing
            }
            else if (inputBuffer->AdditionalParameters[0] == DUID_HARDWARE_IDS_ONLY)
            {
                // Do nothing
            }
            else
            {
                outLength = 0;
                status = STATUS_INVALID_PARAMETER;
            }
 
            if (NT_SUCCESS(status) &&
                (outLength < sizeof(STORAGE_DESCRIPTOR_HEADER)))
            {
                outLength = 0;
                status = STATUS_INFO_LENGTH_MISMATCH;
            }
        }
 
        // From this point forward the status depends on the overflow
        // and infoFound flags.
        if (NT_SUCCESS(status))
        {
            outLength = requestParameters.Parameters.DeviceIoControl.OutputBufferLength;
            status = WdfRequestRetrieveOutputBuffer(Request,
                                                    requestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                    &descHeader,
                                                    NULL);
        }
 
        if (NT_SUCCESS(status))
        {
            RtlZeroMemory(descHeader, outLength);
 
            descHeader->Version = DUID_VERSION_1;
            descHeader->Size = sizeof(STORAGE_DEVICE_UNIQUE_IDENTIFIER);
 
            // Try to build device unique id from StorageDeviceIdProperty.
            status = RequestDuidGetDeviceIdProperty(deviceExtension,
                                                    Request,
                                                    requestParameters,
                                                    &outLength);
 
            if (status == STATUS_BUFFER_OVERFLOW)
            {
                overflow = TRUE;
            }
 
            if (NT_SUCCESS(status))
            {
                infoFound = TRUE;
            }
 
            // Try to build device unique id from StorageDeviceProperty.
            status = RequestDuidGetDeviceProperty(deviceExtension,
                                                  Request,
                                                  requestParameters,
                                                  &outLength);
 
            if (status == STATUS_BUFFER_OVERFLOW)
            {
                overflow = TRUE;
            }
 
            if (NT_SUCCESS(status))
            {
                infoFound = TRUE;
            }
 
            // Return overflow, success, or a generic error.
            if (overflow)
            {
                // If output buffer is STORAGE_DESCRIPTOR_HEADER, then return
                // success to the user.  Otherwise, send an error so the user
                // knows a larger buffer is required.
                if (outLength == sizeof(STORAGE_DESCRIPTOR_HEADER))
                {
                    status = STATUS_SUCCESS;
                }
                else
                {
                    outLength = (ULONG)WdfRequestGetInformation(Request);
                    status = STATUS_BUFFER_OVERFLOW;
                }
 
            }
            else if (infoFound)
            {
                status = STATUS_SUCCESS;
 
                // Exercise the compare routine.  This should always succeed.
                NT_ASSERT(DuidExactMatch == CompareStorageDuids((PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader,
                                                             (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader));
 
            }
            else
            {
                status = STATUS_NOT_FOUND;
            }
        }
    }
 
    RequestCompletion(deviceExtension, Request, status, outLength);
 
    return status;
}

Referenced by RequestDispatchSpecialIoctls().

RequestHandleQueryPropertyRetrieveCachedData()

NTSTATUS RequestHandleQueryPropertyRetrieveCachedData	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2628 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PSTORAGE_PROPERTY_QUERY inputBuffer = NULL;
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &inputBuffer,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->PropertyId == StorageDeviceProperty)
        {
            // check output buffer length
            if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength == 0)
            {
                // According to MSDN, an output buffer of size 0 can be used to determine if a property exists
                // so this must be a success case with no data transferred
                *DataLength = 0;
                status = STATUS_SUCCESS;
            }
            else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_DESCRIPTOR_HEADER))
            {
                // Buffer too small
                *DataLength = DeviceExtension->DeviceDescriptor->Size;
                status = STATUS_BUFFER_TOO_SMALL;
            }
            else
            {
                PSTORAGE_DEVICE_DESCRIPTOR  outputDescriptor = NULL;
                CHAR*                       localDescriptorBuffer = (CHAR*)DeviceExtension->DeviceDescriptor;
 
                status = WdfRequestRetrieveOutputBuffer(Request,
                                                        RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                        &outputDescriptor,
                                                        NULL);
 
                if (NT_SUCCESS(status))
                {
                    // transfer as much data out as the buffer will allow
                    *DataLength = min(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                      DeviceExtension->DeviceDescriptor->Size);
 
                    RtlCopyMemory(outputDescriptor,
                                  DeviceExtension->DeviceDescriptor,
                                  *DataLength);
 
                    // walk through and update offset variables to reflect data that didn't make it into the output buffer
                    if ((*DataLength >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_DEVICE_DESCRIPTOR, VendorIdOffset)) &&
                        (DeviceExtension->DeviceDescriptor->VendorIdOffset != 0) &&
                        (DeviceExtension->DeviceDescriptor->VendorIdOffset != 0xFFFFFFFF))
                    {
                        // set VendorIdOffset appropriately
                        if (*DataLength <
                            (DeviceExtension->DeviceDescriptor->VendorIdOffset + strlen(localDescriptorBuffer + DeviceExtension->DeviceDescriptor->VendorIdOffset)))
                        {
                            outputDescriptor->VendorIdOffset = 0;
                        }
                    }
 
                    if ((*DataLength >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_DEVICE_DESCRIPTOR, ProductIdOffset)) &&
                        (DeviceExtension->DeviceDescriptor->ProductIdOffset != 0) &&
                        (DeviceExtension->DeviceDescriptor->ProductIdOffset != 0xFFFFFFFF))
                    {
                        // set ProductIdOffset appropriately
                        if (*DataLength <
                            (DeviceExtension->DeviceDescriptor->ProductIdOffset + strlen(localDescriptorBuffer + DeviceExtension->DeviceDescriptor->ProductIdOffset)))
                        {
                            outputDescriptor->ProductIdOffset = 0;
                        }
                    }
 
                    if ((*DataLength >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_DEVICE_DESCRIPTOR, ProductRevisionOffset)) &&
                        (DeviceExtension->DeviceDescriptor->ProductRevisionOffset != 0) &&
                        (DeviceExtension->DeviceDescriptor->ProductRevisionOffset != 0xFFFFFFFF))
                    {
                        // set ProductRevisionOffset appropriately
                        if (*DataLength <
                            (DeviceExtension->DeviceDescriptor->ProductRevisionOffset + strlen(localDescriptorBuffer + DeviceExtension->DeviceDescriptor->ProductRevisionOffset)))
                        {
                            outputDescriptor->ProductRevisionOffset = 0;
                        }
                    }
 
                    if ((*DataLength >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_DEVICE_DESCRIPTOR, SerialNumberOffset)) &&
                        (DeviceExtension->DeviceDescriptor->SerialNumberOffset != 0) &&
                        (DeviceExtension->DeviceDescriptor->SerialNumberOffset != 0xFFFFFFFF))
                    {
                        // set SerialNumberOffset appropriately
                        if (*DataLength <
                            (DeviceExtension->DeviceDescriptor->SerialNumberOffset + strlen(localDescriptorBuffer + DeviceExtension->DeviceDescriptor->SerialNumberOffset)))
                        {
                            // NOTE: setting this to 0 since that is what most port drivers do
                            //       [this could cause issues with SCSI port devices whose clients expect -1 in this field]
                            outputDescriptor->SerialNumberOffset = 0;
                        }
                    }
                    status = STATUS_SUCCESS;
                }
            }
        }   //end of StorageDeviceProperty
        else if (inputBuffer->PropertyId == StorageAdapterProperty)
        {
            if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength == 0)
            {
                // According to MSDN, an output buffer of size 0 can be used to determine if a property exists
                // so this must be a success case with no data transferred
                *DataLength = 0;
                status = STATUS_SUCCESS;
            }
            else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_DESCRIPTOR_HEADER))
            {
                // Buffer too small
                *DataLength = DeviceExtension->AdapterDescriptor->Size;
                status = STATUS_BUFFER_TOO_SMALL;
            }
            else
            {
                PSTORAGE_ADAPTER_DESCRIPTOR outputDescriptor = NULL;
 
                status = WdfRequestRetrieveOutputBuffer(Request,
                                                        RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                        &outputDescriptor,
                                                        NULL);
                if (NT_SUCCESS(status))
                {
                    // copy as much data out as the buffer will allow
                    *DataLength = min(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                      DeviceExtension->AdapterDescriptor->Size);
 
                    RtlCopyMemory(outputDescriptor,
                                  DeviceExtension->AdapterDescriptor,
                                  *DataLength);
 
                    // set status
                    status = STATUS_SUCCESS;
                }
            }
        }
    }
 
    return status;
}

Referenced by RequestDispatchSpecialIoctls().

RequestHandleQueryPropertyWriteCache()

NTSTATUS RequestHandleQueryPropertyWriteCache	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request
	)

Definition at line 2974 of file ioctl.c.

{
    NTSTATUS                      status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION       deviceExtension = DeviceGetExtension(Device);
    PSTORAGE_PROPERTY_QUERY       query = NULL;
    PSTORAGE_WRITE_CACHE_PROPERTY writeCache = NULL;
    PMODE_PARAMETER_HEADER        modeData = NULL;
    PMODE_CACHING_PAGE            pageData = NULL;
    size_t                        length = 0;
    ULONG                         information = 0;
    PSCSI_REQUEST_BLOCK           srb = NULL;
    WDF_REQUEST_PARAMETERS        requestParameters;
 
    // Get the Request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           requestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &query,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
 
        // Must run at less then dispatch.
        if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
        {
            NT_ASSERT(FALSE);
            status = STATUS_INVALID_LEVEL;
        }
        else if (query->QueryType == PropertyExistsQuery)
        {
            information = 0;
            status = STATUS_SUCCESS;
        }
        else if (query->QueryType != PropertyStandardQuery)
        {
            status = STATUS_NOT_SUPPORTED;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        length = requestParameters.Parameters.DeviceIoControl.OutputBufferLength;
 
        if (length < sizeof(STORAGE_DESCRIPTOR_HEADER))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                requestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &writeCache,
                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(writeCache, length);
 
        // Set version and required size.
        writeCache->Version = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
        writeCache->Size = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
 
        if (length < sizeof(STORAGE_WRITE_CACHE_PROPERTY))
        {
            // caller only wants header information, bail out.
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            status = STATUS_SUCCESS;
 
            RequestCompletion(deviceExtension, Request, status, information);
            return status;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                                    sizeof(SCSI_REQUEST_BLOCK) +
                                    (sizeof(ULONG_PTR) * 2),
                                    CDROM_TAG_SRB);
 
        if (srb == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
 
        // Set known values
        writeCache->NVCacheEnabled = FALSE;
        writeCache->UserDefinedPowerProtection = TEST_FLAG(deviceExtension->DeviceFlags, DEV_POWER_PROTECTED);
 
        // Check for flush cache support by sending a sync cache command
        // to the device.
 
        // Set timeout value and mark the request as not being a tagged request.
        srb->Length = SCSI_REQUEST_BLOCK_SIZE;
        srb->TimeOutValue = TimeOutValueGetCapValue(deviceExtension->TimeOutValue, 4);
        srb->QueueTag = SP_UNTAGGED;
        srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
        srb->SrbFlags = deviceExtension->SrbFlags;
 
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->CdbLength = 10;
 
        srb->Cdb[0] = SCSIOP_SYNCHRONIZE_CACHE;
 
        status = DeviceSendSrbSynchronously(Device,
                                            srb,
                                            NULL,
                                            0,
                                            TRUE,   //flush drive cache
                                            Request);
 
        if (NT_SUCCESS(status))
        {
            writeCache->FlushCacheSupported = TRUE;
        }
        else
        {
            // Device does not support sync cache
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "RequestHandleQueryPropertyWriteCache: Synchronize cache failed with status 0x%X\n", status));
            writeCache->FlushCacheSupported = FALSE;
 
            // Reset the status if there was any failure
            status = STATUS_SUCCESS;
        }
 
        modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                         MODE_PAGE_DATA_SIZE,
                                         CDROM_TAG_MODE_DATA);
 
        if (modeData == NULL)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestHandleQueryPropertyWriteCache: Unable to allocate mode data buffer\n"));
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        RtlZeroMemory(modeData, MODE_PAGE_DATA_SIZE);
 
        length = DeviceRetrieveModeSenseUsingScratch(deviceExtension,
                                                     (PCHAR)modeData,
                                                     MODE_PAGE_DATA_SIZE,
                                                     MODE_PAGE_CACHING,
                                                     MODE_SENSE_CURRENT_VALUES);
 
        if (length < sizeof(MODE_PARAMETER_HEADER))
        {
            // Retry the request in case of a check condition.
            length = DeviceRetrieveModeSenseUsingScratch(deviceExtension,
                                                         (PCHAR)modeData,
                                                         MODE_PAGE_DATA_SIZE,
                                                         MODE_PAGE_CACHING,
                                                         MODE_SENSE_CURRENT_VALUES);
 
            if (length < sizeof(MODE_PARAMETER_HEADER))
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "RequestHandleQueryPropertyWriteCache: Mode Sense failed\n"));
                status = STATUS_IO_DEVICE_ERROR;
            }
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // If the length is greater than length indicated by the mode data reset
        // the data to the mode data.
        if (length > (ULONG) (modeData->ModeDataLength + 1))
        {
            length = modeData->ModeDataLength + 1;
        }
 
        // Look for caching page in the returned mode page data.
        pageData = ModeSenseFindSpecificPage((PCHAR)modeData,
                                             length,
                                             MODE_PAGE_CACHING,
                                             TRUE);
 
        // Check if valid caching page exists.
        if (pageData == NULL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "RequestHandleQueryPropertyWriteCache: Unable to find caching mode page.\n"));
 
            // Set write cache value as unknown.
            writeCache->WriteCacheEnabled = WriteCacheEnableUnknown;
            writeCache->WriteCacheType = WriteCacheTypeUnknown;
        }
        else
        {
            writeCache->WriteCacheEnabled = pageData->WriteCacheEnable
                                            ? WriteCacheEnabled
                                            : WriteCacheDisabled;
 
            writeCache->WriteCacheType = pageData->WriteCacheEnable
                                         ? WriteCacheTypeWriteBack
                                         : WriteCacheTypeUnknown;
        }
 
        // Check write through support.
        if (modeData->DeviceSpecificParameter & MODE_DSP_FUA_SUPPORTED)
        {
            writeCache->WriteThroughSupported = WriteThroughSupported;
        }
        else
        {
            writeCache->WriteThroughSupported = WriteThroughNotSupported;
        }
 
        // Get the changeable caching mode page and check write cache is changeable.
        RtlZeroMemory(modeData, MODE_PAGE_DATA_SIZE);
 
        length = DeviceRetrieveModeSenseUsingScratch(deviceExtension,
                                                     (PCHAR) modeData,
                                                     MODE_PAGE_DATA_SIZE,
                                                     MODE_PAGE_CACHING,
                                                     MODE_SENSE_CHANGEABLE_VALUES);
 
        if (length < sizeof(MODE_PARAMETER_HEADER))
        {
            // Retry the request in case of a check condition.
            length = DeviceRetrieveModeSenseUsingScratch(deviceExtension,
                                                         (PCHAR) modeData,
                                                         MODE_PAGE_DATA_SIZE,
                                                         MODE_PAGE_CACHING,
                                                         MODE_SENSE_CHANGEABLE_VALUES);
 
            if (length < sizeof(MODE_PARAMETER_HEADER))
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "RequestHandleQueryPropertyWriteCache: Mode Sense failed\n"));
 
                // If the device fails to return changeable pages, then
                // set the write cache changeable value to unknown.
                writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
                information = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
            }
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // If the length is greater than length indicated by the mode data reset
        // the data to the mode data.
        if (length > (ULONG) (modeData->ModeDataLength + 1))
        {
            length = modeData->ModeDataLength + 1;
        }
 
        // Look for caching page in the returned mode page data.
        pageData = ModeSenseFindSpecificPage((PCHAR)modeData,
                                             length,
                                             MODE_PAGE_CACHING,
                                             TRUE);
        // Check if valid caching page exists.
        if (pageData == NULL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "RequestHandleQueryPropertyWriteCache: Unable to find caching mode page.\n"));
 
            // Set write cache changeable value to unknown.
            writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
        }
        else
        {
            writeCache->WriteCacheChangeable = pageData->WriteCacheEnable
                                               ? WriteCacheChangeable
                                               : WriteCacheNotChangeable;
        }
 
        information = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
 
    }
 
    FREE_POOL(srb);
    FREE_POOL(modeData);
 
    RequestCompletion(deviceExtension, Request, status, information);
 
    return status;
}

Referenced by RequestDispatchSpecialIoctls().

RequestHandleReadWrite()

NTSTATUS RequestHandleReadWrite	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 6353 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    PCDROM_DATA         cdData = &(DeviceExtension->DeviceAdditionalData);
 
    size_t              transferByteCount = 0;
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  currentStack = NULL;
 
    PUCHAR              dataBuffer;
 
 
    irp = WdfRequestWdmGetIrp(Request);
    currentStack = IoGetCurrentIrpStackLocation(irp);
    dataBuffer = MmGetMdlVirtualAddress(irp->MdlAddress);
 
    if (NT_SUCCESS(status))
    {
        if (RequestParameters.Type == WdfRequestTypeRead)
        {
            transferByteCount = RequestParameters.Parameters.Read.Length;
        }
        else
        {
            transferByteCount = RequestParameters.Parameters.Write.Length;
        }
 
        if (transferByteCount == 0)
        {
            //  Several parts of the code turn 0 into 0xffffffff,
            //  so don't process a zero-length request any further.
            status = STATUS_SUCCESS;
            RequestCompletion(DeviceExtension, Request, status, 0);
            return status;
        }
 
        // Add partition byte offset to make starting byte relative to
        // beginning of disk.
        currentStack->Parameters.Read.ByteOffset.QuadPart += (DeviceExtension->StartingOffset.QuadPart);
 
        //not very necessary as the starting offset for CD/DVD device is always 0.
        if (RequestParameters.Type == WdfRequestTypeRead)
        {
            RequestParameters.Parameters.Read.DeviceOffset = currentStack->Parameters.Read.ByteOffset.QuadPart;
        }
        else
        {
            RequestParameters.Parameters.Write.DeviceOffset = currentStack->Parameters.Write.ByteOffset.QuadPart;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        ULONG   entireXferLen = currentStack->Parameters.Read.Length;
        ULONG   maxLength = 0;
        ULONG   packetsCount = 0;
 
        PCDROM_SCRATCH_READ_WRITE_CONTEXT readWriteContext;
        PCDROM_REQUEST_CONTEXT            requestContext;
        PCDROM_REQUEST_CONTEXT            originalRequestContext;
 
        // get the count of packets we need to send.
        if ((((ULONG_PTR)dataBuffer) & (PAGE_SIZE-1)) == 0)
        {
            maxLength = cdData->MaxPageAlignedTransferBytes;
        }
        else
        {
            maxLength = cdData->MaxUnalignedTransferBytes;
        }
 
        packetsCount = entireXferLen / maxLength;
 
        if (entireXferLen % maxLength != 0)
        {
            packetsCount++;
        }
 
        originalRequestContext = RequestGetContext(Request);
 
 
        ScratchBuffer_BeginUse(DeviceExtension);
 
        readWriteContext = &DeviceExtension->ScratchContext.ScratchReadWriteContext;
        requestContext = RequestGetContext(DeviceExtension->ScratchContext.ScratchRequest);
 
        readWriteContext->PacketsCount = packetsCount;
        readWriteContext->EntireXferLen = entireXferLen;
        readWriteContext->MaxLength = maxLength;
        readWriteContext->StartingOffset = currentStack->Parameters.Read.ByteOffset;
        readWriteContext->DataBuffer = dataBuffer;
        readWriteContext->TransferedBytes = 0;
        readWriteContext->IsRead = (RequestParameters.Type == WdfRequestTypeRead);
 
        requestContext->OriginalRequest = Request;
        requestContext->DeviceExtension = DeviceExtension;
 
        //
        // Setup the READ/WRITE fields in the original request which is what
        // we use to properly synchronize cancellation logic between the
        // cancel callback and the timer routine.
        //
 
        originalRequestContext->ReadWriteIsCompleted = FALSE;
        originalRequestContext->ReadWriteRetryInitialized = FALSE;
        originalRequestContext->DeviceExtension = DeviceExtension;
 
        status = ScratchBuffer_PerformNextReadWrite(DeviceExtension, TRUE);
 
        // We do not call ScratchBuffer_EndUse here, because we're not releasing the scratch SRB.
        // It will be released in the completion routine.
    }
 
    return status;
}

Referenced by ReadWriteWorkItemRoutine(), and SequentialQueueEvtIoReadWrite().

RequestHandleSetHotPlugInfo()

NTSTATUS RequestHandleSetHotPlugInfo	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 5392 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PSTORAGE_HOTPLUG_INFO   info = NULL;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
        sizeof(STORAGE_HOTPLUG_INFO))
    {
        // Indicate unsuccessful status and no data transferred.
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &info,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (info->Size != DeviceExtension->PrivateFdoData->HotplugInfo.Size)
        {
            status = STATUS_INVALID_PARAMETER_1;
        }
 
        if (info->MediaRemovable != DeviceExtension->PrivateFdoData->HotplugInfo.MediaRemovable)
        {
            status = STATUS_INVALID_PARAMETER_2;
        }
 
        if (info->MediaHotplug != DeviceExtension->PrivateFdoData->HotplugInfo.MediaHotplug)
        {
            status = STATUS_INVALID_PARAMETER_3;
        }
 
        if (info->WriteCacheEnableOverride != DeviceExtension->PrivateFdoData->HotplugInfo.WriteCacheEnableOverride)
        {
            status = STATUS_INVALID_PARAMETER_5;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        DeviceExtension->PrivateFdoData->HotplugInfo.DeviceHotplug = info->DeviceHotplug;
 
        // Store the user-defined override in the registry
        DeviceSetParameter(DeviceExtension,
                           CLASSP_REG_SUBKEY_NAME,
                           CLASSP_REG_REMOVAL_POLICY_VALUE_NAME,
                           (info->DeviceHotplug) ? RemovalPolicyExpectSurpriseRemoval : RemovalPolicyExpectOrderlyRemoval);
    }
 
    return status;
}

Referenced by RequestDispatchProcessDirectly().

RequestIsRealtimeStreaming()

BOOLEAN RequestIsRealtimeStreaming	(	_In_ WDFREQUEST	Request,
		_In_ BOOLEAN	IsReadRequest
	)

Definition at line 6050 of file ioctl.c.

{
    BOOLEAN     useStreaming = FALSE;
 
    if (!useStreaming) {
        //
        // Check if we're required to use Streaming via I/O Stack Location flags
        //
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        useStreaming = TEST_FLAG(currentStackLocationFlags, SL_REALTIME_STREAM);
    }
 
    if (!useStreaming) {
        //
        // Check if we were previously requested to enforce Streaming for
        // the file handle through which this request was sent.
        //
 
        WDFFILEOBJECT           fileObject;
        PFILE_OBJECT_CONTEXT    fileObjectContext;
 
        fileObject = WdfRequestGetFileObject(Request);
 
        if (fileObject != NULL) {
            fileObjectContext = FileObjectGetContext(fileObject);
            NT_ASSERT(fileObjectContext != NULL);
 
            if (IsReadRequest && fileObjectContext->EnforceStreamingRead)
            {
                useStreaming = TRUE;
            }
 
            if (!IsReadRequest && fileObjectContext->EnforceStreamingWrite)
            {
                useStreaming = TRUE;
            }
        }
    }
 
    return useStreaming;
}

Referenced by RequestValidateReadWrite(), and ScratchBuffer_SetupReadWriteSrb().

RequestValidateAacsBindingNonce()

NTSTATUS RequestValidateAacsBindingNonce	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2162 of file ioctl.c.

{
    NTSTATUS                 status = STATUS_SUCCESS;
    PCDROM_DATA              cdData = &(DeviceExtension->DeviceAdditionalData);
    PAACS_READ_BINDING_NONCE inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(AACS_READ_BINDING_NONCE))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_BINDING_NONCE))
    {
        *DataLength = sizeof(AACS_BINDING_NONCE);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_BINDING_NONCE))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->SessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else if (inputBuffer->NumberOfSectors > 255)
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else if (inputBuffer->StartLba > MAXULONG)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsEndSession()

NTSTATUS RequestValidateAacsEndSession	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3462 of file ioctl.c.

{
    NTSTATUS        status = STATUS_SUCCESS;
    PDVD_SESSION_ID sessionId = NULL;
    PCDROM_DATA     cdData = &(DeviceExtension->DeviceAdditionalData);
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &sessionId,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        if (!cdData->Mmc.IsAACS)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
        else if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsGetCertificate()

NTSTATUS RequestValidateAacsGetCertificate	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1757 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PDVD_SESSION_ID         sessionId = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_CERTIFICATE))
    {
        *DataLength = sizeof(AACS_CERTIFICATE);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_CERTIFICATE))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &sessionId,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*sessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsGetChallengeKey()

NTSTATUS RequestValidateAacsGetChallengeKey	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1826 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PDVD_SESSION_ID         sessionId = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_CHALLENGE_KEY))
    {
        *DataLength = sizeof(AACS_CHALLENGE_KEY);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_CHALLENGE_KEY))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &sessionId,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*sessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsReadMediaId()

NTSTATUS RequestValidateAacsReadMediaId	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2093 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PDVD_SESSION_ID         sessionId = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_MEDIA_ID))
    {
        *DataLength = sizeof(AACS_MEDIA_ID);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_MEDIA_ID))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &sessionId,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*sessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsReadMediaKeyBlock()

NTSTATUS RequestValidateAacsReadMediaKeyBlock	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1584 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PAACS_LAYER_NUMBER      layerNumber = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(AACS_LAYER_NUMBER))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < 8)
    {
        // This is a variable-length structure, but we're pretty sure
        // it can never be less than eight bytes...
        *DataLength = 8;
        status = STATUS_BUFFER_TOO_SMALL;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &layerNumber,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*layerNumber > 255)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsReadSerialNumber()

NTSTATUS RequestValidateAacsReadSerialNumber	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2024 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PDVD_SESSION_ID         sessionId = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_SERIAL_NUMBER))
    {
        *DataLength = sizeof(AACS_SERIAL_NUMBER);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_SERIAL_NUMBER))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &sessionId,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*sessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsReadVolumeId()

NTSTATUS RequestValidateAacsReadVolumeId	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1955 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PDVD_SESSION_ID         sessionId = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(AACS_VOLUME_ID))
    {
        *DataLength = sizeof(AACS_VOLUME_ID);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(AACS_VOLUME_ID))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &sessionId,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (*sessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsSendCertificate()

NTSTATUS RequestValidateAacsSendCertificate	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1697 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PAACS_SEND_CERTIFICATE  inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(AACS_SEND_CERTIFICATE))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->SessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsSendChallengeKey()

NTSTATUS RequestValidateAacsSendChallengeKey	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1895 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
    PCDROM_DATA                 cdData = &(DeviceExtension->DeviceAdditionalData);
    PAACS_SEND_CHALLENGE_KEY    inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != sizeof(AACS_SEND_CHALLENGE_KEY))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->SessionId > MAX_COPY_PROTECT_AGID)
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateAacsStartSession()

NTSTATUS RequestValidateAacsStartSession	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1651 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
 
    *DataLength = 0;
 
    if (!cdData->Mmc.IsAACS)
    {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(DVD_SESSION_ID))
    {
        *DataLength = sizeof(DVD_SESSION_ID);
        status = STATUS_BUFFER_TOO_SMALL;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > sizeof(DVD_SESSION_ID))
    {
        status = STATUS_INVALID_BUFFER_SIZE;
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateDvdEndSession()

NTSTATUS RequestValidateDvdEndSession	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3408 of file ioctl.c.

{
    NTSTATUS        status = STATUS_SUCCESS;
    PDVD_SESSION_ID sessionId = NULL;
 
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &sessionId,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(DVD_SESSION_ID))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "DvdDeviceControl: EndSession - input buffer too "
                        "small\n"));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateDvdReadKey()

NTSTATUS RequestValidateDvdReadKey	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3286 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PDVD_COPY_PROTECT_KEY   keyParameters = NULL;
    ULONG                   keyLength = 0;
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &keyParameters,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(DVD_COPY_PROTECT_KEY))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "DvdDeviceControl: EstablishDriveKey - challenge "
                        "key buffer too small\n"));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        switch(keyParameters->KeyType)
        {
 
            case DvdChallengeKey:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_CHALLENGE_KEY_LENGTH);
                keyLength = DVD_CHALLENGE_KEY_LENGTH;
                break;
            }
            case DvdBusKey1:
            case DvdBusKey2:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_BUS_KEY_LENGTH);
                keyLength = DVD_BUS_KEY_LENGTH;
                break;
            }
            case DvdTitleKey:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_TITLE_KEY_LENGTH);
                keyLength = DVD_TITLE_KEY_LENGTH;
                break;
            }
            case DvdAsf:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_ASF_LENGTH);
                keyLength = DVD_ASF_LENGTH;
                break;
            }
            case DvdDiskKey:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_DISK_KEY_LENGTH);
                keyLength = DVD_DISK_KEY_LENGTH;
                break;
            }
            case DvdGetRpcKey:
            {
                C_ASSERT(sizeof(DVD_COPY_PROTECT_KEY) <= DVD_RPC_KEY_LENGTH);
                keyLength = DVD_RPC_KEY_LENGTH;
                break;
            }
            default:
            {
                keyLength = sizeof(DVD_COPY_PROTECT_KEY);
                break;
            }
        }
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < keyLength)
        {
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "DvdDeviceControl: EstablishDriveKey - output "
                        "buffer too small\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            *DataLength = keyLength;
        }
        else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
                 DeviceExtension->AdapterDescriptor->AlignmentMask)
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else if (DeviceExtension->DeviceAdditionalData.DriveDeviceType != FILE_DEVICE_DVD)
        {
            // reject the request if it's not a DVD device.
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateDvdReadStructure()

NTSTATUS RequestValidateDvdReadStructure	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1151 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if (NT_SUCCESS(status))
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
           sizeof(DVD_READ_STRUCTURE))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "RequestValidateDvdReadStructure - input buffer "
                        "length too small (was %d should be %d)\n",
                        (int)RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                        sizeof(DVD_READ_STRUCTURE)));
            status = STATUS_INVALID_PARAMETER;
        }
        else if(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(READ_DVD_STRUCTURES_HEADER))
        {
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "RequestValidateDvdReadStructure - output buffer "
                        "cannot hold header information\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            *DataLength = sizeof(READ_DVD_STRUCTURES_HEADER);
        }
        else if(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength >
                MAXUSHORT)
        {
            // key length must fit in two bytes
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "RequestValidateDvdReadStructure - output buffer "
                        "too large\n"));
            status = STATUS_INVALID_PARAMETER;
        }
        else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
                 DeviceExtension->AdapterDescriptor->AlignmentMask)
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else if (DeviceExtension->DeviceAdditionalData.DriveDeviceType != FILE_DEVICE_DVD)
        {
            // reject the request if it's not a DVD device.
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateDvdSendKey()

NTSTATUS RequestValidateDvdSendKey	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1274 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PDVD_COPY_PROTECT_KEY   key = NULL;
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &key,
                                           NULL);
 
    if (NT_SUCCESS(status))
    {
        if((RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(DVD_COPY_PROTECT_KEY)) ||
           (RequestParameters.Parameters.DeviceIoControl.InputBufferLength != key->KeyLength))
        {
 
            //
            // Key is too small to have a header or the key length doesn't
            // match the input buffer length.  Key must be invalid
            //
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "RequestValidateDvdSendKey: [%p] IOCTL_DVD_SEND_KEY - "
                        "key is too small or does not match KeyLength\n",
                        Request));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // allow only certain key type (non-destructive) to go through
        // IOCTL_DVD_SEND_KEY (which only requires READ access to the device)
        if (RequestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_DVD_SEND_KEY)
        {
            if ((key->KeyType != DvdChallengeKey) &&
                (key->KeyType != DvdBusKey2) &&
                (key->KeyType != DvdInvalidateAGID))
            {
                status = STATUS_INVALID_PARAMETER;
            }
        }
        else if ((key->KeyType != DvdChallengeKey) &&
                (key->KeyType != DvdBusKey1) &&
                (key->KeyType != DvdBusKey2) &&
                (key->KeyType != DvdTitleKey) &&
                (key->KeyType != DvdAsf) &&
                (key->KeyType != DvdSetRpcKey) &&
                (key->KeyType != DvdGetRpcKey) &&
                (key->KeyType != DvdDiskKey) &&
                (key->KeyType != DvdInvalidateAGID))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else if (DeviceExtension->DeviceAdditionalData.DriveDeviceType != FILE_DEVICE_DVD)
        {
            // reject the request if it's not a DVD device.
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateDvdStartSession()

NTSTATUS RequestValidateDvdStartSession	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1225 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if (NT_SUCCESS(status))
    {
        if(RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
           sizeof(DVD_SESSION_ID))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                        "RequestValidateDvdStartSession: DVD_START_SESSION - output "
                        "buffer too small\n"));
            status = STATUS_BUFFER_TOO_SMALL;
            *DataLength = sizeof(DVD_SESSION_ID);
        }
        else if (DeviceExtension->DeviceAdditionalData.DriveDeviceType != FILE_DEVICE_DVD)
        {
            // reject the request if it's not a DVD device.
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateEnableStreaming()

NTSTATUS RequestValidateEnableStreaming	(	_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3515 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
 
    PCDROM_STREAMING_CONTROL    inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
        sizeof(CDROM_STREAMING_CONTROL))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        // Get the request type using CDROM_STREAMING_CONTROL structure
        status = WdfRequestRetrieveInputBuffer(Request,
                                               sizeof(CDROM_STREAMING_CONTROL),
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->RequestType != CdromStreamingDisable &&
            inputBuffer->RequestType != CdromStreamingEnableForReadOnly &&
            inputBuffer->RequestType != CdromStreamingEnableForWriteOnly &&
            inputBuffer->RequestType != CdromStreamingEnableForReadWrite)
        {
            // Unknown request type
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateExclusiveAccess()

NTSTATUS RequestValidateExclusiveAccess	(	_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2240 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_EXCLUSIVE_ACCESS exclusiveAccess = NULL;
 
    *DataLength = 0;
 
    if (KeGetCurrentIrql() != PASSIVE_LEVEL)
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestValidateExclusiveAccess: IOCTL must be called at passive level.\n"));
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(CDROM_EXCLUSIVE_ACCESS))
    {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestValidateExclusiveAccess: Input buffer too small\n"));
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &exclusiveAccess,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        switch (exclusiveAccess->RequestType)
        {
            case ExclusiveAccessQueryState:
            {
                if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
                    sizeof(CDROM_EXCLUSIVE_LOCK_STATE))
                {
                    //
                    // Output buffer too small.
                    //
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestValidateExclusiveAccess: Output buffer too small\n"));
                    *DataLength = sizeof(CDROM_EXCLUSIVE_LOCK_STATE);
                    status = STATUS_BUFFER_TOO_SMALL;
                }
                break;
            }
 
            case ExclusiveAccessLockDevice:
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
                    sizeof(CDROM_EXCLUSIVE_LOCK))
                {
                    //
                    // Input buffer too small
                    //
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestValidateExclusiveAccess: Input buffer too small\n"));
                    status = STATUS_INFO_LENGTH_MISMATCH;
                }
                break;
            }
            case ExclusiveAccessUnlockDevice:
            {
                //
                // Nothing to check
                //
                break;
            }
 
            default:
            {
                //
                // Unknown request type.
                //
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "RequestValidateExclusiveAccess: Invalid request type\n"));
                status = STATUS_INVALID_PARAMETER;
            }
        }
    }
 
    return status;
}

Referenced by RequestDispatchSyncWithSequentialQueue().

RequestValidateGetConfiguration()

NTSTATUS RequestValidateGetConfiguration	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1364 of file ioctl.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(GET_CONFIGURATION_HEADER))
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(GET_CONFIGURATION_HEADER);
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > 0xffff)
    {
        // output buffer is too large
        status = STATUS_INVALID_BUFFER_SIZE;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
        DeviceExtension->AdapterDescriptor->AlignmentMask)
    {
        // buffer is not proper size multiple
        status = STATUS_INVALID_PARAMETER;
    }
 
    if (NT_SUCCESS(status))
    {
 
#if BUILD_WOW64_ENABLED && defined(_WIN64)
 
        if (WdfRequestIsFrom32BitProcess(Request))
        {
            PGET_CONFIGURATION_IOCTL_INPUT32 inputBuffer = NULL;
 
            if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
                sizeof(GET_CONFIGURATION_IOCTL_INPUT32))
            {
                status = STATUS_INFO_LENGTH_MISMATCH;
            }
 
            //
            // also verify the arguments are reasonable.
            //
            if (NT_SUCCESS(status))
            {
                status = WdfRequestRetrieveInputBuffer(Request,
                                                       RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                       &inputBuffer,
                                                       NULL);
            }
 
            if (NT_SUCCESS(status))
            {
                if (inputBuffer->Feature > 0xffff)
                {
                    status = STATUS_INVALID_PARAMETER;
                }
                else if ((inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE) &&
                         (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT) &&
                         (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
                else if (inputBuffer->Reserved[0] || inputBuffer->Reserved[1])
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
        else
 
#endif
 
        {
            PGET_CONFIGURATION_IOCTL_INPUT inputBuffer = NULL;
 
            if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
                sizeof(GET_CONFIGURATION_IOCTL_INPUT))
            {
                status = STATUS_INFO_LENGTH_MISMATCH;
            }
 
            // also verify the arguments are reasonable.
            if (NT_SUCCESS(status))
            {
                status = WdfRequestRetrieveInputBuffer(Request,
                                                       RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                       &inputBuffer,
                                                       NULL);
            }
 
            if (NT_SUCCESS(status))
            {
                if (inputBuffer->Feature > 0xffff)
                {
                    status = STATUS_INVALID_PARAMETER;
                }
                else if ((inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE) &&
                         (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT) &&
                         (inputBuffer->RequestType != SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
                else if (inputBuffer->Reserved[0] || inputBuffer->Reserved[1])
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateGetLastSession()

NTSTATUS RequestValidateGetLastSession	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1029 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(CDROM_TOC_SESSION_DATA))
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(CDROM_TOC_SESSION_DATA);
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
             DeviceExtension->AdapterDescriptor->AlignmentMask)
    {
        status = STATUS_INVALID_PARAMETER;
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateGetPerformance()

NTSTATUS RequestValidateGetPerformance	(	_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3634 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
    PCDROM_WRITE_SPEED_REQUEST  writeSpeedRequest = NULL;
    PCDROM_PERFORMANCE_REQUEST  performanceRequest = NULL;
 
    *DataLength = 0;
 
    // CDROM_WRITE_SPEED_REQUEST is the smallest performance request that we support.
    // We use it to retrieve request type and then check input length more carefully
    // on a per request type basis.
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
        sizeof(CDROM_WRITE_SPEED_REQUEST))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               sizeof(CDROM_WRITE_SPEED_REQUEST),
                                               (PVOID*)&writeSpeedRequest,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (writeSpeedRequest->RequestType == CdromPerformanceRequest)
        {
            // CDROM_PERFORMANCE_REQUEST is bigger than CDROM_WRITE_SPEED_REQUEST,
            // so we perform more checks and retrieve more bytes through WDF.
            if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
                sizeof(CDROM_PERFORMANCE_REQUEST))
            {
                status = STATUS_INFO_LENGTH_MISMATCH;
            }
            if (NT_SUCCESS(status))
            {
                status = WdfRequestRetrieveInputBuffer(Request,
                                                       sizeof(CDROM_PERFORMANCE_REQUEST),
                                                       &performanceRequest,
                                                       NULL);
            }
 
            if (!NT_SUCCESS(status))
            {
                // just pass the status code from above
            }
            // validate all enum-type fields of CDROM_PERFORMANCE_REQUEST
            else if (performanceRequest->PerformanceType != CdromReadPerformance &&
                     performanceRequest->PerformanceType != CdromWritePerformance)
            {
                status = STATUS_INVALID_PARAMETER;
            }
            else if (performanceRequest->Exceptions != CdromNominalPerformance &&
                     performanceRequest->Exceptions != CdromEntirePerformanceList &&
                     performanceRequest->Exceptions != CdromPerformanceExceptionsOnly)
            {
                status = STATUS_INVALID_PARAMETER;
            }
            else if (performanceRequest->Tolerance != Cdrom10Nominal20Exceptions)
            {
                status = STATUS_INVALID_PARAMETER;
            }
        }
        else if (writeSpeedRequest->RequestType == CdromWriteSpeedRequest)
        {
            // No additional checks here: all remaining fields are ignored
            // if RequestType == CdromWriteSpeedRequest.
        }
        else
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    // finally, check output buffer length
    if (NT_SUCCESS(status))
    {
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
                 sizeof(CDROM_PERFORMANCE_HEADER))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            *DataLength = sizeof(CDROM_PERFORMANCE_HEADER);
        }
        else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength >
            ((USHORT)-1))
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidatePersistentReserve()

NTSTATUS RequestValidatePersistentReserve	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 6715 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    ULONG               ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    PPERSISTENT_RESERVE_COMMAND reserveCommand = NULL;
 
    *DataLength = 0;
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           (PVOID*)&reserveCommand,
                                           NULL);
    if (NT_SUCCESS(status))
    {
        if ((RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(PERSISTENT_RESERVE_COMMAND)) ||
            (reserveCommand->Size < sizeof(PERSISTENT_RESERVE_COMMAND)))
        {
            *DataLength = 0;
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else if ((ULONG_PTR)reserveCommand & DeviceExtension->AdapterDescriptor->AlignmentMask)
        {
            // Check buffer alignment. Only an issue if another kernel mode component
            // (not the I/O manager) allocates the buffer.
            *DataLength = 0;
            status = STATUS_INVALID_USER_BUFFER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        if (ioctlCode == IOCTL_STORAGE_PERSISTENT_RESERVE_IN)
        {
            if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < reserveCommand->PR_IN.AllocationLength)
            {
                *DataLength = 0;
                status = STATUS_INVALID_PARAMETER;
            }
            else
            {
                switch (reserveCommand->PR_IN.ServiceAction)
                {
                case RESERVATION_ACTION_READ_KEYS:
                    if (reserveCommand->PR_IN.AllocationLength < sizeof(PRI_REGISTRATION_LIST))
                    {
                        *DataLength = 0;
                        status = STATUS_INVALID_PARAMETER;
                    }
                    break;
 
                case RESERVATION_ACTION_READ_RESERVATIONS:
                    if (reserveCommand->PR_IN.AllocationLength < sizeof(PRI_RESERVATION_LIST))
                    {
                        *DataLength = 0;
                        status = STATUS_INVALID_PARAMETER;
                    }
                    break;
 
                default:
                    *DataLength = 0;
                    status = STATUS_INVALID_PARAMETER;
                    break;
                }
            }
        }
        else // case of IOCTL_STORAGE_PERSISTENT_RESERVE_OUT
        {
            // Verify ServiceAction, Scope, and Type
            switch (reserveCommand->PR_OUT.ServiceAction)
            {
            case RESERVATION_ACTION_REGISTER:
            case RESERVATION_ACTION_REGISTER_IGNORE_EXISTING:
            case RESERVATION_ACTION_CLEAR:
                // Scope and type ignored.
                break;
 
            case RESERVATION_ACTION_RESERVE:
            case RESERVATION_ACTION_RELEASE:
            case RESERVATION_ACTION_PREEMPT:
            case RESERVATION_ACTION_PREEMPT_ABORT:
                if (!ValidPersistentReserveScope(reserveCommand->PR_OUT.Scope) ||
                    !ValidPersistentReserveType(reserveCommand->PR_OUT.Type))
                {
                    *DataLength = 0;
                    status = STATUS_INVALID_PARAMETER;
                }
                break;
 
            default:
                *DataLength = 0;
                status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            // Check input buffer for PR Out.
            // Caller must include the PR parameter list.
            if (NT_SUCCESS(status))
            {
                if ((RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
                        (sizeof(PERSISTENT_RESERVE_COMMAND) + sizeof(PRO_PARAMETER_LIST))) ||
                    (reserveCommand->Size < RequestParameters.Parameters.DeviceIoControl.InputBufferLength))
                {
                    *DataLength = 0;
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        } // end of validation for IOCTL_STORAGE_PERSISTENT_RESERVE_OUT
    }
 
    return status;
} // end RequestValidatePersistentReserve()

Referenced by RequestDispatchToSequentialQueue().

RequestValidateRawRead()

NTSTATUS RequestValidateRawRead	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 650 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    PCDROM_DATA         cdData = &(DeviceExtension->DeviceAdditionalData);
 
    PVOID               inputBuffer = NULL;
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  currentStack = NULL;
 
    LARGE_INTEGER       startingOffset = {0};
    ULONGLONG           transferBytes = 0;
    ULONGLONG           endOffset;
    ULONGLONG           mdlBytes;
    RAW_READ_INFO       rawReadInfo = {0};
 
    *DataLength = 0;
 
    irp = WdfRequestWdmGetIrp(Request);
    currentStack = IoGetCurrentIrpStackLocation(irp);
 
    status = WdfRequestRetrieveInputBuffer(Request,
                                           RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                           &inputBuffer,
                                           NULL);
 
    // Check that ending sector is on disc and buffers are there and of
    // correct size.
    if (NT_SUCCESS(status) &&
        (RequestParameters.Parameters.DeviceIoControl.Type3InputBuffer == NULL))
    {
        //  This is a call from user space.  This is the only time that we need to validate parameters.
        //  Validate the input and get the input buffer into Type3InputBuffer
        //  so the rest of the code will be uniform.
        if (inputBuffer != NULL)
        {
            currentStack->Parameters.DeviceIoControl.Type3InputBuffer = inputBuffer;
            RequestParameters.Parameters.DeviceIoControl.Type3InputBuffer = inputBuffer;
 
            if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(RAW_READ_INFO))
            {
                *DataLength = sizeof(RAW_READ_INFO);
                status = STATUS_BUFFER_TOO_SMALL;
            }
        }
        else
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        //  Since this ioctl is METHOD_OUT_DIRECT, we need to copy away the input buffer before interpreting it.
        //  This prevents a malicious app from messing with the input buffer while we are interpreting it.
        rawReadInfo = *(PRAW_READ_INFO)RequestParameters.Parameters.DeviceIoControl.Type3InputBuffer;
 
        startingOffset.QuadPart = rawReadInfo.DiskOffset.QuadPart;
 
        if ((rawReadInfo.TrackMode == CDDA)        ||
            (rawReadInfo.TrackMode == YellowMode2) ||
            (rawReadInfo.TrackMode == XAForm2)     )
        {
            transferBytes = (ULONGLONG)rawReadInfo.SectorCount * RAW_SECTOR_SIZE;
        }
        else if (rawReadInfo.TrackMode == RawWithSubCode)
        {
            transferBytes = (ULONGLONG)rawReadInfo.SectorCount * CD_RAW_SECTOR_WITH_SUBCODE_SIZE;
        }
        else if (rawReadInfo.TrackMode == RawWithC2)
        {
            transferBytes = (ULONGLONG)rawReadInfo.SectorCount * CD_RAW_SECTOR_WITH_C2_SIZE;
        }
        else if (rawReadInfo.TrackMode == RawWithC2AndSubCode)
        {
            transferBytes = (ULONGLONG)rawReadInfo.SectorCount * CD_RAW_SECTOR_WITH_C2_AND_SUBCODE_SIZE;
        }
        else
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                      "RequestValidateRawRead: Invalid TrackMode type %x for XA read\n",
                      rawReadInfo.TrackMode
                      ));
        }
 
        endOffset = (ULONGLONG)rawReadInfo.SectorCount * COOKED_SECTOR_SIZE;
        endOffset += startingOffset.QuadPart;
 
        // check for overflows....
        if (rawReadInfo.SectorCount == 0)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid I/O parameters for XA "
                        "Read (zero sectors requested)\n"));
            status = STATUS_INVALID_PARAMETER;
        }
        else if (transferBytes < (ULONGLONG)(rawReadInfo.SectorCount))
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid I/O parameters for XA "
                        "Read (TransferBytes Overflow)\n"));
            status = STATUS_INVALID_PARAMETER;
        }
        else if (endOffset < (ULONGLONG)startingOffset.QuadPart)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid I/O parameters for XA "
                        "Read (EndingOffset Overflow)\n"));
            status = STATUS_INVALID_PARAMETER;
        }
        else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < transferBytes)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid I/O parameters for XA "
                        "Read (Bad buffer size)\n"));
            status = STATUS_INVALID_PARAMETER;
        }
        else if (endOffset > (ULONGLONG)DeviceExtension->PartitionLength.QuadPart)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid I/O parameters for XA "
                        "Read (Request Out of Bounds)\n"));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // cannot validate the MdlAddress, since it is not included in any
        // other location per the DDK and file system calls.
 
        // validate the mdl describes at least the number of bytes
        // requested from us.
        mdlBytes = (ULONGLONG)MmGetMdlByteCount(irp->MdlAddress);
        if (mdlBytes < transferBytes)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "RequestValidateRawRead: Invalid MDL %s, Irp %p\n",
                        "size (5)", irp));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // check the buffer for alignment
        // This is important for x86 as some busses (ie ATAPI)
        // require word-aligned buffers.
        if ( ((ULONG_PTR)MmGetMdlVirtualAddress(irp->MdlAddress)) &
             DeviceExtension->AdapterDescriptor->AlignmentMask )
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                      "RequestValidateRawRead: Invalid I/O parameters for "
                      "XA Read (Buffer %p not aligned with mask %x\n",
                      RequestParameters.Parameters.DeviceIoControl.Type3InputBuffer,
                      DeviceExtension->AdapterDescriptor->AlignmentMask));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // Validate the request is not too large for the adapter
        BOOLEAN bufferIsPageAligned = FALSE;
        ULONG   maxLength = 0;
 
        // if buffer is not page-aligned, then subtract one as the
        // transfer could cross a page boundary.
        if ((((ULONG_PTR)MmGetMdlVirtualAddress(irp->MdlAddress)) & (PAGE_SIZE-1)) == 0)
        {
            bufferIsPageAligned = TRUE;
        }
 
        if (bufferIsPageAligned)
        {
            maxLength = cdData->MaxPageAlignedTransferBytes;
        }
        else
        {
            maxLength = cdData->MaxUnalignedTransferBytes;
        }
 
        if (transferBytes > maxLength)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                      "RequestValidateRawRead: The XA Read (type %x) would require %I64x bytes, "
                      "but the adapter can only handle %x bytes (for a%saligned buffer)\n",
                      rawReadInfo.TrackMode,
                      transferBytes,
                      maxLength,
                      (bufferIsPageAligned ? " " : "n un")
                      ));
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        //
        // HACKHACK - REF #0001
        // The retry count will be in this irp's IRP_MN function,
        // as the new irp was freed, and we therefore cannot use
        // this irp's next stack location for this function.
        // This may be a good location to store this info for
        // when we remove RAW_READ (mode switching), as we will
        // no longer have the nextIrpStackLocation to play with
        // when that occurs
        //
        currentStack->MinorFunction = MAXIMUM_RETRIES; // HACKHACK - REF #0001
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateReadQChannel()

NTSTATUS RequestValidateReadQChannel	(	_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1072 of file ioctl.c.

{
    NTSTATUS                 status = STATUS_SUCCESS;
    PCDROM_SUB_Q_DATA_FORMAT inputBuffer = NULL;
    ULONG                    transferByteCount = 0;
 
    *DataLength = 0;
 
    if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
       sizeof(CDROM_SUB_Q_DATA_FORMAT))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        // check for all valid types of request
        if (inputBuffer->Format == IOCTL_CDROM_CURRENT_POSITION)
        {
            transferByteCount = sizeof(SUB_Q_CURRENT_POSITION);
        }
        else if (inputBuffer->Format == IOCTL_CDROM_MEDIA_CATALOG)
        {
            transferByteCount = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
        }
        else if (inputBuffer->Format == IOCTL_CDROM_TRACK_ISRC)
        {
            transferByteCount = sizeof(SUB_Q_TRACK_ISRC);
        }
        else
        {
            // Format not valid
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            transferByteCount)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            *DataLength = transferByteCount;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateReadToc()

NTSTATUS RequestValidateReadToc	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 984 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(CDROM_TOC))
    {
        // they didn't request the entire TOC -- use _EX version
        // for partial transfers and such.
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = sizeof(CDROM_TOC);
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
             DeviceExtension->AdapterDescriptor->AlignmentMask)
    {
        status = STATUS_INVALID_PARAMETER;
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateReadTocEx()

NTSTATUS RequestValidateReadTocEx	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 887 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
 
    PCDROM_READ_TOC_EX  inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
        sizeof(CDROM_READ_TOC_EX))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
             MINIMUM_CDROM_READ_TOC_EX_SIZE)
    {
        status = STATUS_BUFFER_TOO_SMALL;
        *DataLength = MINIMUM_CDROM_READ_TOC_EX_SIZE;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength >
             ((USHORT)-1))
    {
        status = STATUS_INVALID_PARAMETER;
    }
    else if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength &
             DeviceExtension->AdapterDescriptor->AlignmentMask)
    {
        status = STATUS_INVALID_PARAMETER;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveInputBuffer(Request,
                                               RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if ((inputBuffer->Reserved1 != 0) ||
            (inputBuffer->Reserved2 != 0) ||
            (inputBuffer->Reserved3 != 0))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        // NOTE: when adding new formats, ensure that first two bytes
        //       specify the amount of additional data available.
        else if ((inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_TOC     ) ||
                 (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_FULL_TOC) ||
                 (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_CDTEXT  ))
        {
            // SessionTrack field is used
        }
        else if ((inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_SESSION) ||
                 (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_PMA)     ||
                 (inputBuffer->Format == CDROM_READ_TOC_EX_FORMAT_ATIP))
        {
            // SessionTrack field is reserved
            if (inputBuffer->SessionTrack != 0)
            {
                status = STATUS_INVALID_PARAMETER;
            }
        }
        else
        {
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateReadWrite()

NTSTATUS RequestValidateReadWrite	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 6117 of file ioctl.c.

{
    NTSTATUS            status = STATUS_SUCCESS;
    PCDROM_DATA         cdData = &(DeviceExtension->DeviceAdditionalData);
 
    BOOLEAN             isValid = TRUE;
    LONGLONG            startingOffset = 0;
    size_t              transferByteCount = 0;
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  currentStack = NULL;
 
    irp = WdfRequestWdmGetIrp(Request);
    currentStack = IoGetCurrentIrpStackLocation(irp);
 
    if (TEST_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        (currentStack->MinorFunction != CDROM_VOLUME_VERIFY_CHECKED) &&
        !TEST_FLAG(currentStack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        //  DO_VERIFY_VOLUME is set for the device object,
        //  but this request is not itself a verify request.
        //  So fail this request.
 
        //set the status for volume verification.
        status = STATUS_VERIFY_REQUIRED;
    }
 
    if (NT_SUCCESS(status))
    {
        if (PLAY_ACTIVE(DeviceExtension))
        {
            status = STATUS_DEVICE_BUSY;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // If the device is in exclusive mode, check whether the request is from
        // the handle that locked the device.
        if (EXCLUSIVE_MODE(cdData) && !EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)))
        {
            // This request is not from the owner. We can't let the operation go.
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW, "RequestValidateReadWrite: Access Denied! Device in exclusive mode.\n"));
 
            status = STATUS_ACCESS_DENIED;
        }
    }
 
    // Validate the request alignment.
    if (NT_SUCCESS(status))
    {
        if (RequestParameters.Type == WdfRequestTypeRead)
        {
            startingOffset = RequestParameters.Parameters.Read.DeviceOffset;
            transferByteCount = RequestParameters.Parameters.Read.Length;
        }
        else
        {
            startingOffset = RequestParameters.Parameters.Write.DeviceOffset;
            transferByteCount = RequestParameters.Parameters.Write.Length;
        }
 
        if (!DeviceExtension->DiskGeometry.BytesPerSector)
        {
            DeviceExtension->DiskGeometry.BytesPerSector = 2048;
        }
 
        if (!DeviceExtension->SectorShift)
        {
            DeviceExtension->SectorShift = 11;
        }
 
        // Perform some basic validation up front
        if (TEST_FLAG(startingOffset, DeviceExtension->DiskGeometry.BytesPerSector - 1) ||
            TEST_FLAG(transferByteCount,       DeviceExtension->DiskGeometry.BytesPerSector - 1))
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    }
 
    // validate the request against the current mmc schema
    if (NT_SUCCESS(status))
    {
        FEATURE_NUMBER schema = cdData->Mmc.ValidationSchema;
 
        // We validate read requests according to the RandomWritable schema, except in the
        // case of IncrementalStreamingWritable, wherein  the drive is responsible for all
        // of the verification
        if (RequestParameters.Type == WdfRequestTypeRead)
        {
            if (!cdData->Mmc.WriteAllowed)
            {
                // standard legacy validation of read irps
                // if writing is not allowed on the media
                schema =  FeatureRandomWritable;
            }
            else if (schema != FeatureIncrementalStreamingWritable)
            {
                // standard legacy validation of read irps
                // if not using streaming writes on writable media
                schema =  FeatureRandomWritable;
            }
        }
 
        // Fail write requests to read-only media
        if ((RequestParameters.Type == WdfRequestTypeWrite) &&
            !(cdData->Mmc.WriteAllowed))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,  "RequestValidateReadWrite: Write request to read-only media\n"));
            isValid = FALSE;
        }
 
        if (isValid)
        {
            switch (schema)
            {
                case FeatureDefectManagement:
                case FeatureRandomWritable:
                    // Ensure that the request is within bounds for ROM drives.
                    // Writer drives do not need to have bounds as outbounds request should not damage the drive.
                    if(!cdData->Mmc.IsWriter)
                    {
                        if ((startingOffset >= DeviceExtension->PartitionLength.QuadPart) ||
                            startingOffset < 0)
                        {
                            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,  "RequestValidateReadWrite: Request is out of bounds\n"));
                            isValid = FALSE;
 
                        }
                        else
                        {
                            ULONGLONG bytesRemaining = DeviceExtension->PartitionLength.QuadPart - startingOffset;
 
                            if ((ULONGLONG)transferByteCount > bytesRemaining)
                            {
                                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,  "RequestValidateReadWrite: Request is out of bounds\n"));
                                isValid = FALSE;
                            }
                        }
                    }
                    break;
 
                case FeatureRigidRestrictedOverwrite:
                    // Ensure that the number of blocks is a multiple of the blocking size
                    if (((transferByteCount >> DeviceExtension->SectorShift) % cdData->Mmc.Blocking) != 0)
                    {
                        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,
                                   "RequestValidateReadWrite: Number of blocks is not a multiple of the blocking size (%x)\n",
                                   cdData->Mmc.Blocking));
 
                        isValid = FALSE;
                    }
                    // Fall through
                case FeatureRestrictedOverwrite:
                    // Ensure that the request begins on a blocking boundary
                    if ((Int64ShrlMod32(startingOffset, DeviceExtension->SectorShift) % cdData->Mmc.Blocking) != 0)
                    {
                        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,
                                   "RequestValidateReadWrite: Starting block is not a multiple of the blocking size (%x)\n",
                                   cdData->Mmc.Blocking));
 
                        isValid = FALSE;
                    }
                    break;
 
                case FeatureIncrementalStreamingWritable:
                    // Let the drive handle the verification
                    break;
 
                default:
                    // Unknown schema. Fail the request
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,
                               "RequestValidateReadWrite: Unknown validation schema (%x)\n",
                               schema));
 
                    isValid = FALSE;
                    break;
            } //end of switch (schema)
        } // end of if (isValid)
 
        if (!isValid)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
        }
    } // end of mmc schema validation
 
    // validate that the Real-Time Streaming requests meet device capabilties
    if (NT_SUCCESS(status))
    {
        // We do not check for FDO_HACK_NO_STREAMING in DeviceExtension->PrivateFdoData->HackFlags here,
        // because we're going to hide device failures related to streaming reads/writes from the sender
        // of the request. FDO_HACK_NO_STREAMING is going to be taken into account later during actual
        // processing of the request.
        if (RequestIsRealtimeStreaming(Request, RequestParameters.Type == WdfRequestTypeRead))
        {
            if (RequestParameters.Type == WdfRequestTypeRead && !cdData->Mmc.StreamingReadSupported)
            {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,
                           "RequestValidateReadWrite: Streaming reads are not supported.\n"));
 
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
            if (RequestParameters.Type == WdfRequestTypeWrite && !cdData->Mmc.StreamingWriteSupported)
            {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_RW,
                           "RequestValidateReadWrite: Streaming writes are not supported.\n"));
 
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
        }
    }
 
    return status;
}

Referenced by ReadWriteWorkItemRoutine(), and SequentialQueueEvtIoReadWrite().

RequestValidateSendOpcInformation()

NTSTATUS RequestValidateSendOpcInformation	(	_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 3576 of file ioctl.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
 
    PCDROM_SIMPLE_OPC_INFO      inputBuffer = NULL;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
        sizeof(CDROM_SIMPLE_OPC_INFO))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        // Get the request type using CDROM_SIMPLE_OPC_INFO structure
        status = WdfRequestRetrieveInputBuffer(Request,
                                               sizeof(CDROM_SIMPLE_OPC_INFO),
                                               &inputBuffer,
                                               NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->RequestType != SimpleOpcInfo)
        {
            // Unknown request type
            status = STATUS_INVALID_PARAMETER;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

RequestValidateSetSpeed()

NTSTATUS RequestValidateSetSpeed	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 1501 of file ioctl.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DATA             cdData = &(DeviceExtension->DeviceAdditionalData);
    PCDROM_SET_SPEED        inputBuffer = NULL;
    ULONG                   requiredLength = 0;
 
    *DataLength = 0;
 
    if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(CDROM_SET_SPEED))
    {
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    if (NT_SUCCESS(status))
    {
        // Get the request type using CDROM_SET_SPEED structure
        status = WdfRequestRetrieveInputBuffer(Request,
                                               sizeof(CDROM_SET_SPEED),
                                               &inputBuffer,
                                               NULL);
 
    }
 
    if (NT_SUCCESS(status))
    {
        if (inputBuffer->RequestType > CdromSetStreaming)
        {
            // Unknown request type.
            status = STATUS_INVALID_PARAMETER;
        }
        else if (inputBuffer->RequestType == CdromSetSpeed)
        {
            requiredLength = sizeof(CDROM_SET_SPEED);
        }
        else
        {
            // Don't send SET STREAMING command if this is not a MMC compliant device
            if (cdData->Mmc.IsMmc == FALSE)
            {
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
 
            requiredLength = sizeof(CDROM_SET_STREAMING);
        }
    }
 
    if (NT_SUCCESS(status))
    {
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < requiredLength)
        {
            // Input buffer too small
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
    }
 
    return status;
}

Referenced by RequestDispatchToSequentialQueue().

ValidPersistentReserveScope()

static BOOLEAN ValidPersistentReserveScope ( UCHAR  Scope )

static

Definition at line 6680 of file ioctl.c.

{
    switch (Scope) {
    case RESERVATION_SCOPE_LU:
    case RESERVATION_SCOPE_ELEMENT:
 
        return TRUE;
 
    default:
 
        return FALSE;
    }
}

Referenced by RequestValidatePersistentReserve().

ValidPersistentReserveType()

static BOOLEAN ValidPersistentReserveType ( UCHAR  Type )

static

Definition at line 6697 of file ioctl.c.

{
    switch (Type) {
    case RESERVATION_TYPE_WRITE_EXCLUSIVE:
    case RESERVATION_TYPE_EXCLUSIVE:
    case RESERVATION_TYPE_WRITE_EXCLUSIVE_REGISTRANTS:
    case RESERVATION_TYPE_EXCLUSIVE_REGISTRANTS:
 
        return TRUE;
 
    default:
 
        return FALSE;
    }
}

Referenced by RequestValidatePersistentReserve().