vfdctl.c

Go to the documentation of this file.

/*
    vfdctl.c
 
    Virtual Floppy Drive for Windows
    Driver control library
    Driver and image control functions
 
    Copyright (C) 2003-2005 Ken Kato
*/
 
#ifdef __cplusplus
#pragma message(__FILE__": Compiled as C++ for testing purpose.")
#endif  // __cplusplus
 
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <dbt.h>
#ifdef _MSC_VER
#pragma warning (push, 3)
#endif
#include <shlobj.h>
#include <winioctl.h>
#ifdef _MSC_VER
#pragma warning (pop)
#endif
#include <stdio.h>
 
#include "vfdtypes.h"
#include "vfdio.h"
#include "vfdapi.h"
#include "vfdlib.h"
#include "vfdver.h"
 
#ifndef IOCTL_DISK_GET_LENGTH_INFO
//  Old winioctl.h header doesn't define the following
 
#define IOCTL_DISK_GET_LENGTH_INFO          CTL_CODE(\
IOCTL_DISK_BASE, 0x0017, METHOD_BUFFERED, FILE_READ_ACCESS)
 
typedef struct _GET_LENGTH_INFORMATION {
    LARGE_INTEGER   Length;
} GET_LENGTH_INFORMATION, *PGET_LENGTH_INFORMATION;
 
#endif  // IOCTL_DISK_GET_LENGTH_INFO
 
//
//  DOS device name (\\.\VirtualFD)
//
#ifndef __REACTOS__
#define VFD_DEVICE_TEMPLATE     "\\\\.\\" VFD_DEVICE_BASENAME "%u"
#else
#define VFD_DEVICE_TEMPLATE     "\\\\.\\" VFD_DEVICE_BASENAME "%lu"
#endif
#define VFD_VOLUME_TEMPLATE     "\\\\.\\%c:"
 
#define VFD_INSTALL_DIRECTORY   "\\system32\\drivers\\"
 
#ifdef _DEBUG
#ifndef __REACTOS__
extern ULONG TraceFlags = (ULONG)-1;//0;
extern CHAR *TraceFile  = NULL;
extern ULONG TraceLine  = 0;
#else
ULONG TraceFlags = (ULONG)-1;//0;
CHAR const * TraceFile  = NULL;
ULONG TraceLine = 0;
#endif
#endif
 
//
//  broadcast a WM_DEVICECHANGE system message to inform
//  a drive letter creation / removal
//
#define VFD_LINK_CREATED    0
#define VFD_LINK_REMOVED    1
 
static void VfdBroadcastLink(
    CHAR            cLetter,
    BOOL            bRemoved)
{
    DWORD           receipients;
    DWORD           device_event;
    DEV_BROADCAST_VOLUME params;
 
    if (!isalpha(cLetter)) {
        VFDTRACE(0,
            ("VfdBroadcastLink: invalid parameter"))
        return;
    }
 
    receipients = BSM_APPLICATIONS;
 
    device_event = bRemoved ?
        DBT_DEVICEREMOVECOMPLETE : DBT_DEVICEARRIVAL;
 
    ZeroMemory(&params, sizeof(params));
 
    params.dbcv_size        = sizeof(params);
    params.dbcv_devicetype  = DBT_DEVTYP_VOLUME;
    params.dbcv_reserved    = 0;
    params.dbcv_unitmask    = (1 << (toupper(cLetter) - 'A'));
    params.dbcv_flags       = 0;
 
    if (BroadcastSystemMessage(
        BSF_NOHANG | BSF_FORCEIFHUNG | BSF_NOTIMEOUTIFNOTHUNG,
        &receipients,
        WM_DEVICECHANGE,
        device_event,
        (LPARAM)&params) <= 0) {
 
        VFDTRACE(0,
            ("VfdBroadcastLink: BroadcastSystemMessage - %s",
            SystemMessage(GetLastError())));
    }
}
 
//
//  Broadcast a VFD notify message
//
static __inline void VfdNotify(
    WPARAM          wParam,
    LPARAM          lParam)
{
    //  SendNotifyMessage causes volume locking conflict (I think)
    //  on Windows XP while closing an image with VfdWin
//  SendNotifyMessage(HWND_BROADCAST, uVfdMsg, wParam, lParam);
    PostMessage(HWND_BROADCAST, g_nNotifyMsg, wParam, lParam);
}
 
#ifdef VFD_EMBED_DRIVER
//
//  Restore the VFD driver file in the system directory
//
 
static DWORD VfdRestoreDriver(
    PCSTR           sPath)
{
#define FUNC        "VfdRestoreDriver"
    HRSRC           hRes;
    DWORD           size;
    HGLOBAL         hDrv;
    PVOID           pData;
    DWORD           result;
    HANDLE          hFile;
    DWORD           ret;
 
    //
    //  Prepare driver binary
    //
 
    // use embedded driver binary
 
#define S(s) #s
    hRes = FindResource(g_hDllModule,
        S(VFD_DRIVER_NAME_ID), S(VFD_DRIVER_TYPE_ID));
#undef S
 
    if (hRes == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": FindResource - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    size = SizeofResource(g_hDllModule, hRes);
 
    if (size == 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": SizeofResource - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    hDrv = LoadResource(g_hDllModule, hRes);
 
    if (hDrv == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LoadResource - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    pData = LockResource(hDrv);
 
    if (pData == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LockResource - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  create the driver file
 
    hFile = CreateFile(sPath, GENERIC_WRITE,
        0, NULL, OPEN_ALWAYS, 0, NULL);
 
    if (hFile == INVALID_HANDLE_VALUE) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": CreateFile(%s) - %s",
            sPath, SystemMessage(ret)));
 
        return ret;
    }
 
    if (!WriteFile(hFile, pData, size, &result, NULL) ||
        size != result) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": CreateFile - %s",
            SystemMessage(ret)));
 
        CloseHandle(hFile);
        return ret;
    }
 
    SetEndOfFile(hFile);
    CloseHandle(hFile);
 
    return ERROR_SUCCESS;
}
#endif  // VFD_EMBED_DRIVER
 
//
//  Install the Virtual Floppy Driver
//
DWORD WINAPI VfdInstallDriver(
    PCSTR           sFileName,
    DWORD           nStart)
{
#undef  FUNC
#define FUNC        "VfdInstallDriver"
    SC_HANDLE       hScManager;             // Service Control Manager
    SC_HANDLE       hService = NULL;        // Service (= Driver)
#ifndef VFD_EMBED_DRIVER
    CHAR            file_path[MAX_PATH];
    PSTR            file_name;
#endif  //  VFD_EMBED_DRIVER
    CHAR            system_dir[MAX_PATH];
    PSTR            inst_path;
    DWORD           len;
    DWORD           ret = ERROR_SUCCESS;
 
#ifdef __REACTOS__
    CHAR            full_file_path[MAX_PATH];
#endif
 
    //  get SystemRoot directory path
 
//  len = GetEnvironmentVariable(
//      "SystemRoot", system_dir, sizeof(system_dir));
    len = GetWindowsDirectory(system_dir, sizeof(system_dir));
 
    if (len == 0 || len > sizeof(system_dir)) {
        VFDTRACE(0,
            (FUNC ": %%SystemRoot%% is empty or too long.\n"));
 
        return ERROR_BAD_ENVIRONMENT;
    }
 
    inst_path = &system_dir[len];
 
#ifdef __REACTOS__
    strcpy(full_file_path, system_dir);
    strcat(full_file_path, VFD_INSTALL_DIRECTORY);
    strcat(full_file_path, VFD_DRIVER_FILENAME);
#endif
 
#ifdef VFD_EMBED_DRIVER
    //
    //  use embedded driver file
    //
    strcpy(inst_path++, VFD_INSTALL_DIRECTORY VFD_DRIVER_FILENAME);
 
    ret = VfdRestoreDriver(system_dir);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
#else   // VFD_EMBED_DRIVER
    //  Prepare driver binary's full path
 
    if (sFileName == NULL || *sFileName == '\0') {
 
        // default driver file is vfd.sys in the same directory as executable
 
        len = GetModuleFileName(
            NULL, file_path, sizeof(file_path));
 
        if (len == 0) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": GetModuleFileName - %s",
                SystemMessage(ret)));
 
            return ret;
        }
 
        //  search the last '\' character
 
        while (len > 0 && file_path[len - 1] != '\\') {
            len --;
        }
 
        //  supply the file name (vfd.sys)
 
        file_name = &file_path[len];
        strcpy(file_name, VFD_DRIVER_FILENAME);
    }
    else {
 
        //  ensure that tha path is an absolute full path
 
        len = GetFullPathName(
            sFileName,
            sizeof(file_path),
            file_path,
            &file_name);
 
        if (len == 0) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": GetFullPathName(%s) - %s\n",
                sFileName, SystemMessage(ret)));
 
            return ret;
        }
 
        if (GetFileAttributes(file_path) & FILE_ATTRIBUTE_DIRECTORY) {
            //  if the specified path is a directory,
            //  supply the file name (vfd.sys)
 
            file_name = &file_path[len];
            strcpy(file_name++, "\\" VFD_DRIVER_FILENAME);
        }
    }
 
#ifdef __REACTOS__
    //      Check install directory & file exist or use full_file_path
 
    if (GetFileAttributesA(file_path) == INVALID_FILE_ATTRIBUTES) {
        strcpy(file_path, full_file_path);
    }
#endif
 
    //  Check if the file is a valid Virtual Floppy driver
 
    ret = VfdCheckDriverFile(file_path, NULL);
 
    if (ret != ERROR_SUCCESS) {
        VFDTRACE(0,
            (FUNC ": VfdCheckDriverFile(%s)\n", file_path));
 
        return ret;
    }
 
    //  if the path is under the system directory, make it relative
    //  to the system directory
 
    len = strlen(system_dir);
 
    if (!_strnicmp(file_path, system_dir, len)) {
        inst_path = &file_path[len];
 
        while (*inst_path == '\\') {
            inst_path++;
        }
    }
    else {
        inst_path = &file_path[0];
    }
#endif  //  VFD_EMBED_DRIVER
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(
        NULL,                           // local machine
        NULL,                           // local database
        SC_MANAGER_CREATE_SERVICE);     // access required
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Create a new service object
 
    hService = CreateService(
        hScManager,                     // service control manager
        VFD_DEVICE_BASENAME,            // internal service name
        VFD_DEVICE_BASENAME,            // display name
        SERVICE_ALL_ACCESS,             // access mode
        SERVICE_KERNEL_DRIVER,          // service type
        nStart,                         // service start type
        SERVICE_ERROR_NORMAL,           // start error sevirity
        inst_path,                      // service image file path
        NULL,                           // service group
        NULL,                           // service tag
        NULL,                           // service dependency
        NULL,                           // use LocalSystem account
        NULL                            // password for the account
    );
 
    if (!hService) {
        // Failed to create a service object
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": CreateService() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    if (ret == ERROR_SUCCESS) {
        //  Broadcast the successful operation
        VfdNotify(VFD_OPERATION_INSTALL, 0);
    }
#ifdef VFD_EMBED_DRIVER
    else {
        //  Delete the restored driver file
        DeleteFile(system_dir);
    }
#endif  // VFD_EMBED_DRIVER
 
    return ret;
}
 
//
//  Configure the Virtual Floppy Driver (change the start method)
//
 
DWORD WINAPI VfdConfigDriver(
    DWORD           nStart)
{
#undef  FUNC
#define FUNC        "VfdConfigDriver"
    SC_HANDLE       hScManager;             // Service Control Manager
    SC_HANDLE       hService;               // Service (= Driver)
    DWORD           ret = ERROR_SUCCESS;
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        SERVICE_CHANGE_CONFIG);         // service access mode
 
    if (hService == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenService(SERVICE_CHANGE_CONFIG) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Change the start method of the VFD driver
 
    if (!ChangeServiceConfig(
            hService,
            SERVICE_NO_CHANGE,
            nStart,
            SERVICE_NO_CHANGE,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            NULL)) {
 
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": ChangeServiceConfig() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    //  Broadcast the successful operation
 
    if (ret == ERROR_SUCCESS) {
        VfdNotify(VFD_OPERATION_CONFIG, 0);
    }
 
    return ret;
}
 
//
//  Remove the Virtual Floppy Driver entry from the service database
//
DWORD WINAPI VfdRemoveDriver()
{
#undef  FUNC
#define FUNC        "VfdRemoveDriver"
    SC_HANDLE       hScManager;             // Service Control Manager
    SC_HANDLE       hService;               // Service (= Driver)
    CHAR            file_path[MAX_PATH];
    DWORD           ret = ERROR_SUCCESS;
 
    //  Get the current driver path
 
    ret = VfdGetDriverConfig(file_path, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        DELETE);                        // service access mode
 
    if (hService == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenService(DELETE) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Remove driver entry from registry
 
    if (!DeleteService(hService)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeleteService() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    //  Broadcast the successful operation
 
    if (ret == ERROR_SUCCESS) {
        VfdNotify(VFD_OPERATION_REMOVE, 0);
 
#ifdef VFD_EMBED_DRIVER
        //  Remove the driver file
        DeleteFile(file_path);
#endif  //  VFD_EMBED_DRIVER
    }
 
    return ret;
}
 
//
//  Start the Virtual Floppy Driver
//
DWORD WINAPI VfdStartDriver(
    PDWORD          pState)
{
#undef  FUNC
#define FUNC        "VfdStartDriver"
    SC_HANDLE       hScManager;         // Service Control Manager
    SC_HANDLE       hService;           // Service (= Driver)
    SERVICE_STATUS  stat;
    DWORD           ret = ERROR_SUCCESS;
    HCURSOR         original;
    int             i;
 
    if (pState) {
        *pState = 0;
    }
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  show an hourglass cursor
 
    original = SetCursor(LoadCursor(NULL, IDC_WAIT));
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        SERVICE_START
        | SERVICE_QUERY_STATUS);        // service access mode
 
    if (hService == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenService(SERVICE_START) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Start the driver
 
    if (!StartService(hService, 0, NULL)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": StartService() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Wait until the driver is properly running
 
    i = 0;
 
    for (;;) {
        if (!QueryServiceStatus(hService, &stat)) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": QueryServiceStatus() - %s",
                SystemMessage(ret)));
 
            break;
        }
 
        if (stat.dwCurrentState == SERVICE_RUNNING || ++i == 5) {
            break;
        }
 
        Sleep(1000);
    }
 
    if (stat.dwCurrentState == SERVICE_RUNNING) {
 
        //  Broadcast the successful operation
 
        if (ret == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_START, 0);
        }
 
        //  broadcast the arrival of VFD drives
        //  otherwise WinXP explorer doesn't recognize the VFD drives
 
        for (i = 0; i < VFD_MAXIMUM_DEVICES; i++) {
            HANDLE  hDevice;
            CHAR    letter = 0;
 
            hDevice = VfdOpenDevice(i);
 
            if (hDevice != INVALID_HANDLE_VALUE) {
 
                VfdGetGlobalLink(hDevice, &letter);
 
                CloseHandle(hDevice);
 
                if (isalpha(letter)) {
                    VfdBroadcastLink(letter, VFD_LINK_CREATED);
                    VfdNotify(VFD_OPERATION_SETLINK, i);
                }
            }
            else {
                VFDTRACE(0,
                    (FUNC ": VfdOpenDevice(%d) - %s",
                    i, SystemMessage(GetLastError())));
            }
        }
    }
    else {
        //  somehow failed to start the driver
 
        ret = ERROR_SERVICE_NOT_ACTIVE;
    }
 
    if (pState) {
        *pState = stat.dwCurrentState;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    //  revert to the original cursor
 
    SetCursor(original);
 
    return ret;
}
 
//
//  Stop the Virtual Floppy Driver
//
DWORD WINAPI VfdStopDriver(
    PDWORD          pState)
{
#undef  FUNC
#define FUNC        "VfdStopDriver"
    SC_HANDLE       hScManager;         // Service Control Manager
    SC_HANDLE       hService;           // Service (= Driver)
    SERVICE_STATUS  stat;
    CHAR            drive_letters[VFD_MAXIMUM_DEVICES];
    DWORD           ret = ERROR_SUCCESS;
    int             i;
    HCURSOR         original;
 
    if (pState) {
        *pState = 0;
    }
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  Show the hourglass cursor
 
    original = SetCursor(LoadCursor(NULL, IDC_WAIT));
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        SERVICE_STOP
        | SERVICE_QUERY_STATUS);        // service access mode
 
    if (hService == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenService(SERVICE_STOP) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Get assigned drive letters
 
    for (i = 0; i < VFD_MAXIMUM_DEVICES; i++) {
        HANDLE  hDevice;
        CHAR letter;
 
        hDevice = VfdOpenDevice(i);
 
        if (hDevice != INVALID_HANDLE_VALUE) {
 
            //  remove all session local drive letters
 
            while (VfdGetLocalLink(hDevice, &letter) == ERROR_SUCCESS &&
                isalpha(letter)) {
                VfdSetLocalLink(hDevice, 0);
            }
 
            //  store existing persistent drive letters
 
            VfdGetGlobalLink(hDevice, &drive_letters[i]);
 
            CloseHandle(hDevice);
        }
        else {
            VFDTRACE(0,
                (FUNC ": VfdOpenDevice(%d) - %s",
                i, SystemMessage(GetLastError())));
        }
    }
 
    //  Stop the driver
 
    if (!ControlService(hService, SERVICE_CONTROL_STOP, &stat)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": ControlService(SERVICE_CONTROL_STOP) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Wait until the driver is stopped
 
    i = 0;
 
    while (stat.dwCurrentState != SERVICE_STOPPED && ++i < 5) {
        Sleep(1000);
 
        if (!QueryServiceStatus(hService, &stat)) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": QueryServiceStatus() - %s",
                SystemMessage(ret)));
 
            break;
        }
    }
 
    if (stat.dwCurrentState != SERVICE_RUNNING) {
 
        //  broadcast the removal of persistent drive letters
 
        for (i = 0; i < VFD_MAXIMUM_DEVICES; i++) {
            if (isalpha(drive_letters[i])) {
                VfdBroadcastLink(drive_letters[i], VFD_LINK_REMOVED);
                VfdNotify(VFD_OPERATION_DELLINK, i);
            }
        }
    }
 
    if (pState) {
        *pState = stat.dwCurrentState;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    //  Broadcast the successful operation
 
    if (ret == ERROR_SUCCESS) {
        VfdNotify(VFD_OPERATION_STOP, 0);
    }
 
    //  revert to the original cursor
 
    SetCursor(original);
 
    return ret;
}
 
//
//  Get the Virtual Floppy Driver configuration
//
DWORD WINAPI VfdGetDriverConfig(
    PSTR            sFileName,
    PDWORD          pStart)
{
#undef  FUNC
#define FUNC        "VfdGetDriverConfig"
    SC_HANDLE       hScManager;             // Service Control Manager
    SC_HANDLE       hService;               // Service (= Driver)
    LPQUERY_SERVICE_CONFIG config = NULL;
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    if (sFileName) {
        ZeroMemory(sFileName, MAX_PATH);
    }
 
    if (pStart) {
        *pStart = 0;
    }
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s", SystemMessage(ret)));
 
        return ret;
    }
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        SERVICE_QUERY_CONFIG);          // service access mode
 
    if (hService == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenService(SERVICE_QUERY_CONFIG) - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  Get the length of config information
 
    if (!QueryServiceConfig(hService, NULL, 0, &result)) {
        ret = GetLastError();
 
        if (ret == ERROR_INSUFFICIENT_BUFFER) {
            ret = ERROR_SUCCESS;
        }
        else {
            VFDTRACE(0,
                (FUNC ": QueryServiceConfig() - %s",
                SystemMessage(ret)));
 
            goto cleanup;
        }
    }
 
    //  allocate a required buffer
 
    config = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, result);
 
    if (config == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc(%lu) - %s\n",
            result, SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  get the config information
 
    if (!QueryServiceConfig(hService, config, result, &result)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": QueryServiceConfig() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    //  copy information to output buffer
 
    if (sFileName) {
        if (strncmp(config->lpBinaryPathName, "\\??\\", 4) == 0) {
 
            //  driver path is an absolute UNC path
            strncpy(
                sFileName,
                config->lpBinaryPathName + 4,
                MAX_PATH);
        }
        else if (config->lpBinaryPathName[0] == '\\' ||
            (isalpha(config->lpBinaryPathName[0]) &&
            config->lpBinaryPathName[1] == ':')) {
 
            //  driver path is an absolute path
            strncpy(sFileName,
                config->lpBinaryPathName,
                MAX_PATH);
        }
        else {
            //  driver path is relative to the SystemRoot
//          DWORD len = GetEnvironmentVariable(
//              "SystemRoot", sFileName, MAX_PATH);
 
            DWORD len = GetWindowsDirectory(sFileName, MAX_PATH);
 
            if (len == 0 || len > MAX_PATH) {
                VFDTRACE(0,
                    (FUNC ": %%SystemRoot%% is empty or too long.\n"));
 
                ret = ERROR_BAD_ENVIRONMENT;
                goto cleanup;
            }
 
            sprintf((sFileName + len), "\\%s",
                config->lpBinaryPathName);
        }
    }
 
    if (pStart) {
        *pStart = config->dwStartType;
    }
 
cleanup:
    //  Free service config buffer
 
    if (config) {
        LocalFree(config);
    }
 
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    return ret;
}
 
//
//  Get the Virtual Floppy Driver running state
//
DWORD WINAPI VfdGetDriverState(
    PDWORD          pState)
{
#undef  FUNC
#define FUNC        "VfdGetDriverState"
    SC_HANDLE       hScManager = NULL;  // Service Control Manager
    SC_HANDLE       hService = NULL;    // Service (= Driver)
    SERVICE_STATUS  status;
    DWORD           ret = ERROR_SUCCESS;
 
    if (pState) {
        *pState = 0;
    }
 
    //  Connect to the Service Control Manager
 
    hScManager = OpenSCManager(NULL, NULL, 0);
 
    if (hScManager == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": OpenSCManager() - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  Open the VFD driver entry in the service database
 
    hService = OpenService(
        hScManager,                     // Service control manager
        VFD_DEVICE_BASENAME,            // service name
        SERVICE_QUERY_STATUS);          // service access mode
 
    if (hService == NULL) {
 
        ret = GetLastError();
 
        if (ret == ERROR_SERVICE_DOES_NOT_EXIST) {
 
            if (pState) {
                *pState = VFD_NOT_INSTALLED;
            }
 
            ret = ERROR_SUCCESS;
        }
        else {
            VFDTRACE(0,
                (FUNC ": OpenService(SERVICE_QUERY_STATUS) - %s",
                SystemMessage(ret)));
        }
 
        goto cleanup;
    }
 
    //  Get current driver status
 
    ZeroMemory(&status, sizeof(status));
 
    if (!QueryServiceStatus(hService, &status)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": QueryServiceStatus() - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    if (pState) {
        *pState = status.dwCurrentState;
    }
 
cleanup:
    //  Close the service object handle
 
    if (hService) {
        CloseServiceHandle(hService);
    }
 
    //  Close handle to the service control manager.
 
    if (hScManager) {
        CloseServiceHandle(hScManager);
    }
 
    return ret;
}
 
//
//  open a Virtual Floppy drive without showing the "Insert Floppy"
//  dialog when the drive is empty.
//
HANDLE WINAPI VfdOpenDevice(
    ULONG           nTarget)        // either a drive letter or a device number
{
#undef  FUNC
#define FUNC        "VfdOpenDevice"
    CHAR            dev_name[20];
    UINT            err_mode;
    HANDLE          hDevice;
 
    //  format a device name string
 
    if (isalpha(nTarget)) {
        //  nTarget is a drive letter
        //  \\.<x>:
#ifndef __REACTOS__
        sprintf(dev_name, VFD_VOLUME_TEMPLATE, nTarget);
#else
        sprintf(dev_name, VFD_VOLUME_TEMPLATE, (CHAR)nTarget);
#endif
    }
    else if (isdigit(nTarget)) {
        //  nTarget is a device number in character
        //  \\.\VirtualFD<n>
        sprintf(dev_name, VFD_DEVICE_TEMPLATE, nTarget - '0');
    }
    else {
        //  nTarget is a device number value
        //  \\.\VirtualFD<n>
        sprintf(dev_name, VFD_DEVICE_TEMPLATE, nTarget);
    }
 
    // change error mode in order to avoid "Insert Floppy" dialog
 
    err_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
 
    //  open the target drive
 
    hDevice = CreateFile(
        dev_name,
        GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        FILE_FLAG_NO_BUFFERING,
        NULL);
 
    //  revert to the original error mode
 
    SetErrorMode(err_mode);
 
    if (hDevice != INVALID_HANDLE_VALUE) {
 
        //  check if the target is a valid VFD drive
 
        ULONG version;
 
        if (VfdGetDriverVersion(hDevice, &version) != ERROR_SUCCESS) {
 
            //  Failed to get the driver version
 
            CloseHandle(hDevice);
            hDevice = INVALID_HANDLE_VALUE;
        }
        else if ((version & ~0x80000000) !=
            MAKELONG(VFD_DRIVER_MINOR, VFD_DRIVER_MAJOR)) {
 
            //  the driver version mismatch
 
//          CloseHandle(hDevice);
//          hDevice = INVALID_HANDLE_VALUE;
 
            SetLastError(ERROR_REVISION_MISMATCH);
        }
    }
    else {
        VFDTRACE(0,(
            "CreateFile(%s) - %s", dev_name,
            SystemMessage(GetLastError())));;
    }
 
    return hDevice;
}
 
//
//  Open a Virtual Floppy Image
//
DWORD WINAPI VfdOpenImage(
    HANDLE          hDevice,
    PCSTR           sFileName,
    VFD_DISKTYPE    nDiskType,
    VFD_MEDIA       nMediaType,
    VFD_FLAGS       nMediaFlags)
{
#undef  FUNC
#define FUNC        "VfdOpenImage"
    PCSTR           prefix;
    CHAR            abspath[MAX_PATH];
    DWORD           name_len;
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    PVFD_IMAGE_INFO image_info = NULL;
    PUCHAR          image_buf = NULL;
    ULONG           image_size;
    VFD_FILETYPE    file_type;
 
    //
    //  Check parameters
    //
 
    if (hDevice == NULL ||
        hDevice == INVALID_HANDLE_VALUE) {
        return ERROR_INVALID_HANDLE;
    }
 
    if (nMediaType == VFD_MEDIA_NONE ||
        nMediaType >= VFD_MEDIA_MAX) {
 
        VFDTRACE(0,
            (FUNC ": Invalid MediaType - %u\n", nMediaType));
 
        return ERROR_INVALID_PARAMETER;
    }
 
 
    if (sFileName && *sFileName) {
 
        //  check file contents and attributes
 
        HANDLE hFile = CreateFile(sFileName, GENERIC_READ,
            FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 
        if (hFile == INVALID_HANDLE_VALUE) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": CreateFile(%s) - %s",
                sFileName, SystemMessage(ret)));
 
            return ret;
        }
 
        //  try extracting image data from zip compressed file
 
        ExtractZipImage(hFile, &image_buf, &image_size);
 
        if (image_buf) {
 
            file_type = VFD_FILETYPE_ZIP;
 
            //  imz file must be opened in RAM mode
 
            if (nDiskType == VFD_DISKTYPE_FILE) {
 
                VFDTRACE(0,
                    (FUNC ": %s is a zip compressed file",
                    sFileName));
 
                CloseHandle(hFile);
                ret = ERROR_INVALID_PARAMETER;
 
                goto exit_func;
            }
        }
        else {
 
            file_type = VFD_FILETYPE_RAW;
 
            if (nDiskType == VFD_DISKTYPE_FILE) {
 
                //  direct image file must not be compressed or encrypted
 
                BY_HANDLE_FILE_INFORMATION info;
 
                if (!GetFileInformationByHandle(hFile, &info)) {
                    ret = GetLastError();
 
                    VFDTRACE(0,
                        (FUNC ": GetFileInformationByHandle - %s",
                        SystemMessage(ret)));
 
                    CloseHandle(hFile);
 
                    return ret;
                }
 
                if (info.dwFileAttributes &
                    (FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED)) {
 
                    VFDTRACE(0,
                        (FUNC ": file is compressed/encrypted"));
 
                    CloseHandle(hFile);
 
                    return ERROR_FILE_ENCRYPTED;
                }
 
                image_size  = info.nFileSizeLow;
            }
            else {
 
                // prepare image data for a file based RAM disk
 
                image_size = GetFileSize(hFile, NULL);
 
                if (image_size == 0 || image_size == INVALID_FILE_SIZE) {
                    ret = GetLastError();
 
                    VFDTRACE(0,
                        (FUNC ": GetFileSize - %s",
                        SystemMessage(ret)));
 
                    CloseHandle(hFile);
 
                    return ret;
                }
 
                image_buf = (PUCHAR)LocalAlloc(LPTR, image_size);
 
                if (image_buf == NULL) {
                    ret = GetLastError();
 
                    VFDTRACE(0,
                        (FUNC ": LocalAlloc - %s",
                        SystemMessage(ret)));
 
                    CloseHandle(hFile);
 
                    return ret;
                }
 
                if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
                    ret = GetLastError();
 
                    VFDTRACE(0,
                        (FUNC ": SetFilePointer - %s",
                        SystemMessage(ret)));
 
                    CloseHandle(hFile);
 
                    goto exit_func;
                }
 
                if (!ReadFile(hFile, image_buf, image_size, &result, NULL) ||
                    image_size != result) {
 
                    ret = GetLastError();
 
                    VFDTRACE(0,
                        (FUNC ": ReadFile - %s",
                        SystemMessage(ret)));
 
                    CloseHandle(hFile);
 
                    goto exit_func;
                }
            }
        }
 
        CloseHandle(hFile);
 
        //  Prepare absolute path in the kernel namespace
 
        if (*sFileName == '\\' && *(sFileName + 1) == '\\') {
 
            // \\server\share\path\floppy.img
 
            prefix = "\\??\\UNC";
            sFileName++;            // drip the first '\'
        }
        else {
 
            //  local path
 
            PSTR file_part;
 
            if (GetFullPathName(sFileName,
                sizeof(abspath), abspath, &file_part) == 0) {
 
                ret =  GetLastError();
 
                VFDTRACE(0,
                    (FUNC ": GetFullPathName(%s) - %s\n",
                    sFileName, SystemMessage(ret)));
 
                goto exit_func;
            }
 
            prefix = "\\??\\";
            sFileName = abspath;
        }
 
        name_len = strlen(prefix) + strlen(sFileName);
    }
    else {
 
        //  filename is not specified -- pure RAM disk
 
        nDiskType = VFD_DISKTYPE_RAM;
        file_type = VFD_FILETYPE_NONE;
 
        prefix = NULL;
        name_len = 0;
 
        //  prepare a FAT formatted RAM image
 
        image_size = VfdGetMediaSize(nMediaType);
 
        image_buf = (PUCHAR)LocalAlloc(LPTR, image_size);
 
        if (image_buf == NULL) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": LocalAlloc - %s",
                SystemMessage(ret)));
 
            return ret;
        }
 
        FormatBufferFat(image_buf, VFD_BYTE_TO_SECTOR(image_size));
    }
 
    if (image_size < VfdGetMediaSize(nMediaType)) {
 
        //  image is too small for the specified media type
 
        VFDTRACE(0,
            (FUNC ": Image is too small for the specified media type\n"));
 
        ret = ERROR_INVALID_PARAMETER;
        goto exit_func;
    }
 
    //  prepare VFD_IMAGE_INFO structure
 
    image_info = (PVFD_IMAGE_INFO)LocalAlloc(LPTR,
        sizeof(VFD_IMAGE_INFO) + name_len + 1);
 
    if (image_info == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc(%lu) - %s\n",
            sizeof(VFD_IMAGE_INFO) + name_len + 1,
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    ZeroMemory(image_info,
        sizeof(VFD_IMAGE_INFO) + name_len + 1);
 
    if (name_len) {
        sprintf(image_info->FileName,
            "%s%s", prefix, sFileName);
    }
 
    image_info->NameLength  = (USHORT)name_len;
 
    image_info->DiskType    = nDiskType;
    image_info->MediaType   = nMediaType;
    image_info->MediaFlags  = nMediaFlags;
    image_info->FileType    = file_type;
    image_info->ImageSize   = image_size;
 
    if (nDiskType != VFD_DISKTYPE_FILE) {
        //  protect flag for a RAM disk is set after
        //  initializing the image buffer
        image_info->MediaFlags &= ~VFD_FLAG_WRITE_PROTECTED;
    }
 
    VFDTRACE(0,
        (FUNC ": Opening file \"%s\" (%lu bytes) %s %s %s %s\n",
        name_len ? image_info->FileName : "<RAM>",
        image_info->ImageSize,
        (file_type == VFD_FILETYPE_ZIP) ? "ZIP image" : "RAW image",
        VfdMediaTypeName(nMediaType),
        (nDiskType == VFD_DISKTYPE_FILE) ? "FILE disk" : "RAM disk",
        (nMediaFlags & VFD_FLAG_WRITE_PROTECTED) ? "Protected" : "Writable"));
 
    //  Open the image file / create a ram disk
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_OPEN_IMAGE,
        image_info,
        sizeof(VFD_IMAGE_INFO) + name_len,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_OPEN_FILE) - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  initialize the RAM disk image
 
    if (nDiskType != VFD_DISKTYPE_FILE) {
 
        image_size &= ~VFD_SECTOR_ALIGN_MASK;
 
        if (SetFilePointer(hDevice, 0, NULL, FILE_BEGIN) != 0) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": SetFilePointer - %s",
                SystemMessage(ret)));
 
            goto exit_func;
        }
 
        if (!WriteFile(hDevice, image_buf, image_size, &result, NULL) ||
            image_size != result) {
 
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": WriteFile - %s",
                SystemMessage(ret)));
 
            goto exit_func;
        }
 
        if (nMediaFlags & VFD_FLAG_WRITE_PROTECTED) {
            VfdWriteProtect(hDevice, TRUE);
        }
 
        if (!DeviceIoControl(
            hDevice,
            IOCTL_VFD_RESET_MODIFY,
            NULL,
            0,
            NULL,
            0,
            &result,
            NULL))
        {
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_VFD_RESET_MODIFY) - %s",
                SystemMessage(GetLastError())));
        }
    }
 
    //  Broadcast the successful operation
 
    if (ret == ERROR_SUCCESS) {
        ULONG   number;
        CHAR    root[] = "A:\\";
 
        if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_OPEN, number);
        }
 
        VfdGetGlobalLink(hDevice, &root[0]);
 
        if (isalpha(root[0])) {
            SHChangeNotify(SHCNE_MEDIAINSERTED, SHCNF_PATH, root, NULL);
        }
 
        while (VfdGetLocalLink(hDevice, &root[0]) == ERROR_SUCCESS &&
            isalpha(root[0])) {
            SHChangeNotify(SHCNE_MEDIAINSERTED, SHCNF_PATH, root, NULL);
        }
    }
 
exit_func:
    if (image_info) {
        LocalFree(image_info);
    }
 
    if (image_buf) {
        LocalFree(image_buf);
    }
 
    return ret;
}
 
//
//  Close the virtual floppy Image
//
DWORD WINAPI VfdCloseImage(
    HANDLE          hDevice,
    BOOL            bForce)
{
#undef  FUNC
#define FUNC        "VfdCloseImage"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
    int             retry = 0;
 
lock_retry:
    if (!DeviceIoControl(
        hDevice,
        FSCTL_LOCK_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_LOCK_VOLUME) - %s",
            SystemMessage(ret)));
 
        if (ret != ERROR_ACCESS_DENIED || retry == 5) {
            //  error other than access denied or
            //  operation kept failing for 5 seconds
            return ret;
        }
 
        if (!bForce) {
            //  error is access denied and
            //  the force flag is not set
 
            if (retry == 0) {
 
                //  send the MEDIAREMOVED notification to the shell and
                //  see if the shell releases the target drive
 
                CHAR root[] = "A:\\";
 
                VfdGetGlobalLink(hDevice, &root[0]);
 
                if (isalpha(root[0])) {
                    SHChangeNotify(SHCNE_MEDIAREMOVED, SHCNF_PATH, root, NULL);
                }
 
                while (VfdGetLocalLink(hDevice, &root[0]) == ERROR_SUCCESS &&
                    isalpha(root[0])) {
                    SHChangeNotify(SHCNE_MEDIAREMOVED, SHCNF_PATH, root, NULL);
                }
            }
 
            Sleep(1000);
            retry++;
 
            goto lock_retry;
        }
    }
 
    ret = ERROR_SUCCESS;
 
    if (!DeviceIoControl(
        hDevice,
        FSCTL_DISMOUNT_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_DISMOUNT_VOLUME) - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_CLOSE_IMAGE,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        if (ret != ERROR_NOT_READY) {
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_VFD_CLOSE_FILE) - %s",
                SystemMessage(ret)));
        }
 
        return ret;
    }
 
    if (!DeviceIoControl(
        hDevice,
        FSCTL_UNLOCK_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        //  This should not be fatal because the volume is unlocked
        //  when the handle is closed anyway
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_UNLOCK_VOLUME) - %s",
            SystemMessage(GetLastError())));
    }
 
    //  Broadcast the successful operation
    if (ret == ERROR_SUCCESS) {
        ULONG   number;
 
        if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_CLOSE, number);
        }
    }
 
    return ret;
}
 
//
//  Get Virtual Floppy image info
//
DWORD WINAPI VfdGetImageInfo(
    HANDLE          hDevice,
    PSTR            sFileName,
    PVFD_DISKTYPE   pDiskType,
    PVFD_MEDIA      pMediaType,
    PVFD_FLAGS      pMediaFlags,
    PVFD_FILETYPE   pFileType,
    PULONG          pImageSize)
{
#undef  FUNC
#define FUNC        "VfdGetImageInfo"
    PVFD_IMAGE_INFO image_info;
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    image_info = (PVFD_IMAGE_INFO)LocalAlloc(
        LPTR, sizeof(VFD_IMAGE_INFO) + MAX_PATH);
 
    if (image_info == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc(%lu) - %s\n",
            sizeof(VFD_IMAGE_INFO) + MAX_PATH, SystemMessage(ret)));
 
        return ret;
    }
 
    ZeroMemory(image_info, sizeof(VFD_IMAGE_INFO) + MAX_PATH);
 
    //  Query file information
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_QUERY_IMAGE,
        NULL,
        0,
        image_info,
        sizeof(VFD_IMAGE_INFO) + MAX_PATH,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        if (ret != ERROR_MORE_DATA) {
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_VFD_QUERY_FILE) - %s",
                SystemMessage(ret)));
 
            goto cleanup;
        }
    }
 
    //  copy obtained information to output buffer
 
    if (sFileName) {
 
        //  if filename is too long, clip it
 
        if (image_info->NameLength >= MAX_PATH) {
            image_info->NameLength = MAX_PATH - 1;
        }
 
        // ensure the name is properly terminated
 
        image_info->FileName[image_info->NameLength] = '\0';
 
        if (strncmp(image_info->FileName, "\\??\\UNC", 7) == 0) {
            *sFileName = '\\';
            strcpy(sFileName + 1, image_info->FileName + 7);
        }
        else if (strncmp(image_info->FileName, "\\??\\", 4) == 0) {
            strcpy(sFileName, image_info->FileName + 4);
        }
        else {
            strcpy(sFileName, image_info->FileName);
        }
    }
 
    if (pDiskType) {
        *pDiskType = image_info->DiskType;
    }
 
    if (pMediaType) {
        *pMediaType = image_info->MediaType;
    }
 
    if (pMediaFlags) {
        *pMediaFlags = image_info->MediaFlags;
    }
 
    if (pFileType) {
        *pFileType = image_info->FileType;
    }
 
    if (pImageSize) {
        *pImageSize = image_info->ImageSize;
    }
 
cleanup:
    if (image_info) {
        LocalFree(image_info);
    }
 
    return ret;
}
 
//
//  Get current media state (opened / write protected)
//
DWORD WINAPI VfdGetMediaState(
    HANDLE          hDevice)
{
#undef  FUNC
#define FUNC        "VfdGetMediaState"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    //  Query file information
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_DISK_IS_WRITABLE,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        if (ret != ERROR_NOT_READY) {
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_DISK_IS_WRITABLE) - %s",
                SystemMessage(ret)));
        }
    }
 
    return ret;
}
 
//
//  Set or Delete a global drive letter
//
DWORD WINAPI VfdSetGlobalLink(
    HANDLE          hDevice,
    CHAR            cLetter)
{
#undef  FUNC
#define FUNC        "VfdSetGlobalLink"
    CHAR            letter;
    ULONG           number;
    DWORD           result;
    DWORD           ret;
 
    if (isalpha(cLetter)) {
 
        //  make sure the drive does not have a drive letter
 
        letter = 0;
 
        VfdGetGlobalLink(hDevice, &letter);
 
        if (isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive already has a drive letter %c\n", letter));
            return ERROR_ALREADY_ASSIGNED;
        }
 
        VfdGetLocalLink(hDevice, &letter);
 
        if (isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive already has a drive letter %c\n", letter));
            return ERROR_ALREADY_ASSIGNED;
        }
 
        //  make sure drive letter is not in use
 
        cLetter = (CHAR)toupper(cLetter);
 
        if (GetLogicalDrives() & (1 << (cLetter - 'A'))) {
            VFDTRACE(0,
                (FUNC ": Drive letter %c already used\n", cLetter));
            return ERROR_ALREADY_ASSIGNED;
        }
 
        //  Assign a new drive letter
 
        if (!DeviceIoControl(
            hDevice,
            IOCTL_VFD_SET_LINK,
            &cLetter,
            sizeof(cLetter),
            NULL,
            0,
            &result,
            NULL))
        {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_VFD_SET_LINK) - %s",
                SystemMessage(ret)));
 
            return ret;
        }
 
        //  broadcast system message
 
        VfdBroadcastLink(cLetter, VFD_LINK_CREATED);
 
        //  broadcast VFD message
 
        if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_SETLINK, number);
        }
 
        return ERROR_SUCCESS;
    }
    else if (!cLetter) {
 
        //  make sure the drive has a global drive letter
 
        letter = 0;
 
        VfdGetGlobalLink(hDevice, &letter);
 
        if (!isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive does not have a drive letter\n"));
            return ERROR_INVALID_FUNCTION;
        }
 
        //  Remove drive letters
 
        if (!DeviceIoControl(
            hDevice,
            IOCTL_VFD_SET_LINK,
            &cLetter,
            sizeof(cLetter),
            NULL,
            0,
            &result,
            NULL))
        {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": DeviceIoControl(IOCTL_VFD_SET_LINK) - %s",
                SystemMessage(ret)));
 
            return ret;
        }
 
        //  broadcast system message
 
        VfdBroadcastLink(letter, VFD_LINK_REMOVED);
 
        //  broadcast VFD message
        if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_DELLINK, number);
        }
 
        return ERROR_SUCCESS;
    }
    else {
        return ERROR_INVALID_PARAMETER;
    }
}
 
//
//  Get a global drive letter
//
DWORD WINAPI VfdGetGlobalLink(
    HANDLE          hDevice,
    PCHAR           pLetter)
{
#undef  FUNC
#define FUNC        "VfdGetGlobalLinks"
    DWORD           result;
    DWORD           ret;
 
    if (!pLetter) {
        return ERROR_INVALID_PARAMETER;
    }
 
    *pLetter = 0;
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_QUERY_LINK,
        NULL,
        0,
        pLetter,
        sizeof(*pLetter),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_QUERY_LINK) - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    return ERROR_SUCCESS;
}
 
//
//  Set or remove a local drive letter
//
DWORD WINAPI VfdSetLocalLink(
    HANDLE          hDevice,
    CHAR            cLetter)
{
#undef  FUNC
#define FUNC        "VfdSetLocalLink"
    CHAR            letter;
    CHAR            dos_name[] = "A:";
    CHAR            dev_name[MAX_PATH];
    ULONG           number;
    DWORD           ret;
 
    if (isalpha(cLetter)) {
 
        //  make sure the drive does not have a drive letter
 
        letter = 0;
 
        VfdGetGlobalLink(hDevice, &letter);
 
        if (isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive already has a drive letter %c\n", letter));
            return ERROR_ALREADY_ASSIGNED;
        }
 
        VfdGetLocalLink(hDevice, &letter);
 
        if (isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive already has a drive letter %c\n", letter));
            return ERROR_ALREADY_ASSIGNED;
        }
 
        //  make sure drive letters are not in use
 
        cLetter = (CHAR)toupper(cLetter);
 
        if (GetLogicalDrives() & (1 << (cLetter - 'A'))) {
            VFDTRACE(0,
                (FUNC ": Drive letter already used\n"));
 
            return ERROR_ALREADY_ASSIGNED;
        }
 
        //  get VFD device name
 
        ret = VfdGetDeviceName(hDevice, dev_name, sizeof(dev_name));
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
 
        //  assign a drive letter
 
        dos_name[0] = cLetter;
 
        if (!DefineDosDevice(DDD_RAW_TARGET_PATH, dos_name, dev_name)) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": DefineDosDevice(%s,%s) - %s",
                dos_name, dev_name, SystemMessage(ret)));
        }
 
        if (ret == ERROR_SUCCESS) {
            //  broadcast VFD message
 
            if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
                VfdNotify(VFD_OPERATION_SETLINK, number);
            }
        }
 
        return ret;
    }
    else if (!cLetter) {
 
        //  make sure the drive has a local drive letter
 
        letter = 0;
 
        VfdGetLocalLink(hDevice, &letter);
 
        if (!isalpha(letter)) {
            VFDTRACE(0,
                (FUNC ": Drive letter is not assigned to this drive\n"));
            return ERROR_INVALID_FUNCTION;
        }
 
        //  get VFD device name
 
        ret = VfdGetDeviceName(hDevice, dev_name, sizeof(dev_name));
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
 
        //  remove drive letters
#define DDD_FLAGS   (DDD_REMOVE_DEFINITION | DDD_RAW_TARGET_PATH | DDD_EXACT_MATCH_ON_REMOVE)
 
        dos_name[0] = (CHAR)toupper(letter);
 
        if (!DefineDosDevice(DDD_FLAGS, dos_name, dev_name)) {
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": DefineDosDevice(%s,%s) - %s",
                dos_name, dev_name, SystemMessage(ret)));
        }
 
        if (ret == ERROR_SUCCESS) {
            //  broadcast VFD message
            if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
                VfdNotify(VFD_OPERATION_DELLINK, number);
            }
        }
 
        return ret;
    }
    else {
        return ERROR_INVALID_PARAMETER;
    }
}
 
//
//  Get local drive letters
//
DWORD WINAPI VfdGetLocalLink(
    HANDLE          hDevice,
    PCHAR           pLetter)
{
#undef  FUNC
#define FUNC        "VfdGetLocalLinks"
    CHAR            global;
    ULONG           logical;
    CHAR            dos_name[] = "A:";
    CHAR            dev_name[MAX_PATH];
    CHAR            dos_target[MAX_PATH * 2];
    DWORD           ret;
 
    if (!pLetter) {
        return ERROR_INVALID_PARAMETER;
    }
 
    //  Get the VFD device name
 
    ret = VfdGetDeviceName(hDevice, dev_name, sizeof(dev_name));
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //  Get global drive letter
 
    ret = VfdGetGlobalLink(hDevice, &global);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //  Get logical drives
 
    logical = GetLogicalDrives();
 
    //  exclude the global drive letter
 
    if (isalpha(global)) {
        logical &= ~(1 << (toupper(global) - 'A'));
    }
 
    //  start searching from the next drive letter
 
    if (isalpha(*pLetter)) {
        dos_name[0] = (CHAR)(toupper(*pLetter) + 1);
        logical >>= (dos_name[0] - 'A');
    }
 
    //  Check dos device targets
 
    *pLetter = '\0';
 
    while (logical) {
        if (logical & 0x01) {
            if (QueryDosDevice(dos_name, dos_target, sizeof(dos_target))) {
                if (_stricmp(dos_target, dev_name) == 0) {
                    *pLetter = dos_name[0];
                    break;
                }
            }
            else {
                VFDTRACE(0,
                    (FUNC ": QueryDosDevice(%s) - %s",
                    dos_name, SystemMessage(GetLastError())));
            }
        }
        logical >>= 1;
        dos_name[0]++;
    }
 
    return ERROR_SUCCESS;
}
 
//
//  Get the Virtual Floppy device number
//
DWORD WINAPI VfdGetDeviceNumber(
    HANDLE          hDevice,
    PULONG          pNumber)
{
#undef  FUNC
#define FUNC        "VfdGetDeviceNumber"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    if (!pNumber) {
        return ERROR_INVALID_PARAMETER;
    }
 
    *pNumber = 0;
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_QUERY_NUMBER,
        NULL,
        0,
        pNumber,
        sizeof(ULONG),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_QUERY_NUMBER) - %s",
            SystemMessage(ret)));
    }
 
    return ret;
}
 
//  Get the Virtual Floppy device name
 
DWORD WINAPI VfdGetDeviceName(
    HANDLE          hDevice,
    PCHAR           pName,
    ULONG           nLength)
{
#undef  FUNC
#define FUNC        "VfdGetDeviceName"
    DWORD           result;
    WCHAR           wname[MAX_PATH];
    DWORD           ret = ERROR_SUCCESS;
 
    if (!pName || !nLength) {
        return ERROR_INVALID_PARAMETER;
    }
 
    ZeroMemory(pName, nLength);
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_QUERY_NAME,
        NULL,
        0,
        wname,
        sizeof(wname),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_QUERY_NUMBER) - %s",
            SystemMessage(ret)));
    }
 
    if (!WideCharToMultiByte(CP_OEMCP, 0, &wname[1],
        wname[0] / sizeof(WCHAR), pName, nLength, NULL, NULL)) {
 
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": WideCharToMultiByte - %s",
            SystemMessage(ret)));
    }
 
    return ret;
}
 
//
//  Get Virtual Floppy driver version
//
DWORD WINAPI VfdGetDriverVersion(
    HANDLE          hDevice,
    PULONG          pVersion)
{
#undef  FUNC
#define FUNC        "VfdGetDriverVersion"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    if (!pVersion) {
        return ERROR_INVALID_PARAMETER;
    }
 
    *pVersion = '\0';
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_QUERY_VERSION,
        NULL,
        0,
        pVersion,
        sizeof(ULONG),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_QUERY_VERSION) - %s",
            SystemMessage(ret)));
    }
 
    return ret;
}
 
//
//  Change the write protect state of the media
//
DWORD WINAPI VfdWriteProtect(
    HANDLE          hDevice,
    BOOL            bProtect)
{
#undef  FUNC
#define FUNC        "VfdWriteProtect"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    if (!DeviceIoControl(
        hDevice,
        bProtect ? IOCTL_VFD_SET_PROTECT : IOCTL_VFD_CLEAR_PROTECT,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_SET_PROTECT) - %s",
            SystemMessage(ret)));
    }
 
    if (ret == ERROR_SUCCESS) {
        ULONG number;
 
        if (VfdGetDeviceNumber(hDevice, &number) == ERROR_SUCCESS) {
            VfdNotify(VFD_OPERATION_PROTECT, number);
        }
    }
 
    return ret;
}
 
//  Format the current media with FAT12
 
DWORD WINAPI VfdFormatMedia(
    HANDLE          hDevice)
{
#undef  FUNC
#define FUNC        "VfdFormatMedia"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
    PUCHAR          buf = NULL;
    GET_LENGTH_INFORMATION  length;
 
    //  Get the media size
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_DISK_GET_LENGTH_INFO,
        NULL,
        0,
        &length,
        sizeof(length),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_DISK_GET_LENGTH_INFO) - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  Prepare a formatted image buffer
 
    buf = (PUCHAR)LocalAlloc(LPTR, length.Length.LowPart);
 
    if (buf == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  format the buffer
 
    ret = FormatBufferFat(buf,
        VFD_BYTE_TO_SECTOR(length.Length.LowPart));
 
    if (ret != ERROR_SUCCESS) {
        goto exit_func;
    }
 
    //  seek the top of the media
 
    if (SetFilePointer(hDevice, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": SetFilePointer - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  write the image into the media
 
    if (!WriteFile(hDevice, buf, length.Length.LowPart, &result, NULL) ||
        result != length.Length.LowPart) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": WriteFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
exit_func:
    //  unlock the target volume
    if (!DeviceIoControl(
        hDevice,
        FSCTL_UNLOCK_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_UNLOCK_VOLUME) - %s",
            SystemMessage(GetLastError())));
    }
 
    //  release the format image buffer
    if (buf) {
        LocalFree(buf);
    }
 
    return ret;
}
 
//  Dismount the volume (should be called before Save, Format)
 
DWORD WINAPI VfdDismountVolume(
    HANDLE          hDevice,
    BOOL            bForce)
{
#undef  FUNC
#define FUNC        "VfdDismountVolume"
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    //  Lock the target volume
 
    if (!DeviceIoControl(
        hDevice,
        FSCTL_LOCK_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_LOCK_VOLUME) - %s",
            SystemMessage(ret)));
 
        if (ret != ERROR_ACCESS_DENIED || !bForce) {
            return ret;
        }
    }
 
    //  Dismount the target volume
 
    if (!DeviceIoControl(
        hDevice,
        FSCTL_DISMOUNT_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_DISMOUNT_VOLUME) - %s",
            SystemMessage(ret)));
    }
 
    return ret;
}
 
//  Save the current image into a file
 
DWORD WINAPI VfdSaveImage(
    HANDLE          hDevice,
    PCSTR           sFileName,
    BOOL            bOverWrite,
    BOOL            bTruncate)
{
#undef  FUNC
#define FUNC        "VfdSaveImage"
    HANDLE          hFile = INVALID_HANDLE_VALUE;
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
    PUCHAR          buf = NULL;
    GET_LENGTH_INFORMATION  length;
 
 
    ret = ERROR_SUCCESS;
 
    //  Get the media size
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_DISK_GET_LENGTH_INFO,
        NULL,
        0,
        &length,
        sizeof(length),
        &result,
        NULL))
    {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_DISK_GET_LENGTH_INFO) - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  Prepare an intermediate image buffer
 
    buf = (PUCHAR)LocalAlloc(LPTR, length.Length.LowPart);
 
    if (buf == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  seek the top of the media
 
    if (SetFilePointer(hDevice, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": SetFilePointer - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  read the image data
 
    if (!ReadFile(hDevice, buf, length.Length.LowPart, &result, NULL) ||
        result != length.Length.LowPart) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": ReadFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  open the destination file
 
    hFile = CreateFile(sFileName, GENERIC_WRITE, 0, NULL,
        bOverWrite ? OPEN_ALWAYS : CREATE_NEW, 0, NULL);
 
    if (hFile == INVALID_HANDLE_VALUE) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": CreateFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  seek the top of the file
 
    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": SetFilePointer - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  write the image data
 
    if (!WriteFile(hFile, buf, length.Length.LowPart, &result, NULL) ||
        result != length.Length.LowPart) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": WriteFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  truncate the target file
 
    if (bTruncate && !SetEndOfFile(hFile)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": SetEndOfFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    //  reset the media modified flag
 
    if (!DeviceIoControl(
        hDevice,
        IOCTL_VFD_RESET_MODIFY,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(IOCTL_VFD_RESET_MODIFY) - %s",
            SystemMessage(GetLastError())));
    }
 
exit_func:
    //  unlock the target volume
 
    if (!DeviceIoControl(
        hDevice,
        FSCTL_UNLOCK_VOLUME,
        NULL,
        0,
        NULL,
        0,
        &result,
        NULL))
    {
        VFDTRACE(0,
            (FUNC ": DeviceIoControl(FSCTL_UNLOCK_VOLUME) - %s",
            SystemMessage(GetLastError())));
    }
 
    //  release the format image buffer
 
    if (buf) {
        LocalFree(buf);
    }
 
    //  close the image file
 
    if (hFile != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile);
    }
 
    return ret;
}
 
//
//  Check if specified file is valid VFD driver
//
DWORD WINAPI VfdCheckDriverFile(
    PCSTR           sFileName,
    PULONG          pFileVersion)
{
#undef  FUNC
#define FUNC            "VfdCheckDriverFile"
    DWORD               result;
    DWORD               dummy;
    PVOID               info;
    VS_FIXEDFILEINFO    *fixedinfo;
    DWORD               ret = ERROR_SUCCESS;
    PSTR                str;
 
    //  Check parameter
 
    if (!sFileName || !*sFileName) {
        return ERROR_INVALID_PARAMETER;
    }
 
    if (pFileVersion) {
        *pFileVersion = 0;
    }
 
    //  check file existence
 
    if (GetFileAttributes(sFileName) == INVALID_FILE_ATTRIBUTES) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": GetFileAttributes - %s\n",
            SystemMessage(ret)));
 
        return ret;
    }
 
    //  check file version
 
    result = GetFileVersionInfoSize((PSTR)sFileName, &dummy);
 
    if (result == 0) {
        VFDTRACE(0,
            (FUNC ": GetFileVersionInfoSize == 0\n"));
 
        return ERROR_BAD_DRIVER;
    }
 
    info = LocalAlloc(LPTR, result);
 
    if (info == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc(%lu) - %s\n",
            result, SystemMessage(ret)));
 
        return ret;
    }
 
    if (!GetFileVersionInfo((PSTR)sFileName, 0, result, info)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": GetFileVersionInfo - %s", SystemMessage(ret)));
 
        goto cleanup;
    }
 
    result = sizeof(fixedinfo);
 
    if (!VerQueryValue(info, "\\", (PVOID *)&fixedinfo, (PUINT)&result)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": VerQueryValue(\"\\\") - %s", SystemMessage(ret)));
 
        goto cleanup;
    }
 
    if (fixedinfo->dwFileOS             != VOS_NT_WINDOWS32 ||
        fixedinfo->dwFileType           != VFT_DRV          ||
        fixedinfo->dwFileSubtype        != VFT2_DRV_SYSTEM) {
 
        VFDTRACE(0,
            (FUNC ": Invalid file type flags\n"));
 
        ret = ERROR_BAD_DRIVER;
 
        goto cleanup;
    }
 
    if (pFileVersion) {
        *pFileVersion = fixedinfo->dwFileVersionMS;
 
        if (fixedinfo->dwFileFlags & VS_FF_DEBUG) {
            *pFileVersion |= 0x80000000;
        }
    }
 
    if (!VerQueryValue(info,
        "\\StringFileInfo\\" VFD_VERSIONINFO_LANG "\\OriginalFileName",
        (PVOID *)&str, (PUINT)&result)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": VerQueryValue(\"OriginalFileName\") - %s",
            SystemMessage(ret)));
 
        goto cleanup;
    }
 
    if (strcmp(str, VFD_DRIVER_FILENAME)) {
        VFDTRACE(0,
            (FUNC ": Invalid original file name\n"));
 
        ret = ERROR_BAD_DRIVER;
 
        goto cleanup;
    }
 
    if (fixedinfo->dwFileVersionMS      != MAKELONG(VFD_DRIVER_MINOR, VFD_DRIVER_MAJOR) ||
        fixedinfo->dwProductVersionMS   != MAKELONG(VFD_PRODUCT_MINOR, VFD_PRODUCT_MAJOR)) {
 
        VFDTRACE(0,
            (FUNC ": Invalid version values - file:%08x, prod: %08x\n",
            fixedinfo->dwFileVersionMS, fixedinfo->dwProductVersionMS));
 
        ret = ERROR_BAD_DRIVER;
 
        goto cleanup;
    }
 
    //  Ensure that the driver binary is located on a local drive
    //  because device driver cannot be started on network drives.
 
    if (*sFileName == '\\' && *(sFileName + 1) == '\\') {
        //  full path is a UNC path -- \\server\dir\...
 
        VFDTRACE(0,
            (FUNC ": Driver is located on a network drive\n"));
 
        return ERROR_NETWORK_ACCESS_DENIED;
    }
    else {
        //  ensure that the drive letter is not a network drive
 
        CHAR root[] = " :\\";
 
        root[0] = *sFileName;
 
        if (GetDriveType(root) == DRIVE_REMOTE) {
            // the drive is a network drive
 
            VFDTRACE(0,
                (FUNC ": Driver is located on a network drive\n"));
 
            return ERROR_NETWORK_ACCESS_DENIED;
        }
    }
 
cleanup:
    LocalFree(info);
 
    return ret;
}
 
//
//  check an image file
//
DWORD WINAPI VfdCheckImageFile(
    PCSTR           sFileName,
    PDWORD          pAttributes,
    PVFD_FILETYPE   pFileType,
    PULONG          pImageSize)
{
#undef  FUNC
#define FUNC        "VfdCheckImageFile"
    HANDLE          hFile;
    DWORD           ret = ERROR_SUCCESS;
 
    if (!sFileName || !*sFileName || !pAttributes || !pImageSize || !pFileType) {
        return ERROR_INVALID_PARAMETER;
    }
 
    //  get file attributes
 
    *pAttributes = GetFileAttributes(sFileName);
 
    if (*pAttributes == INVALID_FILE_ATTRIBUTES) {
        ret = GetLastError();
 
        if (ret != ERROR_FILE_NOT_FOUND) {
            VFDTRACE(0,
                (FUNC ": GetFileAttributes(%s) - %s\n",
                sFileName, SystemMessage(ret)));
        }
 
        return ret;
    }
 
    //  Open the target file
 
    hFile = CreateFile(sFileName, GENERIC_READ | GENERIC_WRITE,
        0, NULL, OPEN_EXISTING, 0, NULL);
 
    if (hFile == INVALID_HANDLE_VALUE) {
 
        //  failed to open
 
        ret = GetLastError();
 
        if (ret != ERROR_ACCESS_DENIED) {
            VFDTRACE(0,
                (FUNC ": CreateFile(%s) - %s\n",
                sFileName, SystemMessage(ret)));
 
            return ret;
        }
 
        // try opening it read-only
 
        hFile = CreateFile(sFileName, GENERIC_READ,
            FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 
        if (hFile == INVALID_HANDLE_VALUE) {
 
            // cannot open even read-only
 
            ret = GetLastError();
 
            VFDTRACE(0,
                (FUNC ": CreateFile(%s) - %s\n",
                sFileName, SystemMessage(ret)));
 
            return ret;
        }
 
        // file can be opened read-only
        *pAttributes |= FILE_ATTRIBUTE_READONLY;
        ret = ERROR_SUCCESS;
    }
 
    //  check if the image is an IMZ file
 
    if (ExtractZipInfo(hFile, pImageSize) == ERROR_SUCCESS) {
        *pFileType = VFD_FILETYPE_ZIP;
    }
    else {
        *pImageSize = GetFileSize(hFile, NULL);
        *pFileType  = VFD_FILETYPE_RAW;
    }
 
    CloseHandle(hFile);
 
    return ret;
}
 
//
//  Create a formatted new image file
//
DWORD WINAPI VfdCreateImageFile(
    PCSTR           sFileName,
    VFD_MEDIA       nMediaType,
    VFD_FILETYPE    nFileType,
    BOOL            bOverWrite)
{
#undef  FUNC
#define FUNC        "VfdCreateImageFile"
    HANDLE          hFile;
    ULONG           file_size;
    PUCHAR          image_buf = NULL;
    DWORD           result;
    DWORD           ret = ERROR_SUCCESS;
 
    if (nFileType != VFD_FILETYPE_RAW) {
        return ERROR_INVALID_PARAMETER;
    }
 
    file_size = VfdGetMediaSize(nMediaType);
 
    if (file_size == 0) {
        return ERROR_INVALID_PARAMETER;
    }
 
    hFile = CreateFile(sFileName, GENERIC_WRITE, 0, NULL,
        bOverWrite ? CREATE_ALWAYS : CREATE_NEW, 0, NULL);
 
    if (hFile == INVALID_HANDLE_VALUE) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": CreateFile - %s",
            SystemMessage(ret)));
 
        return ret;
    }
 
    image_buf = (PUCHAR)LocalAlloc(LPTR, file_size);
 
    if (image_buf == NULL) {
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": LocalAlloc - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    FormatBufferFat(image_buf, VFD_BYTE_TO_SECTOR(file_size));
 
    if (!WriteFile(hFile, image_buf, file_size, &result, NULL) ||
        file_size != result) {
 
        ret = GetLastError();
 
        VFDTRACE(0,
            (FUNC ": WriteFile - %s",
            SystemMessage(ret)));
 
        goto exit_func;
    }
 
    SetEndOfFile(hFile);
 
exit_func:
    CloseHandle(hFile);
 
    if (image_buf) {
        LocalFree(image_buf);
    }
 
    return ret;
}
 
 
//
// choose first available drive letter
//
CHAR WINAPI VfdChooseLetter()
{
    DWORD   logical_drives = GetLogicalDrives();
    CHAR    drive_letter = 'A';
 
    if (logical_drives == 0) {
        return '\0';
    }
 
    while (logical_drives & 0x1) {
        logical_drives >>= 1;
        drive_letter++;
    }
 
    if (drive_letter > 'Z') {
        return '\0';
    }
 
    return drive_letter;
}
 
//
//  media type functions
//
static const struct
{
    ULONG   Size;
    PCSTR   Name;
}
media_tbl[VFD_MEDIA_MAX] =
{
    { 0,                        "" },                   //  VFD_MEDIA_NONE,
    { VFD_SECTOR_TO_BYTE(320),  "5.25\" 160KB" },       //  VFD_MEDIA_F5_160
    { VFD_SECTOR_TO_BYTE(360),  "5.25\" 180KB" },       //  VFD_MEDIA_F5_180
    { VFD_SECTOR_TO_BYTE(640),  "5.25\" 320KB" },       //  VFD_MEDIA_F5_320
    { VFD_SECTOR_TO_BYTE(720),  "5.25\" 360KB" },       //  VFD_MEDIA_F5_360
    { VFD_SECTOR_TO_BYTE(1280), "3.5\"  640KB" },       //  VFD_MEDIA_F3_640
    { VFD_SECTOR_TO_BYTE(1280), "5.25\" 640KB" },       //  VFD_MEDIA_F5_640
    { VFD_SECTOR_TO_BYTE(1440), "3.5\"  720KB" },       //  VFD_MEDIA_F3_720
    { VFD_SECTOR_TO_BYTE(1440), "5.25\" 720KB" },       //  VFD_MEDIA_F5_720
    { VFD_SECTOR_TO_BYTE(1640), "3.5\"  820KB" },       //  VFD_MEDIA_F3_820
    { VFD_SECTOR_TO_BYTE(2400), "3.5\"  1.2MB" },       //  VFD_MEDIA_F3_1P2
    { VFD_SECTOR_TO_BYTE(2400), "5.25\" 1.2MB" },       //  VFD_MEDIA_F5_1P2
    { VFD_SECTOR_TO_BYTE(2880), "3.5\"  1.44MB" },      //  VFD_MEDIA_F3_1P4
    { VFD_SECTOR_TO_BYTE(3360), "3.5\"  1.68MB DMF" },  //  VFD_MEDIA_F3_1P6
    { VFD_SECTOR_TO_BYTE(3444), "3.5\"  1.72MB DMF" },  //  VFD_MEDIA_F3_1P7
    { VFD_SECTOR_TO_BYTE(5760), "3.5\"  2.88MB"}        //  VFD_MEDIA_F3_2P8
};
 
//  Lookup the largest media to fit in a size
 
VFD_MEDIA WINAPI VfdLookupMedia(
    ULONG           nSize)
{
    VFD_MEDIA i;
 
    for (i = 1; i < VFD_MEDIA_MAX; i++) {
        if (nSize < media_tbl[i].Size) {
            break;
        }
    }
 
    return (--i);
}
 
//  Get media size (in bytes) of a media type
 
ULONG WINAPI VfdGetMediaSize(
    VFD_MEDIA       nMediaType)
{
    return nMediaType < VFD_MEDIA_MAX ? media_tbl[nMediaType].Size : 0;
}
 
//  Get media type name
 
PCSTR WINAPI VfdMediaTypeName(
    VFD_MEDIA       nMediaType)
{
    return nMediaType < VFD_MEDIA_MAX ? media_tbl[nMediaType].Name : NULL;
}