/*
	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;
}