ioctl.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BOOLEAN	RequestDispatchProcessDirectly (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchToSequentialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchSyncWithSequentialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchSpecialIoctls (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchUnknownRequests (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
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	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)
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)
	_IRQL_requires_max_ (APC_LEVEL) NTSTATUS RequestHandleEventNotification(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
NTSTATUS	RequestHandleQueryPropertyRetrieveCachedData (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
	_IRQL_requires_max_ (PASSIVE_LEVEL) NTSTATUS RequestHandleGetDriveGeometry(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
NTSTATUS	RequestHandleUnknownIoctl (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestHandleQueryPropertyDeviceUniqueId (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestHandleQueryPropertyWriteCache (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestHandleReadWrite (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
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	RequestValidateDvdReadKey (_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	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)
BOOLEAN	RequestIsRealtimeStreaming (_In_ WDFREQUEST Request, _In_ BOOLEAN IsReadRequest)
NTSTATUS	RequestValidateReadWrite (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
NTSTATUS	RequestValidatePersistentReserve (_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)

Variables
_In_opt_ WDFREQUEST	Request
_In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_PARAMETERS	RequestParameters
_In_opt_ WDFREQUEST _In_opt_ PWDF_REQUEST_PARAMETERS _Out_ size_t *	DataLength

Function Documentation

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 37 of file cddata.c.

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

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 923 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;
 
    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;
 
        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;
 
            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }
 
    return Status;
}

RequestDispatchProcessDirectly()

BOOLEAN RequestDispatchProcessDirectly	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 1694 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_GET_INQUIRY_DATA:
    {
        status = RequestHandleGetInquiryData(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_MEDIA_TYPES_EX:
    {
        status = RequestHandleGetMediaTypeEx(deviceExtension, Request, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:
    {
        status = RequestHandleMountQueryUniqueId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:
    {
        status = RequestHandleMountQueryDeviceName(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:
    {
        status = RequestHandleMountQuerySuggestedLinkName(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_DEVICE_NUMBER:
    {
        status = RequestHandleGetDeviceNumber(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_HOTPLUG_INFO:
    {
        status = RequestHandleGetHotPlugInfo(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_SET_HOTPLUG_INFO:
    {
        status = RequestHandleSetHotPlugInfo(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_EVENT_NOTIFICATION:
    {
        status = RequestHandleEventNotification(deviceExtension, Request, &RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    case IOCTL_VOLUME_ONLINE:
    {
        //
        // Mount manager and volume manager will
        // follow this online with a post online
        // but other callers may not. In those
        // cases, we process this request right
        // away. We approximate that these other
        // callers are from user mode
        //
 
        if (WdfRequestGetRequestorMode(Request) == KernelMode)
        {
            processed = TRUE;
        }
        break;
    }
#endif
 
    default:
    {
        processed = FALSE;
        break;
    }
 
    } //end of switch (ioctlCode)
 
    if (processed)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchProcessDirectly(Device, Request, RequestParameters);
        }
        else
        {
            // Complete the request after processing it.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchProcessDirectly().

RequestDispatchSpecialIoctls()

BOOLEAN RequestDispatchSpecialIoctls	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 2849 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
    BOOLEAN                 requestCompleted = FALSE;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
    case IOCTL_SCSI_PASS_THROUGH:
    case IOCTL_SCSI_PASS_THROUGH_DIRECT:
    case IOCTL_SCSI_PASS_THROUGH_EX:
    case IOCTL_SCSI_PASS_THROUGH_DIRECT_EX:
    {
        // SPTI is considered special case as we need to set the MinorFunction before pass to low level.
 
#if defined (_WIN64)
        if (WdfRequestIsFrom32BitProcess(Request))
        {
            if ((ioctlCode == IOCTL_SCSI_PASS_THROUGH) || (ioctlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT))
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH32))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
            else
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH32_EX))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
        else
#endif
        {
            if ((ioctlCode == IOCTL_SCSI_PASS_THROUGH) || (ioctlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT))
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
            else
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH_EX))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
 
        if (!NT_SUCCESS(status))
        {
            // validation failed.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
        else
        {
            // keep the request in serialized manner and stay in user's context.
            status = RequestSetContextFields(Request, RequestHandleScsiPassThrough);
 
            if (NT_SUCCESS(status))
            {
                status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
            }
            else
            {
                RequestCompletion(deviceExtension, Request, status, 0);
            }
        }
 
        requestCompleted = TRUE;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_QUERY_PROPERTY:
    {
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_PROPERTY_QUERY))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            PSTORAGE_PROPERTY_QUERY inputBuffer = NULL;
 
            status = WdfRequestRetrieveInputBuffer(Request,
                                                   RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                   &inputBuffer,
                                                   NULL);
 
            if (NT_SUCCESS(status))
            {
                if (!EXCLUSIVE_MODE(cdData) ||                                     // not locked
                    EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)) ||   // request is from lock owner
                    (inputBuffer->QueryType == PropertyExistsQuery))               // request not access device
                {
                    if (inputBuffer->PropertyId == StorageDeviceUniqueIdProperty)
                    {
                        // previously handled in classpnp
                        // keep the request in serialized manner and stay in user's context.
                        status = RequestSetContextFields(Request, RequestHandleQueryPropertyDeviceUniqueId);
 
                        if (NT_SUCCESS(status))
                        {
                            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
                            // remeber that the request has been completed.
                            requestCompleted = TRUE;
                        }
                    }
                    else if (inputBuffer->PropertyId == StorageDeviceWriteCacheProperty)
                    {
                        // previously handled in classpnp
                        // keep the request in serialized manner and stay in user's context.
                        status = RequestSetContextFields(Request, RequestHandleQueryPropertyWriteCache);
 
                        if (NT_SUCCESS(status))
                        {
                            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
                            // remeber that the request has been completed.
                            requestCompleted = TRUE;
                        }
                    }
                    else
                    {
                        // Pass to port driver for handling
                        RequestDispatchUnknownRequests(Device, Request, RequestParameters);
 
                        // remeber that the request has been completed.
                        requestCompleted = TRUE;
                    }
                }
                else
                {
                    // If cached data exists, return cached data. Otherwise, fail the request.
                    if ((inputBuffer->QueryType == PropertyStandardQuery) &&
                        ((inputBuffer->PropertyId == StorageDeviceProperty) || (inputBuffer->PropertyId == StorageAdapterProperty)) )
                    {
                        status = RequestHandleQueryPropertyRetrieveCachedData(deviceExtension, Request, RequestParameters, &dataLength);
                    }
                    else
                    {
                        status = STATUS_ACCESS_DENIED;
                    }
                }
            }
        }
 
        processed = TRUE;
        break;
    }
 
    // this IOCTL is a fake one, used for MCN process sync-ed with serial queue.
    case IOCTL_MCN_SYNC_FAKE_IOCTL:
    {
        PIRP irp = WdfRequestWdmGetIrp(Request);
 
        if ((deviceExtension->MediaChangeDetectionInfo != NULL) &&
            (irp == deviceExtension->MediaChangeDetectionInfo->MediaChangeSyncIrp) &&
            (WdfRequestGetRequestorMode(Request) == KernelMode) &&
            (RequestParameters.Parameters.Others.Arg1 == RequestSetupMcnSyncIrp) &&
            (RequestParameters.Parameters.Others.Arg2 == RequestSetupMcnSyncIrp) &&
            (RequestParameters.Parameters.Others.Arg4 == RequestSetupMcnSyncIrp))
        {
            // This is the requset we use to sync Media Change Detection with sequential queue.
            status = WdfDeviceEnqueueRequest(Device, Request);
 
            if (!NT_SUCCESS(status))
            {
                RequestCompletion(deviceExtension, Request, status, dataLength);
            }
 
            requestCompleted = TRUE;
            processed = TRUE;
        }
        else
        {
            // process as an unknown request.
            processed = FALSE;
        }
        break;
    }
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    if (processed && !requestCompleted)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchSpecialIoctls(Device, Request, RequestParameters);
        }
        else
        {
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSpecialIoctls().

RequestDispatchSyncWithSequentialQueue()

BOOLEAN RequestDispatchSyncWithSequentialQueue	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 2717 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_EXCLUSIVE_ACCESS:
    {
        //1. Validate
        status =  RequestValidateExclusiveAccess(Request, RequestParameters, &dataLength);
 
        //2. keep the request in serialized manner and stay in user's context.
        if (NT_SUCCESS(status))
        {
            PCDROM_EXCLUSIVE_ACCESS exclusiveAccess = NULL;
 
            status = WdfRequestRetrieveInputBuffer(Request,
                                                   RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                   &exclusiveAccess,
                                                   NULL);
 
            if (NT_SUCCESS(status))
            {
                // do not need to check "status" as it passed validation and cannot fail in WdfRequestRetrieveInputBuffer()
                switch (exclusiveAccess->RequestType)
                {
 
                    case ExclusiveAccessQueryState:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessQueryLockState);
                        break;
                    }
 
                    case ExclusiveAccessLockDevice:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessLockDevice);
                        break;
                    }
 
                    case ExclusiveAccessUnlockDevice:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessUnlockDevice);
                        break;
                    }
                    default:
                    {
                        // already valicated in RequestValidateExclusiveAccess()
                        NT_ASSERT(FALSE);
                        break;
                    }
                }
            }
 
            if (NT_SUCCESS(status))
            {
                // now, put the special synchronization information into the context
                status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
 
                // "status" is used for debugging in above statement, reset to success to avoid further work in this function.
                status = STATUS_SUCCESS;
            }
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    // Following process is only valid if the request is not really processed. (failed in validation)
    if (processed && !NT_SUCCESS(status))
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            //
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            //
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchSyncWithSequentialQueue(Device, Request, RequestParameters);
        }
        else
        {
            // Validation failed / forward failed, complete the request.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSyncWithSequentialQueue().

RequestDispatchToSequentialQueue()

BOOLEAN RequestDispatchToSequentialQueue	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 1855 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
    BOOLEAN                 inZeroPowerState = FALSE;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
    PZERO_POWER_ODD_INFO    zpoddInfo = deviceExtension->ZeroPowerODDInfo;
 
    if ((zpoddInfo != NULL) &&
        (zpoddInfo->InZeroPowerState != FALSE))
    {
        inZeroPowerState = TRUE;
    }
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_RAW_READ:
    {
        status = RequestValidateRawRead(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive geometryEx\n"));
        if ( RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
             (ULONG)FIELD_OFFSET(DISK_GEOMETRY_EX, Data))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = FIELD_OFFSET(DISK_GEOMETRY_EX, Data);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive geometry\n"));
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(DISK_GEOMETRY))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(DISK_GEOMETRY);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_TOC_EX:
    {
        status = RequestValidateReadTocEx(deviceExtension, Request, RequestParameters, &dataLength);
 
        if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_TOC:
    {
        status = RequestValidateReadToc(deviceExtension, RequestParameters, &dataLength);
 
        if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_LAST_SESSION:
    {
        status = RequestValidateGetLastSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_PLAY_AUDIO_MSF:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Play audio MSF\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_PLAY_AUDIO_MSF))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SEEK_AUDIO_MSF:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Seek audio MSF\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_SEEK_AUDIO_MSF))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_PAUSE_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Pause audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_RESUME_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Resume audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_Q_CHANNEL:
    {
        status = RequestValidateReadQChannel(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_VOLUME:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get volume control\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(VOLUME_CONTROL))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(VOLUME_CONTROL);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SET_VOLUME:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Set volume control\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(VOLUME_CONTROL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_STOP_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Stop audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_CHECK_VERIFY:
    case IOCTL_STORAGE_CHECK_VERIFY2:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] Check Verify\n", Request));
 
        // Following check will let the condition "OutputBufferLength == 0" pass.
        // Since it's legacy behavior in classpnp, we need to keep it.
        if ((RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > 0) &&
            (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(ULONG);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_GET_REGION:
    {
        // validation will be done when process it.
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_READ_STRUCTURE:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_READ_STRUCTURE\n", Request));
 
        status = RequestValidateDvdReadStructure(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_READ_KEY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_READ_KEY\n", Request));
 
        status = RequestValidateDvdReadKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_START_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_START_SESSION\n", Request));
 
        status = RequestValidateDvdStartSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_SEND_KEY:
    case IOCTL_DVD_SEND_KEY2:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_SEND_KEY\n", Request));
 
        status = RequestValidateDvdSendKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_SET_READ_AHEAD:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] SetReadAhead\n", Request));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(STORAGE_SET_READ_AHEAD))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_IS_WRITABLE:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_LAYOUT:
    {
        ULONG requiredSize = 0;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive layout\n"));
 
        requiredSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[1]);
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            requiredSize)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = requiredSize;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:
    {
        ULONG requiredSize = 0;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive layoutEx\n"));
 
        requiredSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[1]);
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            requiredSize)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = requiredSize;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_PARTITION_INFO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get Partition Info\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(PARTITION_INFORMATION))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(PARTITION_INFORMATION);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_PARTITION_INFO_EX:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get Partition InfoEx\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(PARTITION_INFORMATION_EX))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(PARTITION_INFORMATION_EX);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_VERIFY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: IOCTL_DISK_VERIFY to device %p through request %p\n",
                    Device,
                    Request));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(VERIFY_INFORMATION))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_LENGTH_INFO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Disk Get Length InfoEx\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(GET_LENGTH_INFORMATION))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(GET_LENGTH_INFORMATION);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_CONFIGURATION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_GET_CONFIGURATION\n", Request));
 
        status = RequestValidateGetConfiguration(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SET_SPEED:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_SET_SPEED\n", Request));
 
        status = RequestValidateSetSpeed(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_END_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_END_SESSION\n", Request));
 
        status = RequestValidateDvdEndSession(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_END_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_AACS_END_SESSION\n", Request));
 
        status = RequestValidateAacsEndSession(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_MEDIA_KEY_BLOCK:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying full MKB with bufferSize of %x bytes\n",
                    (int)RequestParameters.Parameters.DeviceIoControl.OutputBufferLength
                    ));
 
        status = RequestValidateAacsReadMediaKeyBlock(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_START_SESSION:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Requesting AGID\n"
                    ));
 
        status = RequestValidateAacsStartSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_SEND_CERTIFICATE:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Sending host certificate to drive\n"
                    ));
 
        status = RequestValidateAacsSendCertificate(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_GET_CERTIFICATE:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying drive certificate\n"
                    ));
 
        status = RequestValidateAacsGetCertificate(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_GET_CHALLENGE_KEY:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying drive challenge key\n"
                    ));
 
        status = RequestValidateAacsGetChallengeKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_SEND_CHALLENGE_KEY:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Sending drive challenge key\n"
                    ));
 
        status = RequestValidateAacsSendChallengeKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_VOLUME_ID:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading volume ID\n"
                    ));
 
        status = RequestValidateAacsReadVolumeId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_SERIAL_NUMBER:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading Serial Number\n"
                    ));
 
        status = RequestValidateAacsReadSerialNumber(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_MEDIA_ID:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading media ID\n"
                    ));
 
        status = RequestValidateAacsReadMediaId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_BINDING_NONCE:
    case IOCTL_AACS_GENERATE_BINDING_NONCE:
    {
        if (ioctlCode == IOCTL_AACS_GENERATE_BINDING_NONCE)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "AACS: Generating new binding nonce\n"
                        ));
        }
        else
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "AACS: Reading existing binding nonce\n"
                        ));
        }
 
        status = RequestValidateAacsBindingNonce(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_ENABLE_STREAMING:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_ENABLE_STREAMING\n", Request));
 
        status = RequestValidateEnableStreaming(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SEND_OPC_INFORMATION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_SEND_OPC_INFORMATION\n", Request));
 
        status = RequestValidateSendOpcInformation(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_PERFORMANCE:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_GET_PERFORMANCE\n", Request));
 
        status = RequestValidateGetPerformance(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_MEDIA_REMOVAL:
    case IOCTL_STORAGE_EJECTION_CONTROL:
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
           sizeof(PREVENT_MEDIA_REMOVAL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_MCN_CONTROL:
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(PREVENT_MEDIA_REMOVAL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_RESERVE:
    case IOCTL_STORAGE_RELEASE:
    {
        // there is no validate check currently.
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_PERSISTENT_RESERVE_IN:
    case IOCTL_STORAGE_PERSISTENT_RESERVE_OUT:
    {
        status = RequestValidatePersistentReserve(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_EJECT_MEDIA:
    case IOCTL_STORAGE_LOAD_MEDIA:
    case IOCTL_STORAGE_LOAD_MEDIA2:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_FIND_NEW_DEVICES:
    {
        // process it.
        IoInvalidateDeviceRelations(deviceExtension->LowerPdo, BusRelations);
 
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_READ_CAPACITY:
    {
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_READ_CAPACITY))
        {
            dataLength = sizeof(STORAGE_READ_CAPACITY);
            status = STATUS_BUFFER_TOO_SMALL;
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORT:
    {
        // for disk.sys only in original classpnp
        status = STATUS_NOT_SUPPORTED;
 
        processed = TRUE;
        break; // complete the irp
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    case IOCTL_DISK_ARE_VOLUMES_READY:
    {
        // this request doesn't access device at all, so seemingly it can be processed
        // directly; however, in case volume online is not received, we will need to
        // park these requests in a queue, and the only way a request can be queued is
        // if the request came out of another queue.
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_VOLUME_ONLINE:
    case IOCTL_VOLUME_POST_ONLINE:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
#endif
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    if (processed)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchToSequentialQueue(Device, Request, RequestParameters);
        }
        else
        {
            if (NT_SUCCESS(status))
            {
                // Forward the request to serialized queue.
                status = WdfDeviceEnqueueRequest(Device, Request);
            }
 
            if (!NT_SUCCESS(status))
            {
                // Validation failed / forward failed, complete the request.
                RequestCompletion(deviceExtension, Request, status, dataLength);
            }
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchToSequentialQueue().

RequestDispatchUnknownRequests()

BOOLEAN RequestDispatchUnknownRequests	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 3093 of file cdrom.c.

{
    NTSTATUS                status = STATUS_UNSUCCESSFUL;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
 
    ULONG       baseCode = DEVICE_TYPE_FROM_CTL_CODE(RequestParameters.Parameters.DeviceIoControl.IoControlCode);
 
    if ((KeGetCurrentIrql() != PASSIVE_LEVEL) ||
        (baseCode == FILE_DEVICE_ACPI))
    {
        // 1. When IRQL is higher than PASSIVE_LEVEL,
        // 2. ataport sends IOCTL_ACPI_ASYNC_EVAL_METHOD before queue starts,
        // send request directly to lower driver.
        status = RequestHandleUnknownIoctl(Device, Request);
    }
    else
    {
        // keep the request in serialized manner and stay in user's context.
        status = RequestSetContextFields(Request, RequestHandleUnknownIoctl);
 
        if (NT_SUCCESS(status))
        {
            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
        }
        else
        {
            RequestCompletion(deviceExtension, Request, status, 0);
        }
    }
 
    UNREFERENCED_PARAMETER(status); //defensive coding, avoid PREFAST warning.
 
    // All unknown IOCTLs are processed in this function.
    return TRUE; //processed
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSpecialIoctls().

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 = 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().

RequestHandleUnknownIoctl()

NTSTATUS RequestHandleUnknownIoctl	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request
	)

Referenced by RequestDispatchUnknownRequests().

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().

Variable Documentation

DataLength

_Out_ size_t* DataLength

Definition at line 139 of file ioctl.h.

Request

_In_ WDFREQUEST Request

Definition at line 137 of file ioctl.h.

RequestParameters

_In_ WDFREQUEST _In_ WDF_REQUEST_PARAMETERS RequestParameters

Definition at line 138 of file ioctl.h.

Referenced by _IRQL_requires_max_(), RequestDispatchProcessDirectly(), RequestDispatchSpecialIoctls(), RequestDispatchSyncWithSequentialQueue(), RequestDispatchToSequentialQueue(), RequestDispatchUnknownRequests(), RequestDuidGetDeviceIdProperty(), RequestDuidGetDeviceProperty(), RequestHandleGetDeviceNumber(), RequestHandleGetHotPlugInfo(), RequestHandleGetInquiryData(), RequestHandleMountQueryDeviceName(), RequestHandleMountQuerySuggestedLinkName(), RequestHandleMountQueryUniqueId(), RequestHandleQueryPropertyRetrieveCachedData(), RequestHandleReadWrite(), RequestHandleSetHotPlugInfo(), RequestValidateAacsBindingNonce(), RequestValidateAacsEndSession(), RequestValidateAacsGetCertificate(), RequestValidateAacsGetChallengeKey(), RequestValidateAacsReadMediaId(), RequestValidateAacsReadMediaKeyBlock(), RequestValidateAacsReadSerialNumber(), RequestValidateAacsReadVolumeId(), RequestValidateAacsSendCertificate(), RequestValidateAacsSendChallengeKey(), RequestValidateAacsStartSession(), RequestValidateDvdEndSession(), RequestValidateDvdReadKey(), RequestValidateDvdReadStructure(), RequestValidateDvdSendKey(), RequestValidateDvdStartSession(), RequestValidateEnableStreaming(), RequestValidateExclusiveAccess(), RequestValidateGetConfiguration(), RequestValidateGetLastSession(), RequestValidateGetPerformance(), RequestValidatePersistentReserve(), RequestValidateRawRead(), RequestValidateReadQChannel(), RequestValidateReadToc(), RequestValidateReadTocEx(), RequestValidateReadWrite(), RequestValidateSendOpcInformation(), and RequestValidateSetSpeed().