reactos/modules/rosapps/drivers/vcdrom/vcdrom.c

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         ReactOS FS utility tool
 * FILE:            modules/rosapps/drivers/vcdrom/vcdrom.c
 * PURPOSE:         Virtual CD-ROM class driver
 * PROGRAMMERS:     Pierre Schweitzer <pierre@reactos.org>
 */

#include <ntddk.h>
#include <ntifs.h>
#include <ntdddisk.h>
#include <ntddcdrm.h>
#include <pseh/pseh2.h>

#define NDEBUG
#include <debug.h>

#include "vcdioctl.h"

typedef struct _DEVICE_EXTENSION
{
    PDEVICE_OBJECT DeviceObject;
    /* File object to the ISO when opened */
    PFILE_OBJECT VolumeObject;
    /* Size of the ISO */
    LARGE_INTEGER VolumeSize;
    /* Mandatory change count for verify */
    ULONG ChangeCount;
    /* Will contain the device name or the drive letter */
    UNICODE_STRING GlobalName;
    /* Will contain the image path */
    UNICODE_STRING ImageName;
    /* Flags on mount (supp. of UDF/Joliet) */
    ULONG Flags;
    /* Faking CD structure */
    ULONG SectorSize;
    ULONG SectorShift;
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

/* Taken from CDFS */
#define TOC_DATA_TRACK 0x04
#define TOC_LAST_TRACK 0xaa

/* Should cover most of our usages */
#define DEFAULT_STRING_SIZE 50

/* Increment on device creation, protection by the mutex */
FAST_MUTEX ViMutex;
ULONG ViDevicesCount;

VOID
ViInitializeDeviceExtension(PDEVICE_OBJECT DeviceObject)
{
    PDEVICE_EXTENSION DeviceExtension;

    DeviceExtension = DeviceObject->DeviceExtension;

    /* Zero mandatory fields, the rest will be zeroed when needed */
    DeviceExtension->DeviceObject = DeviceObject;
    DeviceExtension->VolumeObject = NULL;
    DeviceExtension->ChangeCount = 0;
    DeviceExtension->GlobalName.Buffer = NULL;
    DeviceExtension->GlobalName.MaximumLength = 0;
    DeviceExtension->GlobalName.Length = 0;
    DeviceExtension->ImageName.Buffer = NULL;
    DeviceExtension->ImageName.MaximumLength = 0;
    DeviceExtension->ImageName.Length = 0;
}

NTSTATUS
ViAllocateUnicodeString(USHORT BufferLength, PUNICODE_STRING UnicodeString)
{
    PVOID Buffer;

    /* Allocate the buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPool, BufferLength, ' dCV');
    /* Initialize */
    UnicodeString->Length = 0;
    UnicodeString->MaximumLength = BufferLength;
    UnicodeString->Buffer = Buffer;

    /* Return success if it went fine */
    if (Buffer != NULL)
    {
        return STATUS_SUCCESS;
    }

    return STATUS_NO_MEMORY;
}

VOID
ViFreeUnicodeString(PUNICODE_STRING UnicodeString)
{
    /* Only free if allocate, that allows using this
     * on cleanup in short memory situations
     */
    if (UnicodeString->Buffer != NULL)
    {
        ExFreePoolWithTag(UnicodeString->Buffer, 0);
        UnicodeString->Buffer = NULL;
    }

    /* Zero the rest */
    UnicodeString->Length = 0;
    UnicodeString->MaximumLength = 0;
}

NTSTATUS
ViSetIoStatus(NTSTATUS Status, ULONG_PTR Information, PIRP Irp)
{
    /* Only set what we got */
    Irp->IoStatus.Information = Information;
    Irp->IoStatus.Status = Status;

    /* And return the status, so that caller can return with us */
    return Status;
}

NTSTATUS
NTAPI
VcdHandle(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    /* Stub for CREATE, CLEANUP, CLOSE, always a succes */
    ViSetIoStatus(STATUS_SUCCESS, 0, Irp);
    IoCompleteRequest(Irp, IO_DISK_INCREMENT);

    return STATUS_SUCCESS;
}

NTSTATUS
ViDeleteDevice(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS Status;
    PDEVICE_EXTENSION DeviceExtension;

    DeviceExtension = DeviceObject->DeviceExtension;

    /* Delete the drive letter */
    Status = IoDeleteSymbolicLink(&DeviceExtension->GlobalName);
    ViFreeUnicodeString(&DeviceExtension->GlobalName);

    /* Close the ISO */
    if (DeviceExtension->VolumeObject != NULL)
    {
        ObDereferenceObject(DeviceExtension->VolumeObject);
        DeviceExtension->VolumeObject = NULL;
    }

    /* Free the ISO name */
    ViFreeUnicodeString(&DeviceExtension->ImageName);

    /* And delete the device */
    IoDeleteDevice(DeviceObject);
    return ViSetIoStatus(Status, 0, Irp);
}

VOID
NTAPI
VcdUnload(PDRIVER_OBJECT DriverObject)
{
    IRP FakeIrp;
    PDEVICE_OBJECT DeviceObject;

    /* No device, nothing to free */
    DeviceObject = DriverObject->DeviceObject;
    if (DeviceObject == NULL)
    {
        return;
    }

    /* Delete any device we could have created */
    do
    {
        PDEVICE_OBJECT NextDevice;

        NextDevice = DeviceObject->NextDevice;
        /* This is normally called on IoCtl, so fake
         * the IRP so that status can be dummily set
         */
        ViDeleteDevice(DeviceObject, &FakeIrp);
        DeviceObject = NextDevice;
    } while (DeviceObject != NULL);
}

NTSTATUS
ViCreateDriveLetter(PDRIVER_OBJECT DriverObject, WCHAR Letter, WCHAR *EffectiveLetter, PDEVICE_OBJECT *DeviceObject)
{
    NTSTATUS Status;
    HANDLE LinkHandle;
    WCHAR DriveLetter[3], CurLetter;
    PDEVICE_OBJECT LocalDeviceObject;
    PDEVICE_EXTENSION DeviceExtension;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING DeviceCount, DeviceName;

    *DeviceObject = NULL;

    /* Allocate our buffers */
    ViAllocateUnicodeString(DEFAULT_STRING_SIZE, &DeviceCount);
    ViAllocateUnicodeString(DEFAULT_STRING_SIZE, &DeviceName);

    /* For easier cleanup */
    _SEH2_TRY
    {
        /* Get our device number */
        ExAcquireFastMutex(&ViMutex);
        Status = RtlIntegerToUnicodeString(ViDevicesCount, 10, &DeviceCount);
        ++ViDevicesCount;
        ExReleaseFastMutex(&ViMutex);

        /* Conversion to string failed, bail out */
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }

        /* Create our device name */
        Status = RtlAppendUnicodeToString(&DeviceName, L"\\Device\\VirtualCdRom");
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }

        Status = RtlAppendUnicodeStringToString(&DeviceName, &DeviceCount);
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }

        /* And create the device! */
        Status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION), &DeviceName,
                                FILE_DEVICE_CD_ROM,
                                FILE_READ_ONLY_DEVICE | FILE_FLOPPY_DISKETTE,
                                FALSE, &LocalDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            _SEH2_LEAVE;
        }

        /* Initialize our DE */
        ViInitializeDeviceExtension(LocalDeviceObject);
        DeviceExtension = LocalDeviceObject->DeviceExtension;
        ViAllocateUnicodeString(DEFAULT_STRING_SIZE, &DeviceExtension->GlobalName);

        /* Now, we'll try to find a free drive letter
         * We always start from Z and go backward
         */
        for (CurLetter = Letter; CurLetter >= 'A'; CurLetter--)
        {
            /* By default, no flags. These will be set
             * on mount, by the caller
             */
            DeviceExtension->Flags = 0;

            /* Create a drive letter name */
            DeviceExtension->GlobalName.Length = 0;
            Status = RtlAppendUnicodeToString(&DeviceExtension->GlobalName, L"\\??\\");
            if (!NT_SUCCESS(Status))
            {
                _SEH2_LEAVE;
            }

            DriveLetter[0] = CurLetter;
            DriveLetter[1] = L':';
            DriveLetter[2] = UNICODE_NULL;
            Status = RtlAppendUnicodeToString(&DeviceExtension->GlobalName, DriveLetter);
            if (!NT_SUCCESS(Status))
            {
                _SEH2_LEAVE;
            }

            /* And try to open it */
            InitializeObjectAttributes(&ObjectAttributes, &DeviceExtension->GlobalName, OBJ_CASE_INSENSITIVE | OBJ_PERMANENT, NULL, NULL);
            Status = ZwOpenSymbolicLinkObject(&LinkHandle, GENERIC_READ, &ObjectAttributes);
            /* It failed; good news, that letter is free, jump on it! */
            if (!NT_SUCCESS(Status))
            {
                /* Create a symbolic link to our device */
                Status = IoCreateSymbolicLink(&DeviceExtension->GlobalName, &DeviceName);
                /* If created... */
                if (NT_SUCCESS(Status))
                {
                    /* Return the drive letter to the caller */
                    *EffectiveLetter = CurLetter;
                    ClearFlag(LocalDeviceObject->Flags, DO_DEVICE_INITIALIZING);
                    /* No caching! */
                    SetFlag(LocalDeviceObject->Flags, DO_DIRECT_IO);

                    /* And return the DO */
                    *DeviceObject = LocalDeviceObject;
                    break;
                }
            }
            /* This letter is taken, try another one */
            else
            {
                ZwClose(LinkHandle);
                Status = STATUS_OBJECT_NAME_EXISTS;
            }
        }

        /* We're out of drive letters, so fail :-( */
        if (CurLetter == (L'A' - 1))
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    _SEH2_FINALLY
    {
        /* No longer need these */
        ViFreeUnicodeString(&DeviceName);
        ViFreeUnicodeString(&DeviceCount);

        /* And delete in case of a failure */
        if (!NT_SUCCESS(Status) && Status != STATUS_VERIFY_REQUIRED && LocalDeviceObject != NULL)
        {
            IoDeleteDevice(LocalDeviceObject);
        }
    }
    _SEH2_END;

    return Status;
}

NTSTATUS
ViMountImage(PDEVICE_OBJECT DeviceObject, PUNICODE_STRING Image)
{
    NTSTATUS Status;
    HANDLE ImgHandle;
    IO_STATUS_BLOCK IoStatus;
    ULONG Buffer[2], i, SectorShift;
    PDEVICE_EXTENSION DeviceExtension;
    OBJECT_ATTRIBUTES ObjectAttributes;
    FILE_STANDARD_INFORMATION FileStdInfo;

    /* Try to open the image */
    InitializeObjectAttributes(&ObjectAttributes, Image, OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = ZwCreateFile(&ImgHandle, FILE_READ_DATA | SYNCHRONIZE, &ObjectAttributes,
                          &IoStatus, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
                          FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open image: %wZ\n", Image);
        return Status;
    }

    /* Query its information */
    Status = ZwQueryInformationFile(ImgHandle, &IoStatus, &FileStdInfo,
                                    sizeof(FileStdInfo), FileStandardInformation);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to query image information\n");
        ZwClose(ImgHandle);
        return Status;
    }

    /* Set image size */
    DeviceExtension = DeviceObject->DeviceExtension;
    DeviceExtension->VolumeSize.QuadPart = FileStdInfo.EndOfFile.QuadPart;

    /* Read the first 8-bytes to determine our sector size */
    Status = ZwReadFile(ImgHandle, NULL, NULL, NULL, &IoStatus, Buffer, sizeof(Buffer), NULL, NULL);
    if (!NT_SUCCESS(Status) || Buffer[1] == 0 || (Buffer[1] & 0x1FF) != 0)
    {
        DeviceExtension->SectorSize = 2048;
    }
    else
    {
        DeviceExtension->SectorSize = Buffer[1];
    }

    /* Now, compute the sector shift */
    if (DeviceExtension->SectorSize == 512)
    {
        DeviceExtension->SectorShift = 9;
    }
    else
    {
        for (i = 512, SectorShift = 9; i < DeviceExtension->SectorSize; i = i * 2, ++SectorShift);
        if (i == DeviceExtension->SectorSize)
        {
            DeviceExtension->SectorShift = SectorShift;
        }
        else
        {
            DeviceExtension->SectorShift = 11;
        }
    }

    /* We're good, get the image file object to close the handle */
    Status = ObReferenceObjectByHandle(ImgHandle, 0, NULL, KernelMode,
                                       (PVOID *)&DeviceExtension->VolumeObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        ZwClose(ImgHandle);
        DeviceExtension->VolumeObject = NULL;
        return Status;
    }

    ZwClose(ImgHandle);
    /* Increase change count to force a verify */
    ++DeviceExtension->ChangeCount;

    /* And ask for a verify! */
    SetFlag(DeviceObject->Flags, DO_VERIFY_VOLUME);

    /* Free old string (if any) */
    ViFreeUnicodeString(&DeviceExtension->ImageName);
    /* And save our new image name */
    ViAllocateUnicodeString(Image->MaximumLength, &DeviceExtension->ImageName);
    RtlCopyUnicodeString(&DeviceExtension->ImageName, Image);

    return STATUS_SUCCESS;
}

VOID
ViCreateDriveAndMountImage(PDRIVER_OBJECT DriverObject, WCHAR Letter, LPCWSTR ImagePath)
{
    UNICODE_STRING Image;
    WCHAR EffectiveLetter;
    PDEVICE_OBJECT DeviceObject;

    /* Create string from path */
    DeviceObject = NULL;
    RtlInitUnicodeString(&Image, ImagePath);

    /* Create the drive letter (ignore output, it comes from registry, nothing to do */
    ViCreateDriveLetter(DriverObject, Letter, &EffectiveLetter, &DeviceObject);
    /* And mount the image on the created drive */
    ViMountImage(DeviceObject, &Image);
}

VOID
ViLoadImagesFromRegistry(PDRIVER_OBJECT DriverObject, LPCWSTR RegistryPath)
{
    WCHAR Letter[2];
    WCHAR PathBuffer[100], ResBuffer[100];

    /* We'll browse the registry for
     * DeviceX\IMAGE = {Path}
     * When found, we create (or at least, attempt to)
     * device X: and mount image Path
     */
    Letter[0] = L'A';
    Letter[1] = UNICODE_NULL;
    do
    {
        NTSTATUS Status;
        UNICODE_STRING Path, ResString;
        RTL_QUERY_REGISTRY_TABLE QueryTable[3];

        /* Our path is always Device + drive letter */
        RtlZeroMemory(PathBuffer, sizeof(PathBuffer));
        Path.Buffer = PathBuffer;
        Path.Length = 0;
        Path.MaximumLength = sizeof(PathBuffer);
        RtlAppendUnicodeToString(&Path, L"Parameters\\Device");
        RtlAppendUnicodeToString(&Path, Letter);

        ResString.Buffer = ResBuffer;
        ResString.Length = 0;
        ResString.MaximumLength = sizeof(ResBuffer);

        RtlZeroMemory(&QueryTable[0], sizeof(QueryTable));
        QueryTable[0].Name = Path.Buffer;
        QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
        QueryTable[1].Name = L"IMAGE";
        QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
        QueryTable[1].EntryContext = &ResString;

        /* If query went fine, attempt to create and mount */
        Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE, RegistryPath, QueryTable, NULL, NULL);
        if (NT_SUCCESS(Status))
        {
            ViCreateDriveAndMountImage(DriverObject, Letter[0], ResString.Buffer);
        }

        ++(Letter[0]);
    } while (Letter[0] <= L'Z');
}

NTSTATUS
ViVerifyVolume(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    /* Force verify */
    SetFlag(DeviceObject->Flags, DO_VERIFY_VOLUME);

    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;

    IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);

    return STATUS_VERIFY_REQUIRED;
}

NTSTATUS
ViReadFile(PFILE_OBJECT File, PMDL Mdl, PLARGE_INTEGER Offset, PKEVENT Event, ULONG Length, PIO_STATUS_BLOCK IoStatusBlock)
{
    PIRP LowerIrp;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;

    /* Get the lower DO */
    DeviceObject = IoGetRelatedDeviceObject(File);
    /* Allocate an IRP to deal with it */
    LowerIrp = IoAllocateIrp(DeviceObject->StackSize, 0);
    if (LowerIrp == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    /* Initialize it */
    LowerIrp->RequestorMode = KernelMode;
    /* Our status block */
    LowerIrp->UserIosb = IoStatusBlock;
    LowerIrp->MdlAddress = Mdl;
    /* We don't cache! */
    LowerIrp->Flags = IRP_NOCACHE | IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO;
    /* Sync event for us to know when read is done */
    LowerIrp->UserEvent = Event;
    LowerIrp->UserBuffer = (PVOID)((ULONG_PTR)Mdl->StartVa + Mdl->ByteOffset);
    /* The FO of our image */
    LowerIrp->Tail.Overlay.OriginalFileObject = File;
    LowerIrp->Tail.Overlay.Thread = PsGetCurrentThread();

    /* We basically perform a read operation, nothing complex here */
    Stack = IoGetNextIrpStackLocation(LowerIrp);
    Stack->Parameters.Read.Length = Length;
    Stack->MajorFunction = IRP_MJ_READ;
    Stack->FileObject = File;
    Stack->Parameters.Read.ByteOffset.QuadPart = Offset->QuadPart;

    /* And call lower driver */
    return IoCallDriver(DeviceObject, LowerIrp);
}

NTSTATUS
NTAPI
VcdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    KEVENT Event;
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;
    PDEVICE_EXTENSION DeviceExtension;

    /* Catch any exception that could happen during read attempt */
    _SEH2_TRY
    {
        /* First of all, check if there's an image mounted */
        DeviceExtension = DeviceObject->DeviceExtension;
        if (DeviceExtension->VolumeObject == NULL)
        {
            Status = ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
            _SEH2_LEAVE;
        }

        /* Check if volume has to be verified (or if we override, for instance
         * FSD performing initial reads for mouting FS)
         */
        Stack = IoGetCurrentIrpStackLocation(Irp);
        if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
            !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
        {
            Status = ViVerifyVolume(DeviceObject, Irp);
            _SEH2_LEAVE;
        }

        /* Check if we have enough room for output */
        if (Stack->Parameters.Read.Length > Irp->MdlAddress->ByteCount)
        {
            Status = ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, 0, Irp);
            _SEH2_LEAVE;
        }

        /* Initialize our event */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);

        /* Perform actual read */
        Status = ViReadFile(DeviceExtension->VolumeObject, Irp->MdlAddress,
                            &Stack->Parameters.Read.ByteOffset, &Event,
                            Stack->Parameters.Read.Length, &IoStatus);
        if (!NT_SUCCESS(Status))
        {
            Status = ViSetIoStatus(Status, 0, Irp);
            _SEH2_LEAVE;
        }

        /* Make sure we wait until its done */
        Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        if (!NT_SUCCESS(Status))
        {
            Status = ViSetIoStatus(Status, 0, Irp);
            _SEH2_LEAVE;
        }

        /* Look whether we're reading first bytes of the volume, if so, our
         * "suppression" might be asked for
         */
        if (Stack->Parameters.Read.ByteOffset.QuadPart / DeviceExtension->SectorSize < 0x20)
        {
            /* Check our output buffer is in a state where we can play with it */
            if ((Irp->MdlAddress->MdlFlags & (MDL_ALLOCATED_FIXED_SIZE | MDL_PAGES_LOCKED | MDL_MAPPED_TO_SYSTEM_VA)) ==
                (MDL_ALLOCATED_FIXED_SIZE | MDL_PAGES_LOCKED | MDL_MAPPED_TO_SYSTEM_VA))
            {
                PUCHAR Buffer;

                /* Do we have to delete any UDF mark? */
                if (BooleanFlagOn(DeviceExtension->Flags, MOUNT_FLAG_SUPP_UDF))
                {
                    /* Kill any NSR0X mark from UDF */
                    Buffer = (PUCHAR)((ULONG_PTR)Irp->MdlAddress->StartVa + Irp->MdlAddress->ByteOffset);
                    if (Buffer != NULL)
                    {
                        if (Buffer[0] == 0 && Buffer[1] == 'N' && Buffer[2] == 'S' &&
                            Buffer[3] == 'R' && Buffer[4] == '0')
                        {
                            Buffer[5] = '0';
                        }
                    }
                }

                /* Do we have to delete any Joliet mark? */
                if (BooleanFlagOn(DeviceExtension->Flags, MOUNT_FLAG_SUPP_JOLIET))
                {
                    /* Kill the CD001 mark from Joliet */
                    Buffer = (PUCHAR)((ULONG_PTR)Irp->MdlAddress->StartVa + Irp->MdlAddress->ByteOffset);
                    if (Buffer != NULL)
                    {
                        if (Buffer[0] == 2 && Buffer[1] == 'C' && Buffer[2] == 'D' &&
                            Buffer[3] == '0' && Buffer[4] == '0' && Buffer[5] == '1')
                        {
                            Buffer[5] = '0';
                        }
                    }
                }
            }
        }

        /* Set status */
        Status = ViSetIoStatus(Status, Stack->Parameters.Read.Length, Irp);
    }
    _SEH2_FINALLY
    {
        /* And complete! */
        IoCompleteRequest(Irp, IO_DISK_INCREMENT);
    } _SEH2_END;

    return Status;
}

NTSTATUS
ViCreateDevice(PDRIVER_OBJECT DriverObject, PIRP Irp)
{
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;

    Stack = IoGetCurrentIrpStackLocation(Irp);

    /* Make sure output buffer is big enough to receive the drive letter
     * when we create the drive
     */
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(WCHAR))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(WCHAR), Irp);
    }

    /* And start creation. We always start from bottom */
    Status = ViCreateDriveLetter(DriverObject, L'Z', Irp->AssociatedIrp.SystemBuffer, &DeviceObject);
    return ViSetIoStatus(Status, sizeof(WCHAR), Irp);
}

NTSTATUS
ViGetDriveGeometry(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PDISK_GEOMETRY DiskGeo;
    PIO_STACK_LOCATION Stack;
    PDEVICE_EXTENSION DeviceExtension;

    /* No geometry if no image mounted */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject == NULL)
    {
        return ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
    }

    /* No geometry if volume is to be verified */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        return ViVerifyVolume(DeviceObject, Irp);
    }

    /* No geometry if too small output buffer */
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DISK_GEOMETRY))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(DISK_GEOMETRY), Irp);
    }

    /* Finally, set what we're asked for */
    DiskGeo = Irp->AssociatedIrp.SystemBuffer;
    DiskGeo->MediaType = RemovableMedia;
    DiskGeo->BytesPerSector = DeviceExtension->SectorSize;
    DiskGeo->SectorsPerTrack = DeviceExtension->VolumeSize.QuadPart >> DeviceExtension->SectorShift;
    DiskGeo->Cylinders.QuadPart = 1;
    DiskGeo->TracksPerCylinder = 1;

    return ViSetIoStatus(STATUS_SUCCESS, sizeof(DISK_GEOMETRY), Irp);
}

NTSTATUS
ViCheckVerify(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PULONG Buffer;
    ULONG_PTR Information;
    PIO_STACK_LOCATION Stack;
    PDEVICE_EXTENSION DeviceExtension;

    /* Nothing to verify if no mounted */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject == NULL)
    {
        return ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
    }

    /* Do we have to verify? */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        return ViSetIoStatus(STATUS_VERIFY_REQUIRED, 0, Irp);
    }

    /* If caller provided a buffer, that's to get the change count */
    Buffer = Irp->AssociatedIrp.SystemBuffer;
    if (Buffer != NULL)
    {
        *Buffer = DeviceExtension->ChangeCount;
        Information = sizeof(ULONG);
    }
    else
    {
        Information = 0;
    }

    /* Done */
    return ViSetIoStatus(STATUS_SUCCESS, Information, Irp);
}

NTSTATUS
ViIssueMountImage(PDEVICE_OBJECT DeviceObject, PUNICODE_STRING Image, PIRP Irp)
{
    NTSTATUS Status;
    PDEVICE_EXTENSION DeviceExtension;

    /* We cannot mount an image if there's already one mounted */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject != NULL)
    {
        return ViSetIoStatus(STATUS_DEVICE_NOT_READY, 0, Irp);
    }

    /* Perform the mount */
    Status = ViMountImage(DeviceObject, Image);
    return ViSetIoStatus(Status, 0, Irp);
}

ULONG
ViComputeAddress(ULONG Address)
{
    UCHAR Local[4];

    /* Convert LBA to MSF */
    Local[0] = 0;
    Local[1] = Address / 4500;
    Local[2] = Address % 4500 / 75;
    Local[3] = Address + 108 * Local[1] - 75 * Local[2];

    return *(ULONG *)(&Local[0]);
}

VOID
ViFillInTrackData(PTRACK_DATA TrackData, UCHAR Control, UCHAR Adr, UCHAR TrackNumber, ULONG Address)
{
    /* Fill in our track data with provided information */
    TrackData->Reserved = 0;
    TrackData->Reserved1 = 0;
    TrackData->Control = Control & 0xF;
    TrackData->Adr = Adr;
    TrackData->TrackNumber = TrackNumber;
    *(ULONG *)(&TrackData->Address[0]) = ViComputeAddress(Address);
}

NTSTATUS
ViReadToc(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PCDROM_TOC Toc;
    PIO_STACK_LOCATION Stack;
    PDEVICE_EXTENSION DeviceExtension;

    /* No image mounted, no TOC */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject == NULL)
    {
        return ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
    }

    /* No TOC if we have to verify */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        return ViVerifyVolume(DeviceObject, Irp);
    }

    /* Check we have enough room for TOC */
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(CDROM_TOC))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(CDROM_TOC), Irp);
    }

    /* Start filling the TOC */
    Toc = Irp->AssociatedIrp.SystemBuffer;
    Toc->Length[0] = 0;
    Toc->Length[1] = 8;
    Toc->FirstTrack = 1;
    Toc->LastTrack = 1;
    /* And fill our single (an ISO file always have a single track) track with 2sec gap */
    ViFillInTrackData(Toc->TrackData, TOC_DATA_TRACK, ADR_NO_MODE_INFORMATION, 1, 150);
    /* And add last track termination */
    ViFillInTrackData(&Toc->TrackData[1], TOC_DATA_TRACK, ADR_NO_MODE_INFORMATION, TOC_LAST_TRACK, (DeviceExtension->VolumeSize.QuadPart >> DeviceExtension->SectorShift) + 150);

    return ViSetIoStatus(STATUS_SUCCESS, sizeof(CDROM_TOC), Irp);
}

NTSTATUS
ViReadTocEx(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PCDROM_TOC Toc;
    PIO_STACK_LOCATION Stack;
    PCDROM_READ_TOC_EX TocEx;
    PDEVICE_EXTENSION DeviceExtension;

    /* No image mounted, no TOC */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject == NULL)
    {
        return ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
    }

    /* No TOC if we have to verify */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        return ViVerifyVolume(DeviceObject, Irp);
    }

    /* We need an input buffer */
    if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(CDROM_READ_TOC_EX))
    {
        return ViSetIoStatus(STATUS_INFO_LENGTH_MISMATCH, sizeof(CDROM_READ_TOC_EX), Irp);
    }

    /* Validate output buffer is big enough */
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < MAXIMUM_CDROM_SIZE)
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, MAXIMUM_CDROM_SIZE, Irp);
    }

    /* Validate the input buffer - see cdrom_new */
    TocEx = Irp->AssociatedIrp.SystemBuffer;
    if ((TocEx->Reserved1 != 0) || (TocEx->Reserved2 != 0) ||
        (TocEx->Reserved3 != 0))
    {
        return ViSetIoStatus(STATUS_INVALID_PARAMETER, 0, Irp);
    }

    if (((TocEx->Format == CDROM_READ_TOC_EX_FORMAT_SESSION) ||
         (TocEx->Format == CDROM_READ_TOC_EX_FORMAT_PMA) ||
         (TocEx->Format == CDROM_READ_TOC_EX_FORMAT_ATIP)) &&
        TocEx->SessionTrack != 0)
    {
        return ViSetIoStatus(STATUS_INVALID_PARAMETER, 0, Irp);
    }

    if ((TocEx->Format != CDROM_READ_TOC_EX_FORMAT_TOC) &&
        (TocEx->Format != CDROM_READ_TOC_EX_FORMAT_FULL_TOC) &&
        (TocEx->Format != CDROM_READ_TOC_EX_FORMAT_CDTEXT) &&
        (TocEx->Format != CDROM_READ_TOC_EX_FORMAT_SESSION) &&
        (TocEx->Format != CDROM_READ_TOC_EX_FORMAT_PMA) &&
        (TocEx->Format == CDROM_READ_TOC_EX_FORMAT_ATIP))
    {
        return ViSetIoStatus(STATUS_INVALID_PARAMETER, 0, Irp);
    }

    /* Start filling the TOC */
    Toc = Irp->AssociatedIrp.SystemBuffer;
    Toc->Length[0] = 0;
    Toc->Length[1] = 8;
    Toc->FirstTrack = 1;
    Toc->LastTrack = 1;
    /* And fill our single (an ISO file always have a single track) track with 2sec gap */
    ViFillInTrackData(Toc->TrackData, TOC_DATA_TRACK, ADR_NO_MODE_INFORMATION, 1, 150);
    /* And add last track termination */
    ViFillInTrackData(&Toc->TrackData[1], TOC_DATA_TRACK, ADR_NO_MODE_INFORMATION, TOC_LAST_TRACK, (DeviceExtension->VolumeSize.QuadPart >> DeviceExtension->SectorShift) + 150);

    return ViSetIoStatus(STATUS_SUCCESS, MAXIMUM_CDROM_SIZE, Irp);
}

NTSTATUS
ViGetLastSession(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{

    PIO_STACK_LOCATION Stack;
    PCDROM_TOC_SESSION_DATA Toc;
    PDEVICE_EXTENSION DeviceExtension;

    /* No image, no last session */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject == NULL)
    {
        return ViSetIoStatus(STATUS_NO_MEDIA_IN_DEVICE, 0, Irp);
    }

    /* No last session if we have to verify */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (BooleanFlagOn(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        !BooleanFlagOn(Stack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        return ViVerifyVolume(DeviceObject, Irp);
    }

    /* Check we have enough room for last session data */
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(CDROM_TOC_SESSION_DATA))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(CDROM_TOC_SESSION_DATA), Irp);
    }

    /* Fill in data */
    Toc = Irp->AssociatedIrp.SystemBuffer;
    Toc->Length[0] = 0;
    Toc->Length[1] = 8;
    Toc->FirstCompleteSession = 1;
    Toc->LastCompleteSession = 1;
    /* And return our track with 2sec gap (cf TOC function) */
    ViFillInTrackData(Toc->TrackData, TOC_DATA_TRACK, ADR_NO_MODE_INFORMATION, 1, 150);

    return ViSetIoStatus(STATUS_SUCCESS, sizeof(CDROM_TOC_SESSION_DATA), Irp);
}

NTSTATUS
ViEnumerateDrives(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PDRIVES_LIST DrivesList;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT CurrentDO;
    PDEVICE_EXTENSION DeviceExtension;

    /* Check we have enough room for output */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DRIVES_LIST))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(DRIVES_LIST), Irp);
    }

    /* Get the output buffer */
    DrivesList = Irp->AssociatedIrp.SystemBuffer;
    DrivesList->Count = 0;

    /* And now, starting from our main DO, start browsing all the DO we created */
    for (CurrentDO = DeviceObject->DriverObject->DeviceObject; CurrentDO != NULL;
         CurrentDO = CurrentDO->NextDevice)
    {
        /* Check we won't output our main DO */
        DeviceExtension = CurrentDO->DeviceExtension;
        if (DeviceExtension->GlobalName.Length !=
            RtlCompareMemory(DeviceExtension->GlobalName.Buffer,
                             L"\\??\\VirtualCdRom",
                             DeviceExtension->GlobalName.Length))
        {
            /* When we return, we extract the drive letter
             * See ViCreateDriveLetter(), it's \??\Z:
             */
            DrivesList->Drives[DrivesList->Count++] = DeviceExtension->GlobalName.Buffer[4];
        }
    }

    return ViSetIoStatus(STATUS_SUCCESS, sizeof(DRIVES_LIST), Irp);
}

NTSTATUS
ViGetImagePath(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PIMAGE_PATH ImagePath;
    PIO_STACK_LOCATION Stack;
    PDEVICE_EXTENSION DeviceExtension;

    /* Check we have enough room for output */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(IMAGE_PATH))
    {
        return ViSetIoStatus(STATUS_BUFFER_TOO_SMALL, sizeof(IMAGE_PATH), Irp);
    }

    /* Get our image path from DO */
    DeviceExtension = DeviceObject->DeviceExtension;
    ImagePath = Irp->AssociatedIrp.SystemBuffer;
    ImagePath->Mounted = (DeviceExtension->VolumeObject != NULL);
    ImagePath->Length = DeviceExtension->ImageName.Length;
    /* And if it's set, copy it back to the caller */
    if (DeviceExtension->ImageName.Length != 0)
    {
        RtlCopyMemory(ImagePath->Path, DeviceExtension->ImageName.Buffer, DeviceExtension->ImageName.Length);
    }

    return ViSetIoStatus(STATUS_SUCCESS, sizeof(IMAGE_PATH), Irp);
}

NTSTATUS
ViEjectMedia(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PDEVICE_EXTENSION DeviceExtension;

    /* Eject will force a verify */
    SetFlag(DeviceObject->Flags, DO_VERIFY_VOLUME);

    /* If we have an image mounted, unmount it
     * But don't free anything related, so that
     * we can perform quick remount.
     * See: IOCTL_STORAGE_LOAD_MEDIA
     */
    DeviceExtension = DeviceObject->DeviceExtension;
    if (DeviceExtension->VolumeObject != NULL)
    {
        ObDereferenceObject(DeviceExtension->VolumeObject);
        /* Device changed, so mandatory increment */
        ++DeviceExtension->ChangeCount;
        DeviceExtension->VolumeObject = NULL;
    }

    return ViSetIoStatus(STATUS_SUCCESS, 0, Irp);
}

NTSTATUS
ViRemountMedia(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS Status;
    UNICODE_STRING Image;
    PDEVICE_EXTENSION DeviceExtension;

    /* Get the device extension */
    DeviceExtension = DeviceObject->DeviceExtension;
    /* Allocate a new string as mount parameter */
    Status = ViAllocateUnicodeString(DeviceExtension->ImageName.MaximumLength, &Image);
    if (!NT_SUCCESS(Status))
    {
        return ViSetIoStatus(Status, 0, Irp);
    }

    /* To allow cleanup in case of troubles */
    _SEH2_TRY
    {
        /* Copy our current image name and mount */
        RtlCopyUnicodeString(&Image, &DeviceExtension->ImageName);
        Status = ViIssueMountImage(DeviceObject, &Image, Irp);
    }
    _SEH2_FINALLY
    {
        ViFreeUnicodeString(&Image);
    }
    _SEH2_END;

    return ViSetIoStatus(Status, 0, Irp);
}

NTSTATUS
NTAPI
VcdDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    NTSTATUS Status;
    UNICODE_STRING Image;
    PIO_STACK_LOCATION Stack;
    PMOUNT_PARAMETERS MountParameters;
    PDEVICE_EXTENSION DeviceExtension;

    DeviceExtension = DeviceObject->DeviceExtension;
    Stack = IoGetCurrentIrpStackLocation(Irp);

    _SEH2_TRY
    {
        switch (Stack->Parameters.DeviceIoControl.IoControlCode)
        {
            /* First of all, our private IOCTLs */
            case IOCTL_VCDROM_CREATE_DRIVE:
                Status = ViCreateDevice(DeviceObject->DriverObject, Irp);
                break;

            case IOCTL_VCDROM_DELETE_DRIVE:
                Status = ViDeleteDevice(DeviceObject, Irp);
                break;

            case IOCTL_VCDROM_MOUNT_IMAGE:
                MountParameters = Irp->AssociatedIrp.SystemBuffer;
                Image.MaximumLength = 255 * sizeof(WCHAR);
                Image.Length = MountParameters->Length;
                Image.Buffer = MountParameters->Path;
                DeviceExtension->Flags = MountParameters->Flags;
                Status = ViIssueMountImage(DeviceObject, &Image, Irp);
                break;

            case IOCTL_VCDROM_ENUMERATE_DRIVES:
                Status = ViEnumerateDrives(DeviceObject, Irp);
                break;

            case IOCTL_VCDROM_GET_IMAGE_PATH:
                Status = ViGetImagePath(DeviceObject, Irp);
                break;

            /* Now, IOCTLs we have to handle as class driver */
            case IOCTL_DISK_GET_DRIVE_GEOMETRY:
            case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
                Status = ViGetDriveGeometry(DeviceObject, Irp);
                break;

            case IOCTL_DISK_CHECK_VERIFY:
            case IOCTL_CDROM_CHECK_VERIFY:
                Status = ViCheckVerify(DeviceObject, Irp);
                break;

            case IOCTL_CDROM_READ_TOC:
                Status = ViReadToc(DeviceObject, Irp);
                break;

            case IOCTL_CDROM_READ_TOC_EX:
                Status = ViReadTocEx(DeviceObject, Irp);
                break;

            case IOCTL_CDROM_GET_LAST_SESSION:
                Status = ViGetLastSession(DeviceObject, Irp);
                break;

            case IOCTL_STORAGE_EJECT_MEDIA:
            case IOCTL_CDROM_EJECT_MEDIA:
                Status = ViEjectMedia(DeviceObject, Irp);
                break;

            /* That one is a bit specific
             * It gets unmounted image mounted again
             */
            case IOCTL_STORAGE_LOAD_MEDIA:
                /* That means it can only be performed if:
                 * - We had an image previously
                 * - It's no longer mounted
                 * Otherwise, we just return success
                 */
                if (DeviceExtension->ImageName.Buffer == NULL || DeviceExtension->VolumeObject != NULL)
                {
                    Status = ViSetIoStatus(STATUS_SUCCESS, 0, Irp);
                }
                else
                {
                    Status = ViRemountMedia(DeviceObject, Irp);
                }
                break;

            default:
                Status = STATUS_INVALID_DEVICE_REQUEST;
                DPRINT1("IOCTL: %x not supported\n", Stack->Parameters.DeviceIoControl.IoControlCode);
                break;
        }
    } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    } _SEH2_END;

    /* Depending on the failure code, we may force a verify */
    if (!NT_SUCCESS(Status))
    {
        if (Status == STATUS_DEVICE_NOT_READY || Status == STATUS_IO_TIMEOUT ||
            Status == STATUS_MEDIA_WRITE_PROTECTED || Status == STATUS_NO_MEDIA_IN_DEVICE ||
            Status == STATUS_VERIFY_REQUIRED || Status == STATUS_UNRECOGNIZED_MEDIA ||
            Status == STATUS_WRONG_VOLUME)
        {
            IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        }
    }

    IoCompleteRequest(Irp, IO_DISK_INCREMENT);

    return Status;
}

NTSTATUS
NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
    NTSTATUS Status;
    UNICODE_STRING DeviceName;
    PDEVICE_OBJECT DeviceObject;
    PDEVICE_EXTENSION DeviceExtension;

    /* Set our entry points (rather limited :-)) */
    DriverObject->DriverUnload = VcdUnload;
    DriverObject->MajorFunction[IRP_MJ_CREATE] = VcdHandle;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = VcdHandle;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = VcdHandle;
    DriverObject->MajorFunction[IRP_MJ_READ] = VcdRead;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VcdDeviceControl;

    /* Create our main device to receive private IOCTLs */
    RtlInitUnicodeString(&DeviceName, L"\\Device\\VirtualCdRom");
    Status = IoCreateDevice(DriverObject, sizeof(DEVICE_EXTENSION), &DeviceName,
                            FILE_DEVICE_CD_ROM, FILE_READ_ONLY_DEVICE | FILE_FLOPPY_DISKETTE,
                            FALSE, &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    /* Initialize our device extension */
    ViInitializeDeviceExtension(DeviceObject);
    DeviceExtension = DeviceObject->DeviceExtension;

    /* And create our accessible name from umode */
    ViAllocateUnicodeString(DEFAULT_STRING_SIZE, &DeviceExtension->GlobalName);
    RtlAppendUnicodeToString(&DeviceExtension->GlobalName, L"\\??\\VirtualCdRom");
    Status = IoCreateSymbolicLink(&DeviceExtension->GlobalName, &DeviceName);
    if (!NT_SUCCESS(Status))
    {
        IoDeleteDevice(DeviceObject);
        return Status;
    }

    /* Initialize our mutex for device count */
    ExInitializeFastMutex(&ViMutex);

    /* And try to load images that would have been stored in registry */
    ViLoadImagesFromRegistry(DriverObject, RegistryPath->Buffer);

    return STATUS_SUCCESS;
}