vfddrv.h File Reference

#include "vfdtypes.h"
#include "vfdio.h"
#include "vfdver.h"

Include dependency graph for vfddrv.h:

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

Go to the source code of this file.

Classes
struct	_VFD_DRIVER_EXTENSION
struct	_DEVICE_EXTENSION

Macros
#define	VFD_POOL_TAG   'DFVx'

Typedefs
typedef struct _VFD_DRIVER_EXTENSION	VFD_DRIVER_EXTENSION
typedef struct _VFD_DRIVER_EXTENSION *	PVFD_DRIVER_EXTENSION
typedef struct _DEVICE_EXTENSION	DEVICE_EXTENSION
typedef struct _DEVICE_EXTENSION *	PDEVICE_EXTENSION

Functions
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
VOID NTAPI	VfdUnloadDriver (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	VfdCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	VfdReadWrite (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	VfdDeviceControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	VfdDeviceThread (IN PVOID ThreadContext)
PWSTR	VfdCopyUnicode (OUT PUNICODE_STRING dst, IN PUNICODE_STRING src)
VOID	VfdFreeUnicode (IN OUT PUNICODE_STRING str)
NTSTATUS	VfdCreateDevice (IN PDRIVER_OBJECT DriverObject, OUT PVOID Parameter)
VOID	VfdDeleteDevice (IN PDEVICE_OBJECT DeviceObject)
VOID	VfdIoCtlThread (IN PDEVICE_EXTENSION DeviceExtension, IN PIRP Irp, IN ULONG ControlCode)
NTSTATUS	VfdOpenCheck (IN PDEVICE_EXTENSION DeviceExtension, IN PVFD_IMAGE_INFO ImageInfo, IN ULONG InputLength)
NTSTATUS	VfdOpenImage (IN PDEVICE_EXTENSION DeviceExtension, IN PVFD_IMAGE_INFO ImageInfo)
VOID	VfdCloseImage (IN PDEVICE_EXTENSION DeviceExtension)
NTSTATUS	VfdQueryImage (IN PDEVICE_EXTENSION DeviceExtension, OUT PVFD_IMAGE_INFO ImageInfo, IN ULONG BufferLength, OUT PULONG ReturnLength)
VOID	VfdReadData (IN PDEVICE_EXTENSION DeviceExtension, IN OUT PIRP Irp, IN ULONG Length, IN PLARGE_INTEGER Offset)
VOID	VfdWriteData (IN PDEVICE_EXTENSION DeviceExtension, IN OUT PIRP Irp, IN ULONG Length, IN PLARGE_INTEGER Offset)
NTSTATUS	VfdSetLink (IN PDEVICE_EXTENSION DeviceExtension, IN CHAR DriveLetter)
NTSTATUS	VfdStoreLink (IN PDEVICE_EXTENSION DeviceExtension)
NTSTATUS	VfdLoadLink (IN PDEVICE_EXTENSION DeviceExtension, IN PWSTR RegistryPath)
NTSTATUS	VfdFormatCheck (IN PDEVICE_EXTENSION DeviceExtension, IN PFORMAT_PARAMETERS FormatParams, IN ULONG InputLength, IN ULONG ControlCode)
NTSTATUS	VfdFormatTrack (IN PDEVICE_EXTENSION DeviceExtension, IN PFORMAT_PARAMETERS FormatParams)

Variables
ULONG	OsMajorVersion
ULONG	OsMinorVersion
ULONG	OsBuildNumber
const DISK_GEOMETRY	geom_tbl [VFD_MEDIA_MAX]

Macro Definition Documentation

VFD_POOL_TAG

#define VFD_POOL_TAG   'DFVx'

Definition at line 25 of file vfddrv.h.

Typedef Documentation

DEVICE_EXTENSION

typedef struct _DEVICE_EXTENSION DEVICE_EXTENSION

PDEVICE_EXTENSION

typedef struct _DEVICE_EXTENSION * PDEVICE_EXTENSION

PVFD_DRIVER_EXTENSION

typedef struct _VFD_DRIVER_EXTENSION * PVFD_DRIVER_EXTENSION

VFD_DRIVER_EXTENSION

typedef struct _VFD_DRIVER_EXTENSION VFD_DRIVER_EXTENSION

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 1604 of file cmbatt.c.

{
    NTSTATUS Status;
    PDRIVER_EXTENSION DriverExtension;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING CallbackName;
 
    /* Allocate registry path */
    GlobalRegistryPath.MaximumLength = RegistryPath->Length + sizeof(UNICODE_NULL);
    GlobalRegistryPath.Length = RegistryPath->Length;
    GlobalRegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                      GlobalRegistryPath.MaximumLength,
                                                      'MtaB');
    if (!GlobalRegistryPath.Buffer)
    {
        /* Fail if we're out of memory this early */
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBatt: Couldn't allocate pool for registry path.");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Buffer allocated, copy the string */
    RtlCopyUnicodeString(&GlobalRegistryPath, RegistryPath);
    if (CmBattDebug & CMBATT_GENERIC_INFO)
        DbgPrint("CmBatt DriverEntry - Obj (%08x) Path \"%wZ\"\n",
                 DriverObject,
                 RegistryPath);
 
    /* Setup the major dispatchers */
    DriverObject->MajorFunction[IRP_MJ_CREATE] = CmBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = CmBattOpenClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = CmBattIoctl;
    DriverObject->MajorFunction[IRP_MJ_POWER] = CmBattPowerDispatch;
    DriverObject->MajorFunction[IRP_MJ_PNP] = CmBattPnpDispatch;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = CmBattSystemControl;
 
    /* And the unload routine */
    DriverObject->DriverUnload = CmBattUnload;
 
    /* And the add device routine */
    DriverExtension = DriverObject->DriverExtension;
    DriverExtension->AddDevice = CmBattAddDevice;
 
    /* Create a power callback */
    RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
    InitializeObjectAttributes(&ObjectAttributes,
                               &CallbackName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ExCreateCallback(&CmBattPowerCallBackObject, &ObjectAttributes, 0, TRUE);
    if (!NT_SUCCESS(Status))
    {
        /* No callback, fail */
        CmBattPowerCallBackObject = 0;
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBattRegisterPowerCallBack: failed status=0x%08x\n", Status);
    }
    else
    {
        /* Register the power callback now */
        CmBattPowerCallBackRegistration = ExRegisterCallback(CmBattPowerCallBackObject,
                                                             (PVOID)CmBattPowerCallBack,
                                                             DriverObject);
        if (CmBattPowerCallBackRegistration)
        {
            /* Last thing: setup our DPC and timer for battery wake */
            KeInitializeDpc(&CmBattWakeDpcObject, (PVOID)CmBattWakeDpc, DriverObject);
            KeInitializeTimer(&CmBattWakeDpcTimerObject);
        }
        else
        {
            ObDereferenceObject(CmBattPowerCallBackObject);
            if (CmBattDebug & CMBATT_GENERIC_WARNING)
                DbgPrint("CmBattRegisterPowerCallBack: ExRegisterCallback failed.\n");
        }
 
        /* All good */
        Status = STATUS_SUCCESS;
    }
 
    /* Return failure or success */
    return Status;
}

VfdCloseImage()

VOID VfdCloseImage

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 435 of file vfdimg.c.

{
    VFDTRACE(0, ("[VFD] VfdCloseImage - IN\n"));
 
    ASSERT(DeviceExtension);
 
    DeviceExtension->MediaType          = VFD_MEDIA_NONE;
    DeviceExtension->MediaFlags         = 0;
    DeviceExtension->FileType           = 0;
    DeviceExtension->ImageSize          = 0;
    DeviceExtension->FileName.Length    = 0;
    DeviceExtension->Sectors            = 0;
 
    if (DeviceExtension->FileHandle) {
        ZwClose(DeviceExtension->FileHandle);
        DeviceExtension->FileHandle = NULL;
    }
 
    if (DeviceExtension->FileBuffer) {
        ExFreePool(DeviceExtension->FileBuffer);
        DeviceExtension->FileBuffer = NULL;
    }
 
    VFDTRACE(0, ("[VFD] VfdCloseImage - OUT\n"));
}

Referenced by Close(), VfdGuiClose(), and VfdIoCtlThread().

VfdCopyUnicode()

PWSTR VfdCopyUnicode	(	OUT PUNICODE_STRING	dst,
		IN PUNICODE_STRING	src
	)

VfdCreateClose()

NTSTATUS NTAPI VfdCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 312 of file vfddrv.c.

{
#if DBG
    if (DeviceObject && DeviceObject->DeviceExtension &&
        ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer) {
 
        VFDTRACE(VFDINFO, ("[VFD] %-40s %ws\n",
            GetMajorFuncName(IoGetCurrentIrpStackLocation(Irp)->MajorFunction),
            ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer));
    }
    else {
        VFDTRACE(VFDINFO, ("[VFD] %-40s %p\n",
            GetMajorFuncName(IoGetCurrentIrpStackLocation(Irp)->MajorFunction),
            DeviceObject));
    }
#endif  // DBG
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = FILE_OPENED;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

VfdCreateDevice()

NTSTATUS VfdCreateDevice	(	IN PDRIVER_OBJECT	DriverObject,
		OUT PVOID	Parameter
	)

Definition at line 23 of file vfddev.c.

{
    NTSTATUS                status;
    ULONG                   physical_num;
 
    UNICODE_STRING          unicode_name;
    WCHAR                   name_buffer[40];
 
    PVFD_DRIVER_EXTENSION   driver_extension    = NULL;
    PDEVICE_OBJECT          device_object       = NULL;
    PDEVICE_EXTENSION       device_extension    = NULL;
    HANDLE                  thread_handle       = NULL;
 
    VFDTRACE(VFDINFO | VFDDEV, ("[VFD] VfdCreateDevice - IN\n"));
 
#ifdef VFD_PNP
 
    //  Get the driver device_extension for the driver object
    driver_extension = IoGetDriverObjectExtension(
        DriverObject, VFD_DRIVER_EXTENSION_ID);
 
#else   // VFD_PNP
 
    //  The driver device_extension is passed as the Parameter
    driver_extension = (PVFD_DRIVER_EXTENSION)Parameter;
 
#endif  // VFD_PNP
 
    if (driver_extension == NULL) {
        VFDTRACE(VFDERR, ("[VFD] Failed to get the driver extension\n"));
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
 
    //
    // Create a device object
    // \Device\Floppy<n>
    //
    physical_num = 0;
 
    do {
#ifndef __REACTOS__
        name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buffer, sizeof(name_buffer) - 1,
            L"\\Device\\Floppy%lu", physical_num);
#else
        name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
            L"\\Device\\Floppy%lu", physical_num);
#endif
 
        RtlInitUnicodeString(&unicode_name, name_buffer);
 
        status = IoCreateDevice(
            DriverObject,
            sizeof(DEVICE_EXTENSION),
            &unicode_name,
            FILE_DEVICE_DISK,
            FILE_REMOVABLE_MEDIA | FILE_FLOPPY_DISKETTE | FILE_DEVICE_SECURE_OPEN,
            FALSE,
            &device_object);
 
        if (status != STATUS_OBJECT_NAME_EXISTS &&
            status != STATUS_OBJECT_NAME_COLLISION) {
            break;
        }
    }
    while (++physical_num < 100);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] IoCreateDevice() %s\n",
            GetStatusName(status)));
        return status;
    }
 
    IoGetConfigurationInformation()->FloppyCount++;
 
    VFDTRACE(VFDINFO | VFDDEV,
        ("[VFD] Created a device object %ws\n", name_buffer));
 
    //
    //  Initialize the device object / device extension
    //
 
    device_object->Flags |= DO_DIRECT_IO;
 
    device_extension = (PDEVICE_EXTENSION)device_object->DeviceExtension;
 
    RtlZeroMemory(device_extension, sizeof(DEVICE_EXTENSION));
 
    //  Store the back pointer to the device object
 
    device_extension->DeviceObject = device_object;
 
    //  Store the logical device number
 
    device_extension->DeviceNumber = driver_extension->NumberOfDevices;
 
    //  Store the device name
 
    if (!VfdCopyUnicode(&(device_extension->DeviceName), &unicode_name)) {
        VFDTRACE(VFDERR,
            ("[VFD] Failed to allocate device name buffer\n"));
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
 
    //  set the default disk geometry (3.5" 1.44M)
 
    device_extension->Geometry = &geom_tbl[0];
 
    //  Create the interface link (\??\VirtualFD<n>)
 
#ifndef __REACTOS__
    name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, sizeof(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#else
    name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#endif
 
    RtlInitUnicodeString(&unicode_name, name_buffer);
 
    status = IoCreateSymbolicLink(
        &unicode_name, &device_extension->DeviceName);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] IoCreateSymbolicLink(%ws) %s\n",
            name_buffer, GetStatusName(status)));
        goto cleanup;
    }
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] Created a symbolic link %ws\n", name_buffer));
 
    //  Prepare the IRP queue list for the device thread
 
    InitializeListHead(&device_extension->ListHead);
 
    KeInitializeSpinLock(&device_extension->ListLock);
 
    KeInitializeEvent(
        &device_extension->RequestEvent,
        SynchronizationEvent,
        FALSE);
 
    //  Create the device thread
 
    device_extension->TerminateThread = FALSE;
 
    status = PsCreateSystemThread(
        &thread_handle,
        (ACCESS_MASK) 0L,
        NULL,
        NULL,
        NULL,
        VfdDeviceThread,
        device_object);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] PsCreateSystemThread() %s\n",
            GetStatusName(status)));
        goto cleanup;
    }
 
    //  get a reference pointer to the thread
 
    status = ObReferenceObjectByHandle(
        thread_handle,
        THREAD_ALL_ACCESS,
        NULL,
        KernelMode,
        &device_extension->ThreadPointer,
        NULL);
 
    ZwClose(thread_handle);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDERR,
            ("[VFD] ObReferenceObjectByHandle() %s\n",
            GetStatusName(status)));
        goto cleanup;
    }
 
    //
    //  Load the persistent drive letter from the registry
    //
    if (driver_extension->RegistryPath.Buffer) {
        VfdLoadLink(device_extension,
            driver_extension->RegistryPath.Buffer);
        //  error is not fatal here
    }
 
    //  increment the number of devices in the driver extension
 
    driver_extension->NumberOfDevices++;
 
    if (DriverObject->DriverUnload) {
        //  not called from the DriverEntry routine
        device_object->Flags &= ~DO_DEVICE_INITIALIZING;
    }
 
#ifdef VFD_PNP
    if (Parameter) {
        //  return the device object pointer
        *(PDEVICE_OBJECT *)Parameter = device_object;
    }
#else   // VFD_PNP
    device_extension->DriverExtension = driver_extension;
#endif  // VFD_PNP
 
    VFDTRACE(VFDINFO | VFDDEV, ("[VFD] VfdCreateDevice - OK\n"));
 
    return STATUS_SUCCESS;
 
cleanup:
    //
    //  Something went wrong at one point
    //  Delete all resources that might be created in this function
    //
    if (thread_handle) {
 
        //  terminate the device thread
        device_extension->TerminateThread = TRUE;
 
        KeSetEvent(
            &device_extension->RequestEvent,
            (KPRIORITY) 0,
            FALSE);
 
        if (device_extension->ThreadPointer) {
            ObDereferenceObject(device_extension->ThreadPointer);
        }
    }
 
    VFDTRACE(VFDINFO|VFDDEV,
    ("[VFD] Deleting symbolic link %ws\n", name_buffer));
 
    IoDeleteSymbolicLink(&unicode_name);
 
    if (device_extension->DeviceName.Buffer) {
        VFDTRACE(VFDINFO|VFDDEV, ("[VFD] Deleting device %ws\n",
            device_extension->DeviceName.Buffer));
 
        ExFreePool(device_extension->DeviceName.Buffer);
    }
 
    IoDeleteDevice(device_object);
    IoGetConfigurationInformation()->FloppyCount--;
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] VfdCreateDevice - %s\n",
        GetStatusName(status)));
 
    return status;
}

Referenced by DriverEntry().

VfdDeleteDevice()

VOID VfdDeleteDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 296 of file vfddev.c.

{
    PDEVICE_EXTENSION           device_extension;
    PVFD_DRIVER_EXTENSION       driver_extension;
    UNICODE_STRING              unicode_name;
    WCHAR                       name_buffer[40];
 
    VFDTRACE(VFDINFO|VFDDEV, ("[VFD] VfdDeleteDevice - IN\n"));
 
    device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    //
    //  decrement the number of device in the driver extension
    //
#ifdef VFD_PNP
    driver_extension = IoGetDriverObjectExtension(
        DeviceObject->DriverObject, VFD_DRIVER_EXTENSION_ID);
#else   // VFD_PNP
    driver_extension = device_extension->DriverExtension;
#endif  // VFD_PNP
 
    if (driver_extension) {
        driver_extension->NumberOfDevices--;
    }
 
    //
    //  cleanup the device object
    //
 
    //  Terminate the device thread
 
    device_extension->TerminateThread = TRUE;
 
    KeSetEvent(
        &device_extension->RequestEvent,
        (KPRIORITY) 0,
        FALSE);
 
    KeWaitForSingleObject(
        device_extension->ThreadPointer,
        Executive,
        KernelMode,
        FALSE,
        NULL);
 
    ObDereferenceObject(
        device_extension->ThreadPointer);
 
    //  Delete security context object
 
    if (device_extension->SecurityContext) {
        SeDeleteClientSecurity(device_extension->SecurityContext);
        ExFreePool(device_extension->SecurityContext);
    }
 
    //  Close the image file or free the image buffer
 
    if (device_extension->FileHandle) {
        ZwClose(device_extension->FileHandle);
    }
 
    if (device_extension->FileBuffer) {
        ExFreePool(device_extension->FileBuffer);
    }
 
    //  Release the image path buffer
 
    if (device_extension->FileName.Buffer) {
        ExFreePool(device_extension->FileName.Buffer);
    }
 
    //  Remove the interface symbolic link
 
#ifndef __REACTOS__
    name_buffer[sizeof(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, sizeof(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#else
    name_buffer[ARRAYSIZE(name_buffer) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buffer, ARRAYSIZE(name_buffer) - 1,
        L"\\??\\" VFD_DEVICE_BASENAME L"%lu",
        device_extension->DeviceNumber);
#endif
 
    RtlInitUnicodeString(&unicode_name, name_buffer);
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] Deleting link %ws\n", name_buffer));
 
    IoDeleteSymbolicLink(&unicode_name);
 
    //  Remove the persistent drive letter
 
    if (device_extension->DriveLetter) {
#ifdef VFD_MOUNT_MANAGER
        if (OsMajorVersion >= 5) {
            //  Request the mount manager to remove the drive letter.
            //  This will cause the mount manager to update its database
            //  and it won't arbitrarily assign the drive letter the next
            //  time the driver starts.
            VfdMountMgrMountPoint(device_extension, 0);
        }
        else
#endif  // VFD_MOUNT_MANAGER
        {
            //  Windows NT style drive letter handling
            //  Simply remove the symbolic link
            VfdSetLink(device_extension, 0);
        }
    }
 
    //  Release the device name buffer
 
    if (device_extension->DeviceName.Buffer) {
        VFDTRACE(VFDINFO|VFDDEV,
            ("[VFD] Deleting device %ws\n",
            device_extension->DeviceName.Buffer));
 
        ExFreePool(device_extension->DeviceName.Buffer);
    }
 
    //  Delete the device object
 
    IoDeleteDevice(DeviceObject);
    IoGetConfigurationInformation()->FloppyCount--;
 
    VFDTRACE(VFDINFO|VFDDEV,
        ("[VFD] VfdDeleteDevice - OUT\n"));
 
    return;
}

Referenced by VfdUnloadDriver().

VfdDeviceControl()

NTSTATUS NTAPI VfdDeviceControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 29 of file vfdioctl.c.

{
    PDEVICE_EXTENSION           device_extension;
    PIO_STACK_LOCATION          io_stack;
    NTSTATUS                    status;
 
    device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
    io_stack = IoGetCurrentIrpStackLocation(Irp);
 
    Irp->IoStatus.Information = 0;
 
    VFDTRACE(VFDINFO, ("[VFD] %-40s %ws\n",
        GetIoControlName(IO_CTRLCODE(io_stack)),
        device_extension->DeviceName.Buffer));
 
#ifdef VFD_PNP
    status = IoAcquireRemoveLock(&device_extension->RemoveLock, Irp);
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(0,
            ("Acquire RemoveLock failed %s\n", NtStatusToStr(status)));
 
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }
#endif  // VFD_PNP
 
/*
    //  Check if volume verification is required
 
    if ((DeviceObject->Flags & DO_VERIFY_VOLUME) &&
        !(io_stack->Flags & SL_OVERRIDE_VERIFY_VOLUME)) {
 
        VFDTRACE(VFDWARN,
            ("[VFD] %-40s - %s\n",
                GetIoControlName(IO_CTRLCODE(io_stack)),
                GetStatusName(STATUS_VERIFY_REQUIRED)));
 
        Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_VERIFY_REQUIRED;
    }
*/
 
    switch (IO_CTRLCODE(io_stack)) {
    case IOCTL_VFD_OPEN_IMAGE:
        //  Open an image file or create an empty RAM disk.
        //  Only a few checks are done here.
        //  Actual operation is done in device thread
 
        status = VfdOpenCheck(
            device_extension,
            (PVFD_IMAGE_INFO)Irp->AssociatedIrp.SystemBuffer,
            IO_INPUTLEN(io_stack));
 
        if (!NT_SUCCESS(status)) {
            break;
        }
 
        // Pass the task to the device thread
        status = STATUS_PENDING;
        break;
 
    case IOCTL_VFD_CLOSE_IMAGE:
    case IOCTL_DISK_EJECT_MEDIA:
    case IOCTL_STORAGE_EJECT_MEDIA:
        //  Close the current image file or delete the RAM disk
        //  Only status check is done here.
        //  Actual operation is done in device thread.
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
 
        // Pass the task to the device thread
        status = STATUS_PENDING;
        break;
 
    case IOCTL_VFD_QUERY_IMAGE:
        //  Returns current image file information
 
        status = VfdQueryImage(
            device_extension,
            (PVFD_IMAGE_INFO)Irp->AssociatedIrp.SystemBuffer,
            IO_OUTPUTLEN(io_stack),
            &Irp->IoStatus.Information);
 
        break;
 
    case IOCTL_VFD_SET_LINK:
        // Create / remove a persistent drive letter
        // and store it in the registry
 
        if (IO_INPUTLEN(io_stack) < sizeof(CHAR)) {
            status = STATUS_INVALID_PARAMETER;
            break;
        }
 
#ifdef VFD_MOUNT_MANAGER
        if (OsMajorVersion >= 5) {
            //  Windows 2000/XP
            //  Create a drive letter via the mount manager
 
            status = VfdMountMgrMountPoint(device_extension,
                *(PCHAR)Irp->AssociatedIrp.SystemBuffer);
 
            //  The new drive letter will be stored in the device extension
            //  and the registry when IOCTL_MOUNTDEV_LINK_CREATED or
            //  IOCTL_MOUNTDEV_LINK_DELETED is issued from the mount manager.
        }
        else
#else   //  VFD_MOUNT_MANAGER
        {
            //  Windows NT style drive letter assignment
            //  Simply create a symbolic link and store the new value
 
            status = VfdSetLink(device_extension,
                *(PCHAR)Irp->AssociatedIrp.SystemBuffer);
 
            if (NT_SUCCESS(status)) {
                //  Store the new drive letter into the registry
                status = VfdStoreLink(device_extension);
            }
        }
#endif  //  VFD_MOUNT_MANAGER
        break;
 
    case IOCTL_VFD_QUERY_LINK:
        //  Return the current persistent drive letter
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(CHAR)) {
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        *(PCHAR)Irp->AssociatedIrp.SystemBuffer =
            device_extension->DriveLetter;
 
        Irp->IoStatus.Information = sizeof(CHAR);
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_SET_PROTECT:
        //  Set media protect flag
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
 
        device_extension->MediaFlags |= VFD_FLAG_WRITE_PROTECTED;
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_CLEAR_PROTECT:
        //  Clear media protect flag
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
 
        device_extension->MediaFlags &= ~VFD_FLAG_WRITE_PROTECTED;
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_RESET_MODIFY:
        //  Reset the data modify flag
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
 
        device_extension->MediaFlags &= ~VFD_FLAG_DATA_MODIFIED;
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_QUERY_NUMBER:
        //  Return VFD device number (\??\VirtualFD<n>)
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(ULONG)) {
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        *(PULONG)Irp->AssociatedIrp.SystemBuffer=
            device_extension->DeviceNumber;
 
        Irp->IoStatus.Information = sizeof(ULONG);
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_QUERY_NAME:
        //  Return VFD device name (\Device\Floppy<n>)
        //  counted unicode string (not null terminated)
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(USHORT)) {
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        {
            PUSHORT p = (PUSHORT)Irp->AssociatedIrp.SystemBuffer;
 
            *p = device_extension->DeviceName.Length;
 
            if (IO_OUTPUTLEN(io_stack) < sizeof(USHORT) + *p) {
 
                Irp->IoStatus.Information = sizeof(USHORT);
                status = STATUS_BUFFER_OVERFLOW;
                break;
            }
 
            RtlCopyMemory(p + 1, device_extension->DeviceName.Buffer, *p);
 
            Irp->IoStatus.Information = sizeof(USHORT) + *p;
        }
 
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_VFD_QUERY_VERSION:
        //  Return the VFD driver version
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(ULONG)) {
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        *(PULONG)Irp->AssociatedIrp.SystemBuffer =
            (VFD_DRIVER_MAJOR << 16) | VFD_DRIVER_MINOR | VFD_DEBUG_FLAG;
 
        Irp->IoStatus.Information = sizeof(ULONG);
        status = STATUS_SUCCESS;
        break;
 
    //
    //  standard disk and storage I/O control requests
    //
 
    case IOCTL_DISK_CHECK_VERIFY:
    case IOCTL_STORAGE_CHECK_VERIFY:
    case IOCTL_STORAGE_CHECK_VERIFY2:
 
        if (IO_OUTPUTLEN(io_stack) >= sizeof(ULONG)) {
 
            *(PULONG)Irp->AssociatedIrp.SystemBuffer =
                device_extension->MediaChangeCount;
 
            Irp->IoStatus.Information = sizeof(ULONG);
        }
 
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_DISK_FORMAT_TRACKS:
    case IOCTL_DISK_FORMAT_TRACKS_EX:
        //  Only parameter checks are performed here
        //  Actual operation is done by the device thread
 
        status = VfdFormatCheck(
            device_extension,
            (PFORMAT_PARAMETERS)Irp->AssociatedIrp.SystemBuffer,
            IO_INPUTLEN(io_stack),
            IO_CTRLCODE(io_stack));
 
        if (!NT_SUCCESS(status)) {
            break;
        }
 
        // Pass the task to the device thread
        status = STATUS_PENDING;
        break;
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
        //  Returns the geometry of current media
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
        //  fall through
 
    case IOCTL_DISK_GET_MEDIA_TYPES:
    case IOCTL_STORAGE_GET_MEDIA_TYPES:
        //  Return *the last mounted* disk geometry, although xxx_GET_MEDIA_TYPES
        //  commands are supposed to return all supported media types.
        //  This makes the matter much simpler...;-)
        //  If no image has been mounted yet, 1.44MB media is assumed.
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(DISK_GEOMETRY)) {
            return STATUS_BUFFER_TOO_SMALL;
        }
 
        //  Copy appropriate DISK_GEOMETRY into the output buffer
 
        if (device_extension->Geometry) {
            RtlCopyMemory(
                Irp->AssociatedIrp.SystemBuffer,
                device_extension->Geometry,
                sizeof(DISK_GEOMETRY));
        }
        else {
            //  default = 3.5" 1.44 MB media
            RtlCopyMemory(
                Irp->AssociatedIrp.SystemBuffer,
                &geom_tbl[VFD_MEDIA_F3_1P4],
                sizeof(DISK_GEOMETRY));
        }
        Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
 
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_DISK_GET_LENGTH_INFO:
        //  Return disk length information
        //  (Windows XP requires this request to be handled)
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
            break;
        }
 
        if (IO_OUTPUTLEN(io_stack) < sizeof(GET_LENGTH_INFORMATION)) {
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }
 
        ((PGET_LENGTH_INFORMATION)Irp->AssociatedIrp.SystemBuffer)->Length.QuadPart =
            VFD_SECTOR_TO_BYTE(device_extension->Sectors);
 
        Irp->IoStatus.Information = sizeof(GET_LENGTH_INFORMATION);
 
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_DISK_IS_WRITABLE:
        //  Checks if current media is writable
 
        if (!device_extension->FileHandle &&
            !device_extension->FileBuffer) {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else if (device_extension->MediaFlags & VFD_FLAG_WRITE_PROTECTED) {
            status = STATUS_MEDIA_WRITE_PROTECTED;
        }
        else {
            status = STATUS_SUCCESS;
        }
        break;
 
/*
    case IOCTL_DISK_MEDIA_REMOVAL:
    case IOCTL_STORAGE_MEDIA_REMOVAL:
        //  Since removal lock is irrelevant for virtual disks,
        //  there's really nothing to do here...
 
        status = STATUS_SUCCESS;
        break;
 
    case IOCTL_STORAGE_GET_HOTPLUG_INFO:
        {
            PSTORAGE_HOTPLUG_INFO hotplug;
 
            if (IO_OUTPUTLEN(io_stack) < sizeof(STORAGE_HOTPLUG_INFO)) {
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            hotplug = (PSTORAGE_HOTPLUG_INFO)Irp->AssociatedIrp.SystemBuffer;
 
            RtlZeroMemory(hotplug, sizeof(STORAGE_HOTPLUG_INFO));
 
            hotplug->Size = sizeof(STORAGE_HOTPLUG_INFO);
            hotplug->MediaRemovable = 1;
 
            Irp->IoStatus.Information = sizeof(STORAGE_HOTPLUG_INFO);
            status = STATUS_SUCCESS;
        }
        break;
*/
 
#ifdef VFD_MOUNT_MANAGER
    //
    //  IO control requests received from the mount manager
    //  (on Windows 2000 / XP)
    //
 
    case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:
        //  Returns a unique ID for the target device
        status = VfdMountDevUniqueId(
            device_extension,
            Irp->AssociatedIrp.SystemBuffer,
            IO_OUTPUTLEN(io_stack),
            &Irp->IoStatus);
        break;
 
//  case IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY:
 
    case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:
        //  Returns the device name of the target device
        status = VfdMountDevDeviceName(
            device_extension,
            Irp->AssociatedIrp.SystemBuffer,
            IO_OUTPUTLEN(io_stack),
            &Irp->IoStatus);
        break;
 
    case 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.
        status = VfdMountDevSuggestedLink(
            device_extension,
            Irp->AssociatedIrp.SystemBuffer,
            IO_OUTPUTLEN(io_stack),
            &Irp->IoStatus);
        break;
 
    case IOCTL_MOUNTDEV_LINK_CREATED:
    case IOCTL_MOUNTDEV_LINK_DELETED:
        //  Issued after the mount manager created/deleted a symbolic link
        status = VfdMountDevLinkModified(
            device_extension,
            Irp->AssociatedIrp.SystemBuffer,
            IO_INPUTLEN(io_stack),
            IO_CTRLCODE(io_stack));
        break;
 
/*
    case IOCTL_MOUNTDEV_QUERY_STABLE_GUID:
        {
            PMOUNTDEV_STABLE_GUID guid;
 
            if (IO_OUTPUTLEN(io_stack) < sizeof(MOUNTDEV_STABLE_GUID)) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            guid = Irp->AssociatedIrp.SystemBuffer;
 
            RtlCopyMemory(
                &guid->StableGuid, &VFD_GUID, sizeof(GUID));
 
            Irp->IoStatus.Information = sizeof(guid);
            status = STATUS_SUCCESS;
        }
        break;
*/
#endif  //  VFD_MOUNT_MANAGER
 
    default:
        //  Unknown IOCTL request
        status = STATUS_INVALID_DEVICE_REQUEST;
        break;
    }
 
#if DBG
    if ((NT_SUCCESS(status) && (TraceFlags & VFDINFO) == VFDINFO) ||
        (TraceFlags & VFDWARN) == VFDWARN) {
        VFDTRACE(0,("[VFD] %-40s - %s\n",
            GetIoControlName(IO_CTRLCODE(io_stack)),
            GetStatusName(status)));
    }
#endif
 
    if (status == STATUS_PENDING) {
        //  Let the device thread perform the operation
 
        IoMarkIrpPending(Irp);
 
        ExInterlockedInsertTailList(
            &device_extension->ListHead,
            &Irp->Tail.Overlay.ListEntry,
            &device_extension->ListLock);
 
        KeSetEvent(
            &device_extension->RequestEvent,
            (KPRIORITY) 0,
            FALSE);
    }
    else {
        //  complete the operation
 
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
#ifdef VFD_PNP
        IoReleaseRemoveLock(&device_extension->RemoveLock, Irp);
#endif  // VFD_PNP
    }
 
    return status;
}

Referenced by DriverEntry().

VfdDeviceThread()

VOID NTAPI VfdDeviceThread

(

IN PVOID

ThreadContext

)

Definition at line 404 of file vfddrv.c.

{
    PDEVICE_OBJECT              device_object;
    PDEVICE_EXTENSION           device_extension;
    PLIST_ENTRY                 request;
    PIRP                        irp;
    PIO_STACK_LOCATION          io_stack;
 
    ASSERT(ThreadContext != NULL);
 
    device_object = (PDEVICE_OBJECT)ThreadContext;
 
    device_extension = (PDEVICE_EXTENSION)device_object->DeviceExtension;
 
    KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);
 
    for (;;) {
        //  wait for the request event to be signalled
        KeWaitForSingleObject(
            &device_extension->RequestEvent,
            Executive,
            KernelMode,
            FALSE,
            NULL);
 
        //  terminate request ?
        if (device_extension->TerminateThread) {
            VFDTRACE(0, ("[VFD] Exitting the I/O thread\n"));
            PsTerminateSystemThread(STATUS_SUCCESS);
        }
 
        //  perform requested tasks
 
        while ((request = ExInterlockedRemoveHeadList(
            &device_extension->ListHead,
            &device_extension->ListLock)) != NULL)
        {
            irp = CONTAINING_RECORD(request, IRP, Tail.Overlay.ListEntry);
 
            io_stack = IoGetCurrentIrpStackLocation(irp);
 
            irp->IoStatus.Information = 0;
 
            switch (io_stack->MajorFunction) {
            case IRP_MJ_READ:
                VfdReadData(device_extension, irp,
                    io_stack->Parameters.Read.Length,
                    &io_stack->Parameters.Read.ByteOffset);
                break;
 
            case IRP_MJ_WRITE:
                VfdWriteData(device_extension, irp,
                    io_stack->Parameters.Write.Length,
                    &io_stack->Parameters.Write.ByteOffset);
                break;
 
            case IRP_MJ_DEVICE_CONTROL:
                VfdIoCtlThread(device_extension, irp,
                    io_stack->Parameters.DeviceIoControl.IoControlCode);
                break;
 
            default:
                //  This shouldn't happen...
                VFDTRACE(0,
                    ("[VFD] %s passed to the I/O thread\n",
                    GetMajorFuncName(io_stack->MajorFunction)));
 
                irp->IoStatus.Status = STATUS_DRIVER_INTERNAL_ERROR;
            }
 
            IoCompleteRequest(irp,
                (CCHAR)(NT_SUCCESS(irp->IoStatus.Status) ?
                    IO_DISK_INCREMENT : IO_NO_INCREMENT));
 
#ifdef VFD_PNP
            IoReleaseRemoveLock(&device_extension->RemoveLock, irp);
#endif  // VFD_PNP
        } // while
    } // for (;;)
}

Referenced by VfdCreateDevice().

VfdFormatCheck()

NTSTATUS VfdFormatCheck	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PFORMAT_PARAMETERS	FormatParams,
		IN ULONG	InputLength,
		IN ULONG	ControlCode
	)

Referenced by VfdDeviceControl().

VfdFormatTrack()

NTSTATUS VfdFormatTrack	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PFORMAT_PARAMETERS	FormatParams
	)

Definition at line 153 of file vfdfmt.c.

{
    const DISK_GEOMETRY         *geometry;
    ULONG                       track_length;
    PUCHAR                      format_buffer;
    LARGE_INTEGER               start_offset;
    LARGE_INTEGER               end_offset;
    NTSTATUS                    status;
 
    VFDTRACE(0, ("[VFD] VfdFormatTrack - IN\n"));
 
    ASSERT(DeviceExtension != NULL);
 
    geometry = DeviceExtension->Geometry;
 
    if (!geometry) {
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
 
    track_length = geometry->BytesPerSector * geometry->SectorsPerTrack;
 
    format_buffer = (PUCHAR)ExAllocatePoolWithTag(
        PagedPool, track_length, VFD_POOL_TAG);
 
    if (format_buffer == NULL) {
        VFDTRACE(0, ("[VFD] cannot allocate a format buffer\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlFillMemory(format_buffer, track_length, VFD_FORMAT_FILL_DATA);
 
    start_offset.QuadPart =
        FormatParams->StartCylinderNumber * geometry->TracksPerCylinder * track_length +
        FormatParams->StartHeadNumber * track_length;
 
    end_offset.QuadPart =
        FormatParams->EndCylinderNumber * geometry->TracksPerCylinder * track_length +
        FormatParams->EndHeadNumber * track_length;
 
    do {
        if (DeviceExtension->FileHandle) {
            IO_STATUS_BLOCK io_status;
 
            status = ZwWriteFile(
                DeviceExtension->FileHandle,
                NULL,
                NULL,
                NULL,
                &io_status,
                format_buffer,
                track_length,
                &start_offset,
                NULL);
 
            if (!NT_SUCCESS(status)) {
                VFDTRACE(0, ("[VFD] ZwWriteFile - %s\n",
                    GetStatusName(status)));
                break;
            }
        }
        else {
            RtlMoveMemory(
                DeviceExtension->FileBuffer + start_offset.QuadPart,
                format_buffer,
                track_length);
 
            status = STATUS_SUCCESS;
        }
 
        start_offset.QuadPart += track_length;
    }
    while (start_offset.QuadPart <= end_offset.QuadPart);
 
    ExFreePool(format_buffer);
 
    VFDTRACE(0, ("[VFD] VfdFormatTrack - OUT\n"));
 
    return status;
}

Referenced by VfdIoCtlThread().

VfdFreeUnicode()

VOID VfdFreeUnicode

(

IN OUT PUNICODE_STRING

str

)

VfdIoCtlThread()

VOID VfdIoCtlThread	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PIRP	Irp,
		IN ULONG	ControlCode
	)

Definition at line 542 of file vfdioctl.c.

{
    switch (ControlCode) {
    case IOCTL_VFD_OPEN_IMAGE:
        //  open the file from the caller's security context
        //  -- this allows this driver to open network files
        if (DeviceExtension->SecurityContext) {
            SeImpersonateClient(DeviceExtension->SecurityContext, NULL);
        }
 
        Irp->IoStatus.Status = VfdOpenImage(DeviceExtension,
            (PVFD_IMAGE_INFO)Irp->AssociatedIrp.SystemBuffer);
 
        PsRevertToSelf();
        break;
 
    case IOCTL_VFD_CLOSE_IMAGE:
    case IOCTL_DISK_EJECT_MEDIA:
    case IOCTL_STORAGE_EJECT_MEDIA:
        VfdCloseImage(DeviceExtension);
        Irp->IoStatus.Status = STATUS_SUCCESS;
        break;
 
    case IOCTL_DISK_FORMAT_TRACKS:
    case IOCTL_DISK_FORMAT_TRACKS_EX:
        Irp->IoStatus.Status = VfdFormatTrack(DeviceExtension,
            (PFORMAT_PARAMETERS)Irp->AssociatedIrp.SystemBuffer);
        break;
 
    default:
        //  This shouldn't happen...
        VFDTRACE(0,
            ("[VFD] %s passed to the device thread\n",
            GetIoControlName(ControlCode)));
 
        Irp->IoStatus.Status = STATUS_DRIVER_INTERNAL_ERROR;
    }
 
#if DBG
    if ((NT_SUCCESS(Irp->IoStatus.Status) && (TraceFlags & VFDINFO) == VFDINFO) ||
        (TraceFlags & VFDWARN) == VFDWARN) {
        VFDTRACE(0,("[VFD] %-40s - %s\n",
            GetIoControlName(ControlCode),
            GetStatusName(Irp->IoStatus.Status)));
    }
#endif
}

Referenced by VfdDeviceThread().

VfdLoadLink()

NTSTATUS VfdLoadLink	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PWSTR	RegistryPath
	)

Definition at line 135 of file vfdlink.c.

{
    RTL_QUERY_REGISTRY_TABLE    params[2];
    WCHAR                       name_buf[20];
    ULONG                       letter;
    ULONG                       zero    = 0;
    NTSTATUS                    status;
 
    VFDTRACE(VFDINFO, ("[VFD] VfdLoadLink - IN\n"));
 
    RtlZeroMemory(params, sizeof(params));
 
#ifndef __REACTOS__
    name_buf[sizeof(name_buf) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buf, sizeof(name_buf) - 1,
        VFD_REG_DRIVE_LETTER L"%lu",
        DeviceExtension->DeviceNumber);
#else
    name_buf[ARRAYSIZE(name_buf) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buf, ARRAYSIZE(name_buf) - 1,
        VFD_REG_DRIVE_LETTER L"%lu",
        DeviceExtension->DeviceNumber);
#endif
 
    params[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    params[0].Name          = name_buf;
    params[0].EntryContext  = &letter;
    params[0].DefaultType   = REG_DWORD;
    params[0].DefaultData   = &zero;
    params[0].DefaultLength = sizeof(ULONG);
 
    status = RtlQueryRegistryValues(
        RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
        RegistryPath, &params[0], NULL, NULL);
 
    VFDTRACE(VFDINFO,
        ("[VFD] Drive letter '%wc' loaded from the registry\n",
        letter ? letter : ' '));
 
    DeviceExtension->DriveLetter = (CHAR)letter;
 
    VFDTRACE(VFDINFO,
        ("[VFD] VfdLoadLink - %s\n", GetStatusName(status)));
 
    return status;
}

Referenced by VfdCreateDevice().

VfdOpenCheck()

NTSTATUS VfdOpenCheck	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PVFD_IMAGE_INFO	ImageInfo,
		IN ULONG	InputLength
	)

Referenced by VfdDeviceControl().

VfdOpenImage()

NTSTATUS VfdOpenImage	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PVFD_IMAGE_INFO	ImageInfo
	)

Definition at line 104 of file vfdimg.c.

{
    IO_STATUS_BLOCK             io_status;
    NTSTATUS                    status  = STATUS_SUCCESS;
    const DISK_GEOMETRY         *geometry;
    ULONG                       sectors;
    ULONG                       alignment;
 
    VFDTRACE(0, ("[VFD] VfdOpenImage - IN\n"));
 
    //
    //  Store file name in the device extension
    //
    if (ImageInfo->NameLength) {
 
        if (ImageInfo->NameLength + 1 >
            DeviceExtension->FileName.MaximumLength) {
 
            //  expand the filename buffer
 
            if (DeviceExtension->FileName.Buffer) {
                ExFreePool(DeviceExtension->FileName.Buffer);
                RtlZeroMemory(
                    &DeviceExtension->FileName,
                    sizeof(ANSI_STRING));
            }
 
            DeviceExtension->FileName.Buffer = (PCHAR)ExAllocatePoolWithTag(
                NonPagedPool, ImageInfo->NameLength + 1, VFD_POOL_TAG);
 
            if (!DeviceExtension->FileName.Buffer) {
                VFDTRACE(0, ("[VFD] Can't allocate memory for image path\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            DeviceExtension->FileName.MaximumLength
                = (USHORT)(ImageInfo->NameLength + 1);
 
            RtlZeroMemory(
                DeviceExtension->FileName.Buffer,
                DeviceExtension->FileName.MaximumLength);
        }
 
        if (DeviceExtension->FileName.Buffer) {
            RtlCopyMemory(
                DeviceExtension->FileName.Buffer,
                ImageInfo->FileName,
                ImageInfo->NameLength);
 
            DeviceExtension->FileName.Buffer[ImageInfo->NameLength] = '\0';
        }
    }
 
    DeviceExtension->FileName.Length = ImageInfo->NameLength;
 
    //
    //  Get DISK_GEOMETRY and calculate the media capacity
    //  -- validity of the ImageInfo->MediaType value is assured in
    //  the VfdOpenCheck function
    //
    geometry = &geom_tbl[ImageInfo->MediaType];
 
    sectors =
        geometry->Cylinders.LowPart *
        geometry->TracksPerCylinder *
        geometry->SectorsPerTrack;
 
    if (ImageInfo->ImageSize != 0 &&
        ImageInfo->ImageSize < VFD_SECTOR_TO_BYTE(sectors)) {
 
            VFDTRACE(0, ("[VFD] Image is smaller than the media\n"));
            return STATUS_INVALID_PARAMETER;
    }
 
    //
    //  Prepare a virtual media according to the ImageInfo
    //
    if (ImageInfo->DiskType == VFD_DISKTYPE_FILE) {
        //
        //  open an existing image file
        //
        HANDLE                      file_handle;
        OBJECT_ATTRIBUTES           attributes;
        UNICODE_STRING              unicode_name;
        FILE_STANDARD_INFORMATION   file_standard;
        FILE_BASIC_INFORMATION      file_basic;
        FILE_ALIGNMENT_INFORMATION  file_alignment;
        PFILE_OBJECT                file_object;
        BOOLEAN                     network_drive;
 
        //  convert the filename into a unicode string
 
        status = RtlAnsiStringToUnicodeString(
            &unicode_name, &DeviceExtension->FileName, TRUE);
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(0, ("[VFD] Failed to convert filename to UNICODE\n"));
            return status;
        }
 
        VFDTRACE(VFDINFO,
            ("[VFD] Opening %s\n", DeviceExtension->FileName.Buffer));
 
        //  prepare an object attribute to open
 
        InitializeObjectAttributes(
            &attributes,
            &unicode_name,
            OBJ_CASE_INSENSITIVE,
            NULL,
            NULL);
 
        //  open the target file
 
        status = ZwCreateFile(
            &file_handle,
            GENERIC_READ | GENERIC_WRITE,
            &attributes,
            &io_status,
            NULL,
            FILE_ATTRIBUTE_NORMAL,
            0,
            FILE_OPEN,
            FILE_NON_DIRECTORY_FILE |
            FILE_RANDOM_ACCESS |
            FILE_NO_INTERMEDIATE_BUFFERING |
            FILE_SYNCHRONOUS_IO_NONALERT,
            NULL,
            0);
 
        RtlFreeUnicodeString(&unicode_name);
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(0, ("[VFD] ZwCreateFile - %s\n",
                GetStatusName(status)));
            return status;
        }
 
        //  Check the file size
 
        status = ZwQueryInformationFile(
            file_handle,
            &io_status,
            &file_standard,
            sizeof(FILE_STANDARD_INFORMATION),
            FileStandardInformation);
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(0,
                ("[VFD] ZwQueryInformationFile - FILE_STANDARD_INFORMATION\n"));
 
            ZwClose(file_handle);
            goto exit_func;
        }
 
        //  Actual file size can be larger than the media capacity
 
        if (file_standard.EndOfFile.QuadPart < VFD_SECTOR_TO_BYTE(sectors)) {
 
            VFDTRACE(0, ("[VFD] file is smaller than the media.\n"));
 
            status = STATUS_INVALID_PARAMETER;
 
            ZwClose(file_handle);
            goto exit_func;
        }
 
        DeviceExtension->ImageSize = file_standard.EndOfFile.LowPart;
 
        // Find out whether the file is on a local disk or a network drive
 
        network_drive = FALSE;
 
        status = ObReferenceObjectByHandle(
            file_handle,
            GENERIC_READ,
            NULL,
            KernelMode,
#ifndef __REACTOS__
            &file_object,
#else
            (PVOID *)&file_object,
#endif
            NULL);
 
        if (NT_SUCCESS(status)) {
            if (file_object && file_object->DeviceObject) {
                VFDTRACE(VFDINFO, ("[VFD] Device type is 0x%08x\n",
                    file_object->DeviceObject->DeviceType));
 
                if (file_object->DeviceObject->DeviceType
                    == FILE_DEVICE_NETWORK_FILE_SYSTEM) {
                    network_drive = TRUE;
                }
 
                // how about these types ?
                // FILE_DEVICE_NETWORK
                // FILE_DEVICE_NETWORK_BROWSER
                // FILE_DEVICE_NETWORK_REDIRECTOR
            }
            else {
                VFDTRACE(VFDWARN, ("[VFD Cannot decide the device type\n"));
            }
            ObDereferenceObject(file_object);
        }
        else {
            VFDTRACE(0, ("[VFD] ObReferenceObjectByHandle - %s\n",
                GetStatusName(status)));
        }
 
        if (!network_drive) {
            // The NT cache manager can deadlock if a filesystem that is using
            // the cache manager is used in a virtual disk that stores its file
            // on a file systemthat is also using the cache manager, this is
            // why we open the file with FILE_NO_INTERMEDIATE_BUFFERING above,
            // however if the file is compressed or encrypted NT will not honor
            // this request and cache it anyway since it need to store the
            // decompressed/unencrypted data somewhere, therefor we put an
            // extra check here and don't alow disk images to be compressed/
            // encrypted.
 
            status = ZwQueryInformationFile(
                file_handle,
                &io_status,
                &file_basic,
                sizeof(FILE_BASIC_INFORMATION),
                FileBasicInformation);
 
            if (!NT_SUCCESS(status)) {
                VFDTRACE(0,
                    ("[VFD] ZwQueryInformationFile - FILE_BASIC_INFORMATION\n"));
 
                ZwClose(file_handle);
                goto exit_func;
            }
 
            if (file_basic.FileAttributes
                & (FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))
            {
                VFDTRACE(0,
                    ("[VFD] Image file is compressed and/or encrypted\n"));
 
                status =  STATUS_ACCESS_DENIED;
 
                ZwClose(file_handle);
                goto exit_func;
            }
        }
 
        //  Retrieve the file alignment requirement
 
        status = ZwQueryInformationFile(
            file_handle,
            &io_status,
            &file_alignment,
            sizeof(FILE_ALIGNMENT_INFORMATION),
            FileAlignmentInformation);
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(0,
                ("[VFD] ZwQueryInformationFile - FILE_ALIGNMENT_INFORMATION\n"));
 
            ZwClose(file_handle);
            goto exit_func;
        }
 
        DeviceExtension->FileHandle = file_handle;
 
        alignment = file_alignment.AlignmentRequirement;
 
        VFDTRACE(0, ("[VFD] Opened an image file\n"));
    }
    else {
        //
        //  Create an empty RAM disk
        //
        DeviceExtension->FileBuffer = (PUCHAR)ExAllocatePoolWithTag(
            NonPagedPool,
            VFD_SECTOR_TO_BYTE(sectors),
            VFD_POOL_TAG);
 
        if (!DeviceExtension->FileBuffer) {
            VFDTRACE(0, ("[VFD] Can't allocate memory for RAM disk\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlZeroMemory(
            DeviceExtension->FileBuffer,
            VFD_SECTOR_TO_BYTE(sectors));
 
        if (ImageInfo->ImageSize) {
            DeviceExtension->ImageSize = ImageInfo->ImageSize;
        }
        else {
            DeviceExtension->ImageSize = VFD_SECTOR_TO_BYTE(sectors);
        }
 
        alignment = FILE_WORD_ALIGNMENT;
 
        VFDTRACE(0, ("[VFD] Created an empty RAM disk\n"));
    }
 
    DeviceExtension->MediaChangeCount++;
 
    DeviceExtension->MediaType  = ImageInfo->MediaType;
    DeviceExtension->MediaFlags = ImageInfo->MediaFlags;
    DeviceExtension->FileType   = ImageInfo->FileType;
    DeviceExtension->Geometry   = geometry;
    DeviceExtension->Sectors    = sectors;
 
    VFDTRACE(0, ("[VFD] Media:%d Flag:0x%02x Size:%lu Capacity:%lu\n",
        DeviceExtension->MediaType,
        DeviceExtension->MediaFlags,
        DeviceExtension->ImageSize,
        DeviceExtension->Sectors));
 
    DeviceExtension->DeviceObject->AlignmentRequirement
        = alignment;
 
exit_func:
    VFDTRACE(0, ("[VFD] VfdOpenImage - %s\n", GetStatusName(status)));
 
    return status;
}

Referenced by CVfdShExt::DoVfdDrop(), OnOK(), Open(), and VfdIoCtlThread().

VfdQueryImage()

NTSTATUS VfdQueryImage	(	IN PDEVICE_EXTENSION	DeviceExtension,
		OUT PVFD_IMAGE_INFO	ImageInfo,
		IN ULONG	BufferLength,
		OUT PULONG	ReturnLength
	)

Definition at line 466 of file vfdimg.c.

{
    //  Check output buffer length
 
    if (BufferLength < sizeof(VFD_IMAGE_INFO)) {
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    RtlZeroMemory(ImageInfo, BufferLength);
 
    //  Store fixed length image information
 
    ImageInfo->MediaType    = DeviceExtension->MediaType;
 
    if (DeviceExtension->MediaType == VFD_MEDIA_NONE) {
        *ReturnLength = sizeof(VFD_IMAGE_INFO);
        return STATUS_SUCCESS;
    }
 
    if (DeviceExtension->FileBuffer) {
        ImageInfo->DiskType = VFD_DISKTYPE_RAM;
    }
    else {
        ImageInfo->DiskType = VFD_DISKTYPE_FILE;
    }
 
    ImageInfo->MediaFlags   = DeviceExtension->MediaFlags;
    ImageInfo->FileType     = DeviceExtension->FileType;
    ImageInfo->ImageSize    = DeviceExtension->ImageSize;
 
    ImageInfo->NameLength   = DeviceExtension->FileName.Length;
 
    //  output buffer is large enough to hold the file name?
 
    if (BufferLength < sizeof(VFD_IMAGE_INFO) +
        DeviceExtension->FileName.Length)
    {
        *ReturnLength = sizeof(VFD_IMAGE_INFO);
        return STATUS_BUFFER_OVERFLOW;
    }
 
    //  copy file name
 
    if (DeviceExtension->FileName.Length &&
        DeviceExtension->FileName.Buffer) {
 
        RtlCopyMemory(ImageInfo->FileName,
            DeviceExtension->FileName.Buffer,
            DeviceExtension->FileName.Length);
    }
 
    //  store the actually returned data length
 
    *ReturnLength = sizeof(VFD_IMAGE_INFO) +
        DeviceExtension->FileName.Length;
 
    return STATUS_SUCCESS;
}

Referenced by VfdDeviceControl().

VfdReadData()

VOID VfdReadData	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN OUT PIRP	Irp,
		IN ULONG	Length,
		IN PLARGE_INTEGER	Offset
	)

Definition at line 217 of file vfdrdwr.c.

{
    PVOID buf;
 
    VFDTRACE(VFDINFO,("[VFD] VfdReadData - IN\n"));
 
    buf = MmGetSystemAddressForMdlPrettySafe(
        Irp->MdlAddress, NormalPagePriority);
 
    if (!buf) {
        VFDTRACE(0,
            ("[VFD] MmGetSystemAddressForMdlPrettySafe\n"));
 
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        return;
    }
 
    if (DeviceExtension->FileHandle) {
 
        //  Read from image file
        Irp->IoStatus.Status = ZwReadFile(
            DeviceExtension->FileHandle,
            NULL,
            NULL,
            NULL,
            &Irp->IoStatus,
            buf,
            Length,
            Offset,
            NULL);
 
        if (NT_SUCCESS(Irp->IoStatus.Status)) {
            Irp->IoStatus.Information = Length;
        }
        else {
            VFDTRACE(0,
                ("[VFD] ZwReadFile - %s\n",
                GetStatusName(Irp->IoStatus.Status)));
        }
    }
    else if (DeviceExtension->FileBuffer) {
 
        //  Copy from RAM disk buffer
        RtlMoveMemory(
            buf,
            DeviceExtension->FileBuffer + Offset->QuadPart,
            Length);
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = Length;
    }
    else {
        //  no image opened
        Irp->IoStatus.Status = STATUS_NO_MEDIA_IN_DEVICE;
    }
 
    VFDTRACE(VFDINFO,("[VFD] VfdReadData - %s\n",
        GetStatusName(Irp->IoStatus.Status)));
 
    return;
}

Referenced by VfdDeviceThread().

VfdReadWrite()

NTSTATUS NTAPI VfdReadWrite	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 24 of file vfdrdwr.c.

{
    PDEVICE_EXTENSION           device_extension;
    PIO_STACK_LOCATION          io_stack;
    NTSTATUS                    status;
 
    device_extension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    io_stack = IoGetCurrentIrpStackLocation(Irp);
 
#if DBG
    if (DeviceObject && DeviceObject->DeviceExtension &&
        ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer) {
 
        VFDTRACE(VFDINFO, ("[VFD] %-40s %ws\n",
            GetMajorFuncName(io_stack->MajorFunction),
            ((PDEVICE_EXTENSION)DeviceObject->DeviceExtension)->DeviceName.Buffer));
    }
    else {
        VFDTRACE(VFDINFO, ("[VFD] %-40s %p\n",
            GetMajorFuncName(io_stack->MajorFunction),
            DeviceObject));
    }
#endif  // DBG
 
#ifdef VFD_PNP
 
    if (device_extension->DeviceState != VFD_WORKING) {
 
        // Device is not yet started or being removed, reject any IO request
        // TODO: Queue the IRPs
 
        VFDTRACE(VFDWARN, ("[VFD] Device not ready\n"));
 
        status = STATUS_INVALID_DEVICE_STATE;
        goto complete_request;
    }
    else {
        status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
 
        if (!NT_SUCCESS(status)) {
            VFDTRACE(0, ("[VFD] Acquire RemoveLock failed: %s\n", GetStatusName(status)));
 
            goto complete_request;
        }
    }
#endif  // VFD_PNP
 
/*
    //  Check if volume verification is required
 
    if ((DeviceObject->Flags & DO_VERIFY_VOLUME) &&
        !(io_stack->Flags & SL_OVERRIDE_VERIFY_VOLUME)) {
 
        status = STATUS_VERIFY_REQUIRED;
        goto complete_request;
    }
*/
 
    //  Check if an image is opened
 
    if (!device_extension->FileHandle &&
        !device_extension->FileBuffer)  {
 
        status = STATUS_NO_MEDIA_IN_DEVICE;
        goto complete_request;
    }
 
 
    // Check if write operation is allowed
 
    if (io_stack->MajorFunction == IRP_MJ_WRITE &&
        (device_extension->MediaFlags & VFD_FLAG_WRITE_PROTECTED)) {
 
        status = STATUS_MEDIA_WRITE_PROTECTED;
        goto complete_request;
    }
 
 
    // Check for invalid parameters.  It is an error for the starting offset
    // + length to go past the end of the partition, or for the length or
    // offset to not be a proper multiple of the sector size.
    //
    // Others are possible, but we don't check them since we trust the
    // file system and they aren't deadly.
 
    if ((IO_READ_OFF(io_stack) + IO_READ_LEN(io_stack)) >
        VFD_SECTOR_TO_BYTE(device_extension->Sectors)) {
 
        VFDTRACE(VFDWARN,
            ("[VFD] Offset:%I64u + Length:%u goes past the media size %lu\n",
            IO_READ_OFF(io_stack), IO_READ_LEN(io_stack),
            VFD_SECTOR_TO_BYTE(device_extension->Sectors)));
 
        status = STATUS_INVALID_PARAMETER;
        goto complete_request;
    }
 
    if (!VFD_SECTOR_ALIGNED((IO_READ_LEN(io_stack))) ||
        !VFD_SECTOR_ALIGNED((IO_READ_OFF(io_stack)))) {
 
        VFDTRACE(VFDWARN,
            ("[VFD] Invalid Alignment Offset:%I64u Length:%u\n",
            IO_READ_OFF(io_stack), IO_READ_LEN(io_stack)));
 
        status = STATUS_INVALID_PARAMETER;
        goto complete_request;
    }
 
    //  If read/write data length is 0, we are done
 
    if (IO_READ_LEN(io_stack) == 0) {
        status = STATUS_SUCCESS;
        goto complete_request;
    }
 
    //  It seems that actual read/write operation is going to take place
    //  so mark the IRP as pending, insert the IRP into queue list
    //  then signal the device thread to perform the operation
 
    IoMarkIrpPending(Irp);
 
    ExInterlockedInsertTailList(
        &device_extension->ListHead,
        &Irp->Tail.Overlay.ListEntry,
        &device_extension->ListLock);
 
    KeSetEvent(
        &device_extension->RequestEvent,
        (KPRIORITY) 0,
        FALSE);
 
    VFDTRACE(VFDINFO,("[VFD] %-40s - STATUS_PENDING\n",
        GetMajorFuncName(io_stack->MajorFunction)));
 
    return STATUS_PENDING;
 
complete_request:
 
    //  complete the request immediately
 
    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    VFDTRACE(VFDWARN,("[VFD] %-40s - %s\n",
        GetMajorFuncName(io_stack->MajorFunction),
        GetStatusName(status)));
 
    return status;
}

Referenced by DriverEntry().

VfdSetLink()

NTSTATUS VfdSetLink	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN CHAR	DriveLetter
	)

Definition at line 24 of file vfdlink.c.

{
    UNICODE_STRING              unicode_name;
    WCHAR                       name_buf[15];
    NTSTATUS                    status = STATUS_SUCCESS;
 
    VFDTRACE(VFDINFO, ("[VFD] VfdSetLink - IN\n"));
 
    //  convert lower case into upper case
 
    if (DriveLetter >= 'a' && DriveLetter <= 'z') {
        DriveLetter -= ('a' - 'A');
    }
 
    //  check the drive letter range
 
    if (DriveLetter != 0 &&
        (DriveLetter < 'A' || DriveLetter > 'Z')) {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (DeviceExtension->DriveLetter &&
        DeviceExtension->DriveLetter != DriveLetter) {
        //
        //  Delete the old drive letter
        //
#ifndef __REACTOS__
        name_buf[sizeof(name_buf) - 1] = UNICODE_NULL;
#else
        name_buf[ARRAYSIZE(name_buf) - 1] = UNICODE_NULL;
#endif
 
        _snwprintf(name_buf, sizeof(name_buf) - 1,
            L"\\??\\%wc:", DeviceExtension->DriveLetter);
 
        RtlInitUnicodeString(&unicode_name, name_buf);
 
        status = IoDeleteSymbolicLink(&unicode_name);
 
        if (NT_SUCCESS(status)) {
            VFDTRACE(VFDINFO,
                ("[VFD] Link %ws deleted\n", name_buf));
 
            DeviceExtension->DriveLetter = 0;
        }
        else if (status != STATUS_OBJECT_NAME_NOT_FOUND) {
            //  the driver letter did not exist in the first place
 
            VFDTRACE(VFDINFO,
                ("[VFD] Link %ws not found\n", name_buf));
 
            DeviceExtension->DriveLetter = 0;
            status = STATUS_SUCCESS;
        }
        else {
            VFDTRACE(VFDWARN,
                ("[VFD] IoDeleteSymbolicLink %ws - %s\n",
                name_buf, GetStatusName(status)));
        }
    }
 
    if (NT_SUCCESS(status) && DriveLetter) {
        //
        //  Create a new drive letter
        //
 
#ifndef __REACTOS__
        name_buf[sizeof(name_buf) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buf, sizeof(name_buf) - 1,
            (OsMajorVersion >= 5) ?
            L"\\??\\Global\\%wc:" : L"\\??\\%wc:",
            DriveLetter);
#else
        name_buf[ARRAYSIZE(name_buf) - 1] = UNICODE_NULL;
 
        _snwprintf(name_buf, ARRAYSIZE(name_buf) - 1,
            (OsMajorVersion >= 5) ?
            L"\\??\\Global\\%wc:" : L"\\??\\%wc:",
            DriveLetter);
#endif
 
        RtlInitUnicodeString(&unicode_name, name_buf);
 
        status = IoCreateSymbolicLink(
            &unicode_name, &(DeviceExtension->DeviceName));
 
        if (NT_SUCCESS(status)) {
            VFDTRACE(VFDINFO, ("[VFD] Link %ws created\n", name_buf));
 
            DeviceExtension->DriveLetter = DriveLetter;
        }
        else {
            VFDTRACE(VFDWARN,
                ("[VFD] IoCreateSymbolicLink %ws - %s\n",
                name_buf, GetStatusName(status)));
        }
    }
 
    VFDTRACE(VFDINFO,
        ("[VFD] VfdSetLink - %s\n", GetStatusName(status)));
 
    return status;
}

Referenced by VfdDeleteDevice(), VfdDeviceControl(), and VfdReinitialize().

VfdStoreLink()

NTSTATUS VfdStoreLink

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 190 of file vfdlink.c.

{
    PVFD_DRIVER_EXTENSION       driver_extension;
    WCHAR                       name_buf[20];
    ULONG                       letter;
    NTSTATUS                    status;
 
    VFDTRACE(VFDINFO, ("[VFD] VfdStoreLink - IN\n"));
 
#ifdef VFD_PNP
    driver_extension = IoGetDriverObjectExtension(
        DeviceExtension->device_object->DriverObject,
        VFD_DRIVER_EXTENSION_ID);
#else   // VFD_PNP
    driver_extension = DeviceExtension->DriverExtension;
#endif  // VFD_PNP
 
    if (!driver_extension ||
        !driver_extension->RegistryPath.Buffer) {
 
        VFDTRACE(VFDWARN, ("[VFD] Registry Path not present.\n"));
        VFDTRACE(VFDINFO, ("[VFD] VfdStoreLinks - OUT\n"));
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
 
#ifndef __REACTOS__
    name_buf[sizeof(name_buf) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buf, sizeof(name_buf) - 1,
        VFD_REG_DRIVE_LETTER L"%lu",
        DeviceExtension->DeviceNumber);
#else
    name_buf[ARRAYSIZE(name_buf) - 1] = UNICODE_NULL;
 
    _snwprintf(name_buf, ARRAYSIZE(name_buf) - 1,
        VFD_REG_DRIVE_LETTER L"%lu",
        DeviceExtension->DeviceNumber);
#endif
 
    letter = DeviceExtension->DriveLetter;
 
    status = RtlWriteRegistryValue(
        RTL_REGISTRY_ABSOLUTE,
        driver_extension->RegistryPath.Buffer,
        name_buf,
        REG_DWORD,
        &letter,
        sizeof(ULONG));
 
    if (!NT_SUCCESS(status)) {
        VFDTRACE(VFDWARN,
            ("[VFD] RtlWriteRegistryValue - %s\n",
            GetStatusName(status)));
    }
    else {
        VFDTRACE(VFDINFO,
            ("[VFD] Drive letter '%wc' stored into the registry\n",
            letter ? letter : L' '));
    }
 
    VFDTRACE(VFDINFO,
        ("[VFD] VfdStoreLink - %s\n", GetStatusName(status)));
 
    return status;
}

Referenced by VfdDeviceControl().

VfdUnloadDriver()

VOID NTAPI VfdUnloadDriver

(

IN PDRIVER_OBJECT

DriverObject

)

Definition at line 250 of file vfddrv.c.

{
    PDEVICE_OBJECT              device_object;
    PVFD_DRIVER_EXTENSION       driver_extension;
 
    VFDTRACE(VFDINFO, ("[VFD] VfdUnloadDriver - IN\n"));
 
    device_object = DriverObject->DeviceObject;
 
#ifdef VFD_PNP
    driver_extension = IoGetDriverObjectExtension(
        DriverObject, VFD_DRIVER_EXTENSION_ID);
#else
    if (device_object && device_object->DeviceExtension) {
        driver_extension =
            ((PDEVICE_EXTENSION)(device_object->DeviceExtension))->DriverExtension;
    }
    else {
        driver_extension = NULL;
    }
#endif  // VFD_PNP
 
    //
    //  Delete all remaining device objects
    //
    while (device_object) {
 
        PDEVICE_OBJECT next_device = device_object->NextDevice;
 
        VfdDeleteDevice(device_object);
 
        device_object = next_device;
    }
 
    //
    //  Release the driver extension and the registry path buffer
    //
    if (driver_extension) {
 
        if (driver_extension->RegistryPath.Buffer) {
            VFDTRACE(0, ("[VFD] Releasing the registry path buffer\n"));
            ExFreePool(driver_extension->RegistryPath.Buffer);
        }
 
#ifndef VFD_PNP
        //  The system takes care of freeing the driver extension
        //  allocated with IoAllocateDriverObjectExtension in a PnP driver.
        VFDTRACE(0, ("[VFD] Releasing the driver extension\n"));
        ExFreePool(driver_extension);
#endif  // VFD_PNP
    }
 
    VFDTRACE(VFDINFO, ("[VFD] VfdUnloadDriver - OUT\n"));
}

Referenced by DriverEntry().

VfdWriteData()

VOID VfdWriteData	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN OUT PIRP	Irp,
		IN ULONG	Length,
		IN PLARGE_INTEGER	Offset
	)

Definition at line 287 of file vfdrdwr.c.

{
    PVOID buf;
 
    VFDTRACE(VFDINFO,("[VFD] VfdWriteData - IN\n"));
 
    buf = MmGetSystemAddressForMdlPrettySafe(
        Irp->MdlAddress, NormalPagePriority);
 
    if (!buf) {
        VFDTRACE(0,
            ("[VFD] MmGetSystemAddressForMdlPrettySafe\n"));
 
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        return;
    }
 
    if (DeviceExtension->FileHandle) {
 
        //  Write into image file
        Irp->IoStatus.Status = ZwWriteFile(
            DeviceExtension->FileHandle,
            NULL,
            NULL,
            NULL,
            &Irp->IoStatus,
            buf,
            Length,
            Offset,
            NULL);
 
        if (NT_SUCCESS(Irp->IoStatus.Status)) {
            Irp->IoStatus.Information = Length;
        }
        else {
            VFDTRACE(0,
                ("[VFD] ZwWriteFile - %s\n",
                GetStatusName(Irp->IoStatus.Status)));
        }
    }
    else if (DeviceExtension->FileBuffer) {
 
        //  Deal with the modify flag
        if (RtlCompareMemory(
            DeviceExtension->FileBuffer + Offset->QuadPart,
            buf, Length) != Length) {
            DeviceExtension->MediaFlags |= VFD_FLAG_DATA_MODIFIED;
        }
 
        //  Copy into RAM image buffer
        RtlMoveMemory(
            DeviceExtension->FileBuffer + Offset->QuadPart,
            buf, Length);
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = Length;
    }
    else {
        //  no image opened
        Irp->IoStatus.Status = STATUS_NO_MEDIA_IN_DEVICE;
    }
 
    VFDTRACE(VFDINFO,("[VFD] VfdWriteData - %s\n",
        GetStatusName(Irp->IoStatus.Status)));
 
    return;
}

Referenced by VfdDeviceThread().

Variable Documentation

geom_tbl

const DISK_GEOMETRY geom_tbl[VFD_MEDIA_MAX]

extern

Referenced by VfdCreateDevice(), VfdDeviceControl(), and VfdOpenImage().

OsBuildNumber

ULONG OsBuildNumber

extern

OsMajorVersion

ULONG OsMajorVersion

extern

OsMinorVersion

ULONG OsMinorVersion

extern