vfdmnt.c

Go to the documentation of this file.

/*
    vfdmnt.c
 
    Virtual Floppy Drive for Windows NT platform
    Kernel mode driver mount manager functions
 
    Copyright (C) 2003-2005 Ken Kato
*/
 
#ifndef VFD_MOUNT_MANAGER
/*
    Not in working order for the time being
    so DO NOT define VFD_MOUNT_MANAGER macro
    unless you know exactly what you are doing...
*/
#if !defined(__REACTOS__) || defined(_MSC_VER)
//  suppress empty compile unit warning
#pragma warning (disable: 4206)
#pragma message ("Mount Manager support feature is disabled.")
#endif
 
#else   //  VFD_MOUNT_MANAGER
/*
    The flow of the drive letter assignment via the Mount Manager
    during the VFD driver start up
 
    1)  IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION  VFD -> MM
        notifies the mount manager of VFD devices.
 
    2)  IOCTL_MOUNTDEV_QUERY_DEVICE_NAME            VFD <- MM
        device name (\Device\Floppy<x>)             VFD -> MM
 
    3)  IOCTL_MOUNTDEV_QUERY_UNIQUE_ID              VFD <- MM
        device unique ID (\??\VirtualFD<x>)         VFD -> MM
 
    4)  IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME    VFD <- MM
        drive letter link (\DosDevices<x>:)     VFD -> MM
 
    5)  The mount manager creates the drive letter link
 
    6)  IOCTL_MOUNTDEV_LINK_CREATED                 VFD <- MM
        The driver stores the created drive letter
 
    The flow of the drive letter operation with IOCTL_VFD_SET_LINK
 
    1)  IOCTL_MOUNTMGR_CREATE_POINT or
        IOCTL_MOUNTMGR_DELETE_POINTS                VFD -> MM
 
    2)  The mount manager creates/deletes the drive letter link
 
    3)  IOCTL_MOUNTDEV_LINK_CREATED or
        IOCTL_MOUNTDEV_LINK_DELETED                 VFD <- MM
        The driver stores the created/deleted drive letter
*/
 
#include "imports.h"
#include "vfddrv.h"
#include "vfddbg.h"
 
//
//  Call the mount manager with an IO control IRP
//
static NTSTATUS
VfdMountMgrSendRequest(
    ULONG           ControlCode,
    PVOID           InputBuffer,
    ULONG           InputLength,
    PVOID           OutputBuffer,
    ULONG           OutputLength);
 
#ifdef ALLOC_PRAGMA
//#pragma alloc_text(PAGE, VfdRegisterMountManager)
#pragma alloc_text(PAGE, VfdMountMgrNotifyVolume)
#pragma alloc_text(PAGE, VfdMountMgrMountPoint)
#pragma alloc_text(PAGE, VfdMountMgrSendRequest)
#pragma alloc_text(PAGE, VfdMountDevUniqueId)
#pragma alloc_text(PAGE, VfdMountDevDeviceName)
#pragma alloc_text(PAGE, VfdMountDevSuggestedLink)
#pragma alloc_text(PAGE, VfdMountDevLinkModified)
#endif  // ALLOC_PRAGMA
 
/*
#include <initguid.h>
#include <mountmgr.h>
//
//  register a device to the mount manager interface
//  does not work...
//
NTSTATUS
VfdRegisterMountManager(
    PDEVICE_EXTENSION       DeviceExtension)
{
    NTSTATUS        status = STATUS_SUCCESS;
    UNICODE_STRING  interface;
    UNICODE_STRING  interface2;
 
    VFDTRACE(VFDINFO,
        ("[VFD] Registering %ws to the Mount Manager Interface\n",
        DeviceExtension->DeviceName.Buffer));
 
    RtlInitUnicodeString(&interface, NULL);
 
    status = IoRegisterDeviceInterface(
        DeviceExtension->DeviceObject,
        (LPGUID)&MOUNTDEV_MOUNTED_DEVICE_GUID,
        NULL,
        &interface);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(0,
            ("[VFD] IoRegisterDeviceInterface - %s\n",
            GetStatusName(status)));
        return status;
    }
 
    status = IoSetDeviceInterfaceState(&interface, TRUE);
 
    if (NT_SUCCESS(status)) {
        if (VfdCopyUnicode(&interface2, &interface)) {
            VFDTRACE(VFDINFO,
                ("[VFD] Interface: %ws\n", interface2.Buffer));
        }
        else {
            VFDTRACE(0,
                ("[VFD] Failed to allocate an interface name buffer\n"));
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    else {
        VFDTRACE(0,
            ("[VFD] IoSetDeviceInterfaceState - %s\n",
            GetStatusName(status)));
    }
 
    RtlFreeUnicodeString(&interface);
    VfdFreeUnicode(&interface2);
 
    return status;
}
*/
 
//
//  informs the Mount Manager of a new VFD device
//
NTSTATUS
VfdMountMgrNotifyVolume(
    PDEVICE_EXTENSION       DeviceExtension)
{
    PMOUNTMGR_TARGET_NAME   target_name;
    USHORT                  target_name_buf[MAXIMUM_FILENAME_LENGTH];
    NTSTATUS                status;
 
    VFDTRACE(VFDINFO,
        ("[VFD] VfdMountMgrNotifyVolume - %ws\n",
        DeviceExtension->DeviceName.Buffer));
 
    target_name = (PMOUNTMGR_TARGET_NAME)target_name_buf;
 
    target_name->DeviceNameLength =
        DeviceExtension->DeviceName.Length;
 
    RtlCopyMemory(
        target_name->DeviceName,
        DeviceExtension->DeviceName.Buffer,
        DeviceExtension->DeviceName.Length);
 
    status = VfdMountMgrSendRequest(
        IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION,
        target_name,
        sizeof(target_name->DeviceNameLength) + target_name->DeviceNameLength,
        NULL,
        0);
 
    VFDTRACE(VFDINFO,
        ("[VFD] VfdMountMgrNotifyVolume - %s\n",
        GetStatusName(status)));
 
    return status;
}
 
//
//  Create / remove a drive letter via the Mount Manager
//
NTSTATUS
VfdMountMgrMountPoint(
    PDEVICE_EXTENSION   DeviceExtension,
    CHAR                DriveLetter)
{
    ULONG               alloc_size;
    UNICODE_STRING      link_name;
    WCHAR               link_buf[20];
    NTSTATUS            status;
 
    VFDTRACE(VFDINFO, ("[VFD] VfdMountMgrMountPoint - IN\n"));
 
    //  convert lower case into upper case
 
    if (DriveLetter >= 'a' && DriveLetter <= 'z') {
        DriveLetter -= ('a' - 'A');
    }
 
    if (DriveLetter >= 'A' && DriveLetter <= 'Z') {
 
        //  Create a new drive letter
 
        PMOUNTMGR_CREATE_POINT_INPUT    create;
 
        swprintf(link_buf, L"\\DosDevices\\%wc:", DriveLetter);
 
        RtlInitUnicodeString(&link_name, link_buf);
 
        VFDTRACE(VFDINFO,
            ("[VFD] Creating a link: %ws => %ws\n",
            link_buf, DeviceExtension->DeviceName.Buffer));
 
        //  allocate buffer for MOUNTMGR_CREATE_POINT_INPUT
 
        alloc_size = sizeof(MOUNTMGR_CREATE_POINT_INPUT) +
            link_name.Length + DeviceExtension->DeviceName.Length;
 
        create = (PMOUNTMGR_CREATE_POINT_INPUT)ExAllocatePoolWithTag(
            NonPagedPool, alloc_size, VFD_POOL_TAG);
 
        if (!create) {
            VFDTRACE(0, ("[VFD] Failed to allocate mount point input\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        //  set the symbolic link name
 
        create->SymbolicLinkNameOffset  = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
        create->SymbolicLinkNameLength  = link_name.Length;
 
        RtlCopyMemory(
            (PCHAR)create + create->SymbolicLinkNameOffset,
            link_name.Buffer,
            link_name.Length);
 
        //  set the target device name
 
        create->DeviceNameOffset        = (USHORT)
            (create->SymbolicLinkNameOffset + create->SymbolicLinkNameLength);
        create->DeviceNameLength        = DeviceExtension->DeviceName.Length;
 
        RtlCopyMemory(
            (PCHAR)create + create->DeviceNameOffset,
            DeviceExtension->DeviceName.Buffer,
            DeviceExtension->DeviceName.Length);
 
        //  call the mount manager with the IO control request
 
        status = VfdMountMgrSendRequest(
            IOCTL_MOUNTMGR_CREATE_POINT,
            create, alloc_size, NULL, 0);
 
        ExFreePool(create);
 
        //  no need to set the new drive letter into the
        //  DeviceExtension because the mount manager will issue an
        //  IOCTL_MOUNTDEV_LINK_CREATED and it will be processed then
    }
    else if (DriveLetter == 0) {
 
        //  Delete the existing drive letter
 
        PMOUNTMGR_MOUNT_POINT   mount;
        PMOUNTMGR_MOUNT_POINTS  points;
        UNICODE_STRING  unique_id;
        WCHAR           unique_buf[20];
 
        swprintf(link_buf, L"\\DosDevices\\%wc:",
            DeviceExtension->DriveLetter);
 
        VFDTRACE(VFDINFO,
            ("[VFD] Deleting link: %ws\n", link_buf));
 
        RtlInitUnicodeString(&link_name, link_buf);
 
        swprintf(unique_buf, L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
            DeviceExtension->DeviceNumber);
 
        RtlInitUnicodeString(&unique_id, unique_buf);
 
        //  allocate buffer for MOUNTMGR_MOUNT_POINT
 
        alloc_size = sizeof(MOUNTMGR_MOUNT_POINT) +
            link_name.Length +
            unique_id.Length +
            DeviceExtension->DeviceName.Length;
 
        mount = (PMOUNTMGR_MOUNT_POINT)ExAllocatePoolWithTag(
            NonPagedPool, alloc_size, VFD_POOL_TAG);
 
        if (!mount) {
            VFDTRACE(0, ("[VFD] Failed to allocate mount point input\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlZeroMemory(mount, alloc_size + sizeof(WCHAR));
 
        //  set the symbolic link name
 
        mount->SymbolicLinkNameOffset   = sizeof(MOUNTMGR_MOUNT_POINT);
        mount->SymbolicLinkNameLength   = link_name.Length;
 
        RtlCopyMemory(
            (PCHAR)mount + mount->SymbolicLinkNameOffset,
            link_name.Buffer, link_name.Length);
 
        //  set the unique id
 
        mount->UniqueIdOffset =
            mount->SymbolicLinkNameOffset +
            mount->SymbolicLinkNameLength;
        mount->UniqueIdLength = unique_id.Length;
 
        RtlCopyMemory(
            (PCHAR)mount + mount->UniqueIdOffset,
            unique_id.Buffer, unique_id.Length);
 
        //  set the target device name
 
        mount->DeviceNameOffset =
            mount->UniqueIdOffset +
            mount->UniqueIdLength;
        mount->DeviceNameLength =
            DeviceExtension->DeviceName.Length;
 
        RtlCopyMemory(
            (PCHAR)mount + mount->DeviceNameOffset,
            DeviceExtension->DeviceName.Buffer,
            DeviceExtension->DeviceName.Length);
 
        //  prepare the output buffer
 
        points = (PMOUNTMGR_MOUNT_POINTS)ExAllocatePoolWithTag(
            NonPagedPool, alloc_size * 2, VFD_POOL_TAG);
 
        status = VfdMountMgrSendRequest(
            IOCTL_MOUNTMGR_DELETE_POINTS,
            mount, alloc_size, points, alloc_size * 2);
 
        ExFreePool(mount);
        ExFreePool(points);
 
        if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
            //  the drive letter did not exist in the first place
            DeviceExtension->DriveLetter = 0;
        }
 
        //  no need to clear the drive letter in the
        //  DeviceExtension because the mount manager will issue an
        //  IOCTL_MOUNTDEV_LINK_DELETED and it will be processed then
    }
    else {
        return STATUS_INVALID_PARAMETER;
    }
 
    VFDTRACE(VFDINFO, ("[VFD] VfdMountMgrMountPoint - %s\n",
        GetStatusName(status)));
 
    return status;
}
 
//
//  send a request to the Mount Manager
//
NTSTATUS
VfdMountMgrSendRequest(
    ULONG           ControlCode,
    PVOID           InputBuffer,
    ULONG           InputLength,
    PVOID           OutputBuffer,
    ULONG           OutputLength)
{
    NTSTATUS        status = STATUS_SUCCESS;
    UNICODE_STRING  mntmgr_name;
    PDEVICE_OBJECT  mntmgr_dev;
    PFILE_OBJECT    mntmgr_file;
    IO_STATUS_BLOCK io_status;
    KEVENT          event;
    PIRP            irp;
 
    //  Obtain a pointer to the Mount Manager device object
 
    RtlInitUnicodeString(
        &mntmgr_name,
        MOUNTMGR_DEVICE_NAME);
 
    status = IoGetDeviceObjectPointer(
        &mntmgr_name,
        FILE_READ_ATTRIBUTES,
        &mntmgr_file,
        &mntmgr_dev);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDWARN,
            ("[VFD] IoGetDeviceObjectPointer - %s\n", GetStatusName(status)));
        return status;
    }
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    //  Create an IRP request block
 
    irp = IoBuildDeviceIoControlRequest(
        ControlCode,
        mntmgr_dev,
        InputBuffer,
        InputLength,
        OutputBuffer,
        OutputLength,
        FALSE,
        &event,
        &io_status);
 
    if (!irp) {
        VFDTRACE(VFDWARN,
            ("[VFD] IoBuildDeviceIoControlRequest\n"));
        ObDereferenceObject(mntmgr_file);
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
 
    //  Call the mount manager
 
    status = IoCallDriver(mntmgr_dev, irp);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDWARN,
            ("[VFD] IoCallDriver - %s\n", GetStatusName(status)));
    }
 
    if (status == STATUS_PENDING) {
 
        //  Wait for the operation to complete
 
        KeWaitForSingleObject(
            &event, Executive, KernelMode, FALSE, NULL);
 
        status = io_status.Status;
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(VFDWARN,
                ("[VFD] IoCallDriver - %s\n", GetStatusName(status)));
        }
    }
 
    ObDereferenceObject(mntmgr_file);
 
    return status;
}
 
//
//  IOCTL_MOUNTDEV_QUERY_UNIQUE_ID
//  -- use the device interface link (\??\VirtualFD<x>) as the unique ID
//
NTSTATUS
VfdMountDevUniqueId(
    PDEVICE_EXTENSION   DeviceExtension,
    PMOUNTDEV_UNIQUE_ID UniqueId,
    ULONG               OutputLength,
    PIO_STATUS_BLOCK    IoStatus)
{
    WCHAR               buf[20];
    UNICODE_STRING      unicode;
 
    if (OutputLength < sizeof(MOUNTDEV_UNIQUE_ID)) {
        return STATUS_INVALID_PARAMETER;
    }
 
    swprintf(buf,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        DeviceExtension->DeviceNumber);
 
    RtlInitUnicodeString(&unicode, buf);
 
    UniqueId->UniqueIdLength = unicode.Length;
 
    if (OutputLength <
        sizeof(UniqueId->UniqueIdLength) + UniqueId->UniqueIdLength) {
 
        IoStatus->Information = sizeof(MOUNTDEV_UNIQUE_ID);
        return STATUS_BUFFER_OVERFLOW;
    }
 
    RtlCopyMemory(
        UniqueId->UniqueId, buf, unicode.Length);
 
    IoStatus->Information =
        sizeof(UniqueId->UniqueIdLength) + UniqueId->UniqueIdLength;
 
    return STATUS_SUCCESS;
}
 
//
//  IOCTL_MOUNTDEV_QUERY_DEVICE_NAME
//  Returns the device name of the target device (\Device\Floppy<n>)
//
NTSTATUS
VfdMountDevDeviceName(
    PDEVICE_EXTENSION   DeviceExtension,
    PMOUNTDEV_NAME      DeviceName,
    ULONG               OutputLength,
    PIO_STATUS_BLOCK    IoStatus)
{
    if (OutputLength < sizeof(MOUNTDEV_NAME)) {
        return STATUS_INVALID_PARAMETER;
    }
 
    DeviceName->NameLength = DeviceExtension->DeviceName.Length;
 
    if (OutputLength <
        sizeof(DeviceName->NameLength) + DeviceName->NameLength) {
 
        IoStatus->Information = sizeof(MOUNTDEV_NAME);
        return STATUS_BUFFER_OVERFLOW;
    }
 
    RtlCopyMemory(
        DeviceName->Name,
        DeviceExtension->DeviceName.Buffer,
        DeviceName->NameLength);
 
    IoStatus->Information =
        sizeof(DeviceName->NameLength) + DeviceName->NameLength;
 
    return STATUS_SUCCESS;
}
 
//
//  IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME
//  Returns the drive letter link which we want the mount manager
//  to create.  This request is issued in response to the volume
//  arrival notification, and the mount manager will create the
//  symbolic link.
//
NTSTATUS
VfdMountDevSuggestedLink(
    PDEVICE_EXTENSION   DeviceExtension,
    PMOUNTDEV_SUGGESTED_LINK_NAME   LinkName,
    ULONG               OutputLength,
    PIO_STATUS_BLOCK    IoStatus)
{
    WCHAR               buf[20];
    UNICODE_STRING      unicode;
 
    if (OutputLength < sizeof(MOUNTDEV_SUGGESTED_LINK_NAME)) {
        return STATUS_INVALID_PARAMETER;
    }
 
    LinkName->UseOnlyIfThereAreNoOtherLinks = TRUE;
 
    if (!DeviceExtension->DriveLetter) {
 
        //  No persistent drive letter stored in the registry
        VFDTRACE(VFDINFO, ("[VFD] suggested link : none\n"));
 
        LinkName->NameLength  = 0;
 
        IoStatus->Information = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
        return STATUS_SUCCESS;
    }
 
    //  A persistent drive letter exists
 
    swprintf(buf, L"\\DosDevices\\%wc:",
        DeviceExtension->DriveLetter);
 
    VFDTRACE(VFDINFO, ("[VFD] suggested link : %ws\n", buf));
 
    RtlInitUnicodeString(&unicode, buf);
 
    LinkName->NameLength = unicode.Length;
 
    if (OutputLength <
        sizeof(MOUNTDEV_SUGGESTED_LINK_NAME) +
        LinkName->NameLength - sizeof(WCHAR)) {
 
        IoStatus->Information = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
        return STATUS_BUFFER_OVERFLOW;
    }
 
    RtlCopyMemory(LinkName->Name, buf, unicode.Length);
 
    IoStatus->Information =
        sizeof(MOUNTDEV_SUGGESTED_LINK_NAME) +
        LinkName->NameLength - sizeof(WCHAR);
 
    return STATUS_SUCCESS;
}
 
//
//  IOCTL_MOUNTDEV_LINK_CREATED / IOCTL_MOUNTDEV_LINK_DELETED
//  Issued after the mount manager created/deleted a symbolic link
//  If the link is a drive letter, store the new value into the
//  registry as the new drive letter
//
NTSTATUS
VfdMountDevLinkModified(
    PDEVICE_EXTENSION   DeviceExtension,
    PMOUNTDEV_NAME      LinkName,
    ULONG               InputLength,
    ULONG               ControlCode)
{
    if (InputLength < sizeof(MOUNTDEV_NAME)) {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (InputLength < sizeof(MOUNTDEV_NAME) +
        LinkName->NameLength - sizeof(WCHAR)) {
 
        return STATUS_INVALID_PARAMETER;
    }
 
#if DBG
    {   //  Print the reported link name
        PWSTR buf = ExAllocatePoolWithTag(
            PagedPool, LinkName->NameLength + sizeof(WCHAR), VFD_POOL_TAG);
 
        if (buf) {
            RtlZeroMemory(buf, LinkName->NameLength + sizeof(WCHAR));
            RtlCopyMemory(buf, LinkName->Name, LinkName->NameLength);
            VFDTRACE(VFDINFO, ("[VFD] %ws\n", buf));
            ExFreePool(buf);
        }
    }
#endif  // DBG
 
    if (LinkName->NameLength == 28      &&
        LinkName->Name[0]   == L'\\'    &&
        LinkName->Name[1]   == L'D'     &&
        LinkName->Name[2]   == L'o'     &&
        LinkName->Name[3]   == L's'     &&
        LinkName->Name[4]   == L'D'     &&
        LinkName->Name[5]   == L'e'     &&
        LinkName->Name[6]   == L'v'     &&
        LinkName->Name[7]   == L'i'     &&
        LinkName->Name[8]   == L'c'     &&
        LinkName->Name[9]   == L'e'     &&
        LinkName->Name[10]  == L's'     &&
        LinkName->Name[11]  == L'\\'    &&
        LinkName->Name[12]  >= L'A'     &&
        LinkName->Name[12]  <= L'Z'     &&
        LinkName->Name[13]  == L':') {
 
        //  The link is a drive letter
 
        if (ControlCode == IOCTL_MOUNTDEV_LINK_CREATED) {
            //  link is created - store the new drive letter
            DeviceExtension->DriveLetter = (CHAR)LinkName->Name[12];
        }
        else {
            //  link is deleted - clear the drive letter
            DeviceExtension->DriveLetter = 0;
        }
 
        //  Store the value into the registry
 
        VfdStoreLink(DeviceExtension);
    }
 
    return STATUS_SUCCESS;
}
 
#endif  //  VFD_MOUNT_MANAGER