vfdapi.h File Reference

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

Go to the source code of this file.

Macros
#define	VFD_NOT_INSTALLED   0xffffffff

Typedefs
typedef enum _VFD_OPERATION	VFD_OPERATION
typedef enum _VFD_OPERATION *	PVFD_OPERATION

Enumerations
enum	_VFD_OPERATION {   VFD_OPERATION_NONE , VFD_OPERATION_INSTALL , VFD_OPERATION_CONFIG , VFD_OPERATION_REMOVE ,   VFD_OPERATION_START , VFD_OPERATION_STOP , VFD_OPERATION_OPEN , VFD_OPERATION_SAVE ,   VFD_OPERATION_CLOSE , VFD_OPERATION_SETLINK , VFD_OPERATION_DELLINK , VFD_OPERATION_PROTECT ,   VFD_OPERATION_SHELL , VFD_OPERATION_MAX }

Functions
DWORD WINAPI	VfdInstallDriver (PCSTR sFileName, DWORD nStart)
DWORD WINAPI	VfdRemoveDriver ()
DWORD WINAPI	VfdConfigDriver (DWORD nStart)
DWORD WINAPI	VfdStartDriver (PDWORD pState)
DWORD WINAPI	VfdStopDriver (PDWORD pState)
DWORD WINAPI	VfdGetDriverConfig (PSTR sFileName, PDWORD pStart)
DWORD WINAPI	VfdGetDriverState (PDWORD pState)
HANDLE WINAPI	VfdOpenDevice (ULONG nTarget)
DWORD WINAPI	VfdGetDeviceNumber (HANDLE hDevice, PULONG pNumber)
DWORD WINAPI	VfdGetDeviceName (HANDLE hDevice, PCHAR pName, ULONG nLength)
DWORD WINAPI	VfdGetDriverVersion (HANDLE hDevice, PULONG pVersion)
DWORD WINAPI	VfdOpenImage (HANDLE hDevice, PCSTR sFileName, VFD_DISKTYPE nDiskType, VFD_MEDIA nMediaType, VFD_FLAGS nMediaFlags)
DWORD WINAPI	VfdCloseImage (HANDLE hDevice, BOOL bForce)
DWORD WINAPI	VfdGetImageInfo (HANDLE hDevice, PSTR sFileName, PVFD_DISKTYPE pDiskType, PVFD_MEDIA pMediaType, PVFD_FLAGS pMediaFlags, PVFD_FILETYPE pFileType, PULONG pImageSize)
DWORD WINAPI	VfdSaveImage (HANDLE hDevice, PCSTR sFileName, BOOL bOverWrite, BOOL bTruncate)
DWORD WINAPI	VfdFormatMedia (HANDLE hDevice)
DWORD WINAPI	VfdGetMediaState (HANDLE hDevice)
DWORD WINAPI	VfdWriteProtect (HANDLE hDevice, BOOL bProtect)
DWORD WINAPI	VfdDismountVolume (HANDLE hDevice, BOOL bForce)
DWORD WINAPI	VfdSetGlobalLink (HANDLE hDevice, CHAR cLetter)
DWORD WINAPI	VfdGetGlobalLink (HANDLE hDevice, PCHAR pLetter)
DWORD WINAPI	VfdSetLocalLink (HANDLE hDevice, CHAR cLetter)
DWORD WINAPI	VfdGetLocalLink (HANDLE hDevice, PCHAR pLetter)
CHAR WINAPI	VfdChooseLetter ()
BOOL WINAPI	VfdIsValidPlatform ()
UINT WINAPI	VfdGetNotifyMessage ()
DWORD WINAPI	VfdCheckDriverFile (PCSTR sFileName, PULONG pFileVersion)
DWORD WINAPI	VfdCheckImageFile (PCSTR sFileName, PDWORD pAttributes, PVFD_FILETYPE pFileType, PULONG pImageSize)
DWORD WINAPI	VfdCreateImageFile (PCSTR sFileName, VFD_MEDIA nMediaType, VFD_FILETYPE nFileType, BOOL bOverWrite)
VFD_MEDIA WINAPI	VfdLookupMedia (ULONG nSize)
ULONG WINAPI	VfdGetMediaSize (VFD_MEDIA nMediaType)
PCSTR WINAPI	VfdMediaTypeName (VFD_MEDIA nMediaType)
void WINAPI	VfdMakeFileDesc (PSTR pBuffer, ULONG nBufSize, VFD_FILETYPE nFileType, ULONG nFileSize, DWORD nFileAttr)
DWORD WINAPI	VfdRegisterHandlers ()
DWORD WINAPI	VfdUnregisterHandlers ()
DWORD WINAPI	VfdCheckHandlers ()
DWORD WINAPI	VfdGuiOpen (HWND hParent, ULONG nDevice)
DWORD WINAPI	VfdGuiSave (HWND hParent, ULONG nDevice)
DWORD WINAPI	VfdGuiClose (HWND hParent, ULONG nDevice)
DWORD WINAPI	VfdGuiFormat (HWND hParent, ULONG nDevice)
void WINAPI	VfdToolTip (HWND hParent, PCSTR sText, int pos_x, int pos_y, BOOL stick)
void WINAPI	VfdImageTip (HWND hParent, ULONG nDevice)

Macro Definition Documentation

VFD_NOT_INSTALLED

#define VFD_NOT_INSTALLED   0xffffffff

Definition at line 20 of file vfdapi.h.

Typedef Documentation

PVFD_OPERATION

typedef enum _VFD_OPERATION * PVFD_OPERATION

VFD_OPERATION

typedef enum _VFD_OPERATION VFD_OPERATION

Enumeration Type Documentation

_VFD_OPERATION

enum _VFD_OPERATION

Enumerator
VFD_OPERATION_NONE
VFD_OPERATION_INSTALL
VFD_OPERATION_CONFIG
VFD_OPERATION_REMOVE
VFD_OPERATION_START
VFD_OPERATION_STOP
VFD_OPERATION_OPEN
VFD_OPERATION_SAVE
VFD_OPERATION_CLOSE
VFD_OPERATION_SETLINK
VFD_OPERATION_DELLINK
VFD_OPERATION_PROTECT
VFD_OPERATION_SHELL
VFD_OPERATION_MAX

Definition at line 25 of file vfdapi.h.

                            {
    VFD_OPERATION_NONE,         //  No operation
    VFD_OPERATION_INSTALL,      //  The driver was installed
    VFD_OPERATION_CONFIG,       //  The driver config was changed
    VFD_OPERATION_REMOVE,       //  The driver was removed
    VFD_OPERATION_START,        //  The driver was started
    VFD_OPERATION_STOP,         //  The driver was stopped
    VFD_OPERATION_OPEN,         //  An image was opened
    VFD_OPERATION_SAVE,         //  An image was saved
    VFD_OPERATION_CLOSE,        //  An image was closed
    VFD_OPERATION_SETLINK,      //  A drive letter was created
    VFD_OPERATION_DELLINK,      //  A drive letter was removed
    VFD_OPERATION_PROTECT,      //  Write protect state was changed
    VFD_OPERATION_SHELL,        //  Shell extension was installed/removed
    VFD_OPERATION_MAX           //  Maximum value place holder
} VFD_OPERATION, *PVFD_OPERATION;

Function Documentation

VfdCheckDriverFile()

DWORD WINAPI VfdCheckDriverFile	(	PCSTR	sFileName,
		PULONG	pFileVersion
	)

Definition at line 2867 of file vfdctl.c.

{
#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;
}

Referenced by CheckDriver(), Status(), and VfdInstallDriver().

VfdCheckHandlers()

DWORD WINAPI VfdCheckHandlers

(

)

Definition at line 393 of file vfdshutil.cpp.

{
    TCHAR   buf[MAX_PATH];
    TCHAR   guid_str[40];
    DWORD   temp;
    DWORD   ret;
 
    MakeGuidString(guid_str, CLSID_VfdShellExt);
 
    sprintf(buf, "CLSID\\%s", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    temp = sizeof(buf);
 
    ret = RegQueryValue(HKEY_CLASSES_ROOT, buf, buf, (PLONG)&temp);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    if (_stricmp(buf, VFDEXT_DESCRIPTION)) {
        return ERROR_PATH_NOT_FOUND;
    }
 
    return ERROR_SUCCESS;
}

Referenced by Shell(), and Status().

VfdCheckImageFile()

DWORD WINAPI VfdCheckImageFile	(	PCSTR	sFileName,
		PDWORD	pAttributes,
		PVFD_FILETYPE	pFileType,
		PULONG	pImageSize
	)

Definition at line 3035 of file vfdctl.c.

{
#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;
}

Referenced by CVfdShExt::DoVfdDrop(), OnImage(), OnTarget(), Open(), and Save().

VfdChooseLetter()

CHAR WINAPI VfdChooseLetter

(

)

Definition at line 3205 of file vfdctl.c.

{
    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;
}

Referenced by Link(), and Open().

VfdCloseImage()

DWORD WINAPI VfdCloseImage	(	HANDLE	hDevice,
		BOOL	bForce
	)

Definition at line 1702 of file vfdctl.c.

{
#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;
}

VfdConfigDriver()

DWORD WINAPI VfdConfigDriver

(

DWORD

nStart

)

Definition at line 468 of file vfdctl.c.

{
#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;
}

Referenced by Config().

VfdCreateImageFile()

DWORD WINAPI VfdCreateImageFile	(	PCSTR	sFileName,
		VFD_MEDIA	nMediaType,
		VFD_FILETYPE	nFileType,
		BOOL	bOverWrite
	)

Definition at line 3126 of file vfdctl.c.

{
#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;
}

Referenced by OnOK(), and Open().

VfdDismountVolume()

DWORD WINAPI VfdDismountVolume	(	HANDLE	hDevice,
		BOOL	bForce
	)

Definition at line 2629 of file vfdctl.c.

{
#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;
}

Referenced by Format(), OnOK(), Save(), and VfdGuiFormat().

VfdFormatMedia()

DWORD WINAPI VfdFormatMedia

(

HANDLE

hDevice

)

Definition at line 2523 of file vfdctl.c.

{
#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;
}

Referenced by Format(), and VfdGuiFormat().

VfdGetDeviceName()

DWORD WINAPI VfdGetDeviceName	(	HANDLE	hDevice,
		PCHAR	pName,
		ULONG	nLength
	)

Definition at line 2396 of file vfdctl.c.

{
#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;
}

Referenced by VfdGetLocalLink(), and VfdSetLocalLink().

VfdGetDeviceNumber()

DWORD WINAPI VfdGetDeviceNumber	(	HANDLE	hDevice,
		PULONG	pNumber
	)

Definition at line 2359 of file vfdctl.c.

{
#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;
}

Referenced by CVfdShExt::Initialize(), Link(), PrintImageInfo(), Unlink(), VfdCloseImage(), VfdOpenImage(), VfdSetGlobalLink(), VfdSetLocalLink(), and VfdWriteProtect().

VfdGetDriverConfig()

DWORD WINAPI VfdGetDriverConfig	(	PSTR	sFileName,
		PDWORD	pStart
	)

Definition at line 959 of file vfdctl.c.

{
#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;
}

Referenced by CheckDriver(), Status(), and VfdRemoveDriver().

VfdGetDriverState()

DWORD WINAPI VfdGetDriverState

(

PDWORD

pState

)

Definition at line 1121 of file vfdctl.c.

{
#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;
}

Referenced by Install(), ProcessCommandLine(), and Remove().

VfdGetDriverVersion()

DWORD WINAPI VfdGetDriverVersion	(	HANDLE	hDevice,
		PULONG	pVersion
	)

Definition at line 2446 of file vfdctl.c.

{
#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;
}

Referenced by Status(), and VfdOpenDevice().

VfdGetGlobalLink()

DWORD WINAPI VfdGetGlobalLink	(	HANDLE	hDevice,
		PCHAR	pLetter
	)

Definition at line 2114 of file vfdctl.c.

{
#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;
}

Referenced by Open(), PrintDriveLetter(), VfdCloseImage(), VfdGetLocalLink(), VfdOpenImage(), VfdSetGlobalLink(), VfdSetLocalLink(), VfdStartDriver(), and VfdStopDriver().

VfdGetImageInfo()

DWORD WINAPI VfdGetImageInfo	(	HANDLE	hDevice,
		PSTR	sFileName,
		PVFD_DISKTYPE	pDiskType,
		PVFD_MEDIA	pMediaType,
		PVFD_FLAGS	pMediaFlags,
		PVFD_FILETYPE	pFileType,
		PULONG	pImageSize
	)

Definition at line 1839 of file vfdctl.c.

{
#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;
}

Referenced by Close(), PrintImageInfo(), Save(), UpdateImageInfo(), VfdGuiClose(), VfdGuiSave(), and VfdImageTip().

VfdGetLocalLink()

DWORD WINAPI VfdGetLocalLink	(	HANDLE	hDevice,
		PCHAR	pLetter
	)

Definition at line 2281 of file vfdctl.c.

{
#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;
}

Referenced by Open(), PrintDriveLetter(), VfdCloseImage(), VfdOpenImage(), VfdSetGlobalLink(), VfdSetLocalLink(), and VfdStopDriver().

VfdGetMediaSize()

ULONG WINAPI VfdGetMediaSize

(

VFD_MEDIA

nMediaType

)

Definition at line 3272 of file vfdctl.c.

{
    return nMediaType < VFD_MEDIA_MAX ? media_tbl[nMediaType].Size : 0;
}

Referenced by OnMediaType(), OnTarget(), Open(), VfdCreateImageFile(), and VfdOpenImage().

VfdGetMediaState()

DWORD WINAPI VfdGetMediaState

(

HANDLE

hDevice

)

Definition at line 1949 of file vfdctl.c.

{
#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;
}

Referenced by CVfdShExt::DoVfdProtect(), Format(), Open(), Protect(), and CVfdShExt::QueryContextMenu().

VfdGetNotifyMessage()

UINT WINAPI VfdGetNotifyMessage

(

)

Definition at line 115 of file vfdlib.c.

{
    return g_nNotifyMsg;
}

VfdGuiClose()

DWORD WINAPI VfdGuiClose	(	HWND	hParent,
		ULONG	nDevice
	)

Definition at line 114 of file vfdguiut.c.

{
    HANDLE          hDevice;
    SAVE_PARAM      param;
    CHAR            path[MAX_PATH];
    HCURSOR         hourglass;
    DWORD           ret;
    int             reply;
 
    VFDTRACE(0, ("VfdGuiClose()\n"));
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    //  get current image information
 
    ret = VfdGetImageInfo(
        hDevice,
        path,
        &param.DiskType,
        &param.MediaType,
        &param.MediaFlags,
        &param.FileType,
        &param.ImageSize);
 
    if (ret != ERROR_SUCCESS) {
        CloseHandle(hDevice);
        return ret;
    }
 
    param.hDevice = hDevice;
    param.ImageName = path;
 
    //  check if RAM image is modified
 
    if (param.MediaFlags & VFD_FLAG_DATA_MODIFIED) {
        PSTR msg = ModuleMessage(MSG_MEDIA_MODIFIED);
 
        for (;;) {
            reply = MessageBox(hParent, msg ? msg : "save?",
                VFD_MSGBOX_TITLE, MB_ICONQUESTION | MB_YESNOCANCEL);
 
            if (reply != IDYES) {
                break;
            }
 
            if (GuiSaveParam(hParent, &param) == ERROR_SUCCESS) {
                break;
            }
        }
 
        if (msg) {
            LocalFree(msg);
        }
 
        if (reply == IDCANCEL) {
            CloseHandle(hDevice);
            return ERROR_CANCELLED;
        }
    }
 
    //  close the image
 
    hourglass = LoadCursor(NULL, IDC_WAIT);
 
    for (;;) {
 
        //  show the hourglass cursor
 
        HCURSOR original = SetCursor(hourglass);
 
        //  close the current image
 
        ret = VfdCloseImage(hDevice, FALSE);
 
        //  restore the original cursor
 
        SetCursor(original);
 
        if (ret != ERROR_ACCESS_DENIED) {
            //  success or errors other than access denied
            break;
        }
 
        if (IS_WINDOWS_NT()) {
 
            //  Windows NT -- cannot force close
            //  show retry / cancel message box
 
            PSTR msg = ModuleMessage(MSG_UNMOUNT_FAILED);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_RETRYCANCEL);
 
            if (msg) {
                LocalFree(msg);
            }
        }
        else {
 
            //  Windows 2000 and later -- possible to force
            //  show cancel / retry / continue message box
 
            PSTR msg = ModuleMessage(MSG_UNMOUNT_CONFIRM);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_CANCELTRYCONTINUE);
 
            if (msg) {
                LocalFree(msg);
            }
 
            if (reply == IDCONTINUE) {
 
                //  try forced close
 
                ret = VfdCloseImage(hDevice, TRUE);
            }
        }
 
        if (reply == IDCANCEL) {
            ret = ERROR_CANCELLED;
            break;
        }
        else if (reply == IDCONTINUE) {
 
            //  try forced close
 
            ret = VfdCloseImage(hDevice, TRUE);
            break;
        }
    }
 
    CloseHandle(hDevice);
 
    return ret;
}

Referenced by CVfdShExt::DoVfdClose().

VfdGuiFormat()

DWORD WINAPI VfdGuiFormat	(	HWND	hParent,
		ULONG	nDevice
	)

Definition at line 262 of file vfdguiut.c.

{
    HANDLE          hDevice;
    ULONG           ret;
    PSTR            msg;
 
    msg = ModuleMessage(MSG_FORMAT_WARNING);
 
    ret = MessageBox(hParent,
        msg ? msg : "Format?",
        VFD_MSGBOX_TITLE,
        MB_ICONEXCLAMATION | MB_OKCANCEL);
 
    if (msg) {
        LocalFree(msg);
    }
 
    if (ret == IDCANCEL) {
        MessageBox(hParent,
            SystemMessage(ERROR_CANCELLED),
            VFD_MSGBOX_TITLE, MB_ICONSTOP);
 
        return ERROR_CANCELLED;
    }
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        ret = GetLastError();
    }
    else {
        HCURSOR original;
 
retry:
        original = SetCursor(LoadCursor(NULL, IDC_WAIT));
 
        ret = VfdDismountVolume(hDevice, FALSE);
 
        if (ret == ERROR_ACCESS_DENIED) {
            PSTR msg;
            int reply;
 
            SetCursor(original);
 
            msg = ModuleMessage(MSG_UNMOUNT_CONFIRM);
 
            reply = MessageBox(
                hParent, msg ? msg : "retry", VFD_MSGBOX_TITLE,
                MB_ICONEXCLAMATION | MB_CANCELTRYCONTINUE);
 
            if (msg) {
                LocalFree(msg);
            }
 
            if (reply == IDRETRY) {
                goto retry;
            }
            else if (reply == IDCANCEL) {
                ret = ERROR_CANCELLED;
            }
            else {
                VfdDismountVolume(hDevice, TRUE);
                ret = ERROR_SUCCESS;
            }
        }
 
        if (ret == ERROR_SUCCESS) {
            ret = VfdFormatMedia(hDevice);
        }
 
        SetCursor(original);
 
        CloseHandle(hDevice);
    }
 
    MessageBox(hParent,
        SystemMessage(ret),
        VFD_MSGBOX_TITLE,
        ret == ERROR_SUCCESS ? MB_ICONINFORMATION : MB_ICONSTOP);
 
    return ret;
}

Referenced by VfdPageDlgProc().

VfdGuiOpen()

DWORD WINAPI VfdGuiOpen	(	HWND	hParent,
		ULONG	nDevice
	)

Definition at line 71 of file vfdguiopen.c.

{
    switch (DialogBoxParam(
        g_hDllModule,
        MAKEINTRESOURCE(IDD_OPENDIALOG),
        hParent,
        OpenDialogProc,
        nDevice))
    {
    case IDOK:
        return ERROR_SUCCESS;
 
    case IDCANCEL:
        return ERROR_CANCELLED;
 
    default:
        return GetLastError();
    }
}

Referenced by CVfdShExt::DoVfdOpen().

VfdGuiSave()

DWORD WINAPI VfdGuiSave	(	HWND	hParent,
		ULONG	nDevice
	)

Definition at line 58 of file vfdguisave.c.

{
    SAVE_PARAM      param;
    CHAR            path[MAX_PATH];
    DWORD           ret;
 
    //  open the source device
 
    param.hDevice = VfdOpenDevice(nDevice);
 
    if (param.hDevice == INVALID_HANDLE_VALUE) {
        return GetLastError();
    }
 
    //  get current image information
 
    param.ImageName = path;
 
    ret = VfdGetImageInfo(
        param.hDevice,
        param.ImageName,
        &param.DiskType,
        &param.MediaType,
        &param.MediaFlags,
        &param.FileType,
        &param.ImageSize);
 
    if (ret == ERROR_SUCCESS) {
 
        //  show dialog box
 
        ret = GuiSaveParam(hParent, &param);
    }
 
    //  close the source device
 
    CloseHandle(param.hDevice);
 
    return ret;
}

Referenced by CVfdShExt::DoVfdSave().

VfdImageTip()

void WINAPI VfdImageTip	(	HWND	hParent,
		ULONG	nDevice
	)

Definition at line 266 of file vfdguitip.c.

{
    HANDLE          hDevice;
    PSTR            info_str    = NULL;
    PSTR            type_str    = NULL;
    PSTR            prot_str    = NULL;
    PCSTR           media_str   = NULL;
    CHAR            path[MAX_PATH];
    CHAR            desc[MAX_PATH];
    VFD_DISKTYPE    disk_type;
    VFD_MEDIA       media_type;
    VFD_FLAGS       media_flags;
    VFD_FILETYPE    file_type;
    ULONG           image_size;
    DWORD           file_attr;
    ULONG           ret;
 
    hDevice = VfdOpenDevice(nDevice);
 
    if (hDevice == INVALID_HANDLE_VALUE) {
        VfdToolTip(hParent,
            SystemMessage(GetLastError()), -1, -1, FALSE);
        return;
    }
 
    ret = VfdGetImageInfo(
        hDevice,
        path,
        &disk_type,
        &media_type,
        &media_flags,
        &file_type,
        &image_size);
 
    CloseHandle(hDevice);
 
    if (ret != ERROR_SUCCESS) {
        VfdToolTip(hParent, SystemMessage(ret), -1, -1, FALSE);
        return;
    }
 
    if (path[0]) {
        file_attr = GetFileAttributes(path);
    }
    else {
        if (disk_type != VFD_DISKTYPE_FILE) {
            strcpy(path, "<RAM>");
        }
        file_attr = 0;
    }
 
    VfdMakeFileDesc(desc, sizeof(desc),
        file_type, image_size, file_attr);
 
    if (disk_type == VFD_DISKTYPE_FILE) {
        type_str = "FILE";
    }
    else {
        type_str = "RAM";
    }
 
    media_str = VfdMediaTypeName(media_type);
 
    if (media_flags & VFD_FLAG_WRITE_PROTECTED) {
        prot_str = ModuleMessage(MSG_WRITE_PROTECTED);
    }
    else {
        prot_str = ModuleMessage(MSG_WRITE_ALLOWED);
    }
 
    info_str = ModuleMessage(
        MSG_IMAGE_INFOTIP,
        path,
        desc,
        type_str ? type_str : "",
        media_str ? media_str : "",
        prot_str ? prot_str : "");
 
    if (info_str) {
        VfdToolTip(hParent, info_str, -1, -1, FALSE);
        LocalFree(info_str);
    }
 
    if (prot_str) {
        LocalFree(prot_str);
    }
}

Referenced by CVfdShExt::InvokeCommand().

VfdInstallDriver()

DWORD WINAPI VfdInstallDriver	(	PCSTR	sFileName,
		DWORD	nStart
	)

Definition at line 241 of file vfdctl.c.

{
#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;
}

Referenced by Install().

VfdIsValidPlatform()

BOOL WINAPI VfdIsValidPlatform

(

)

Definition at line 87 of file vfdlib.c.

{
    BOOL (WINAPI *pfnIsWow64Process)(HANDLE, PBOOL);
    BOOL wow64;
 
    if (GetVersion() & 0x80000000) {
        return FALSE;       // doesn't work on Win9x
    }
 
    pfnIsWow64Process = (BOOL (WINAPI *)(HANDLE, PBOOL))
        GetProcAddress(GetModuleHandle("kernel32.dll"), "IsWow64Process");
 
    if (pfnIsWow64Process == NULL) {
        return TRUE;        // NT4 or 2000 -- assured to be 32 bit
    }
 
    wow64 = FALSE;
 
    if (!pfnIsWow64Process(GetCurrentProcess(), &wow64)) {
        return FALSE;
    }
 
    return !wow64;
}

Referenced by main().

VfdLookupMedia()

VFD_MEDIA WINAPI VfdLookupMedia

(

ULONG

nSize

)

Definition at line 3256 of file vfdctl.c.

{
    VFD_MEDIA i;
 
    for (i = 1; i < VFD_MEDIA_MAX; i++) {
        if (nSize < media_tbl[i].Size) {
            break;
        }
    }
 
    return (--i);
}

Referenced by CVfdShExt::DoVfdDrop(), OnImage(), and Open().

VfdMakeFileDesc()

void WINAPI VfdMakeFileDesc	(	PSTR	pBuffer,
		ULONG	nBufSize,
		VFD_FILETYPE	nFileType,
		ULONG	nFileSize,
		DWORD	nFileAttr
	)

Definition at line 376 of file vfdguiut.c.

{
    PSTR            type_str;
    PSTR            size_str;
    PSTR            attr_ro;
    PSTR            attr_enc;
    PSTR            attr_cmp;
 
    ZeroMemory(pBuffer, nBufSize);
 
    switch (nFileType) {
    case VFD_FILETYPE_RAW:
        type_str = ModuleMessage(MSG_FILETYPE_RAW);
        break;
 
    case VFD_FILETYPE_ZIP:
        type_str = ModuleMessage(MSG_FILETYPE_ZIP);
        break;
 
    default:
        type_str = NULL;
    }
 
    if (nFileSize == INVALID_FILE_SIZE) {
        size_str = ModuleMessage(MSG_DESC_NEW_FILE);
    }
    else {
        CHAR buf[20], buf2[20];
        size_str = ModuleMessage(MSG_DESC_FILESIZE, 
            FormatSizeBytes(nFileSize, buf),
            FormatSizeUnits(nFileSize, buf2));
    }
 
    attr_ro = NULL;
    attr_cmp = NULL;
    attr_enc = NULL;
 
    if (nFileAttr != INVALID_FILE_ATTRIBUTES) {
        if (nFileAttr & FILE_ATTRIBUTE_READONLY) {
            attr_ro = ModuleMessage(MSG_ATTR_READONLY);
        }
 
        if (nFileAttr & FILE_ATTRIBUTE_COMPRESSED) {
            attr_cmp = ModuleMessage(MSG_ATTR_COMPRESSED);
        }
 
        if (nFileAttr & FILE_ATTRIBUTE_ENCRYPTED) {
            attr_enc = ModuleMessage(MSG_ATTR_ENCRYPTED);
        }
    }
 
    _snprintf(pBuffer, nBufSize - 1, "%s %s %s %s %s",
        type_str ? type_str : "",
        size_str ? size_str : "",
        attr_ro  ? attr_ro  : "",
        attr_cmp ? attr_cmp : "",
        attr_enc ? attr_enc : "");
 
    if (type_str) {
        LocalFree(type_str);
    }
    if (size_str) {
        LocalFree(size_str);
    }
    if (attr_ro) {
        LocalFree(attr_ro);
    }
    if (attr_cmp) {
        LocalFree(attr_cmp);
    }
    if (attr_enc) {
        LocalFree(attr_enc);
    }
}

Referenced by OnImage(), OnTarget(), PrintImageInfo(), UpdateImageInfo(), and VfdImageTip().

VfdMediaTypeName()

PCSTR WINAPI VfdMediaTypeName

(

VFD_MEDIA

nMediaType

)

Definition at line 3280 of file vfdctl.c.

{
    return nMediaType < VFD_MEDIA_MAX ? media_tbl[nMediaType].Name : NULL;
}

Referenced by OnInit(), Open(), PrintImageInfo(), UpdateImageInfo(), VfdImageTip(), and VfdOpenImage().

VfdOpenDevice()

HANDLE WINAPI VfdOpenDevice

(

ULONG

nTarget

)

Definition at line 1215 of file vfdctl.c.

{
#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;
}

Referenced by CheckDriver(), Close(), CVfdShExt::DoVfdDrop(), CVfdShExt::DoVfdProtect(), Format(), CVfdShExt::Initialize(), Link(), OnOK(), Open(), Protect(), CVfdShExt::QueryContextMenu(), Save(), Status(), Unlink(), UpdateImageInfo(), VfdGuiClose(), VfdGuiFormat(), VfdGuiSave(), VfdImageTip(), VfdStartDriver(), and VfdStopDriver().

VfdOpenImage()

DWORD WINAPI VfdOpenImage	(	HANDLE	hDevice,
		PCSTR	sFileName,
		VFD_DISKTYPE	nDiskType,
		VFD_MEDIA	nMediaType,
		VFD_FLAGS	nMediaFlags
	)

Definition at line 1301 of file vfdctl.c.

{
#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;
}

VfdRegisterHandlers()

DWORD WINAPI VfdRegisterHandlers

(

)

Definition at line 100 of file vfdshutil.cpp.

{
    TCHAR   buf[MAX_PATH];
    TCHAR   guid_str[40];
    HKEY    hKey;
    DWORD   temp;
    DWORD   ret;
 
    MakeGuidString(guid_str, CLSID_VfdShellExt);
 
    //
    //  Register the GUID in the CLSID subtree
    //
    sprintf(buf, "CLSID\\%s", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    ret = RegCreateKeyEx(
        HKEY_CLASSES_ROOT, buf, 0, NULL,
        0, KEY_ALL_ACCESS, NULL, &hKey, &temp);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    if (temp == REG_OPENED_EXISTING_KEY) {
        temp = sizeof(buf);
 
        ret = RegQueryValueEx(
            hKey, NULL, NULL, NULL, (PBYTE)buf, &temp);
 
        if (ret != ERROR_SUCCESS) {
            RegCloseKey(hKey);
            return ret;
        }
 
        if (_stricmp(buf, VFDEXT_DESCRIPTION)) {
            RegCloseKey(hKey);
            return ERROR_FILE_EXISTS;
        }
    }
    else {
 
        VFDTRACE(0, ("@=" VFDEXT_DESCRIPTION "\n"));
 
        ret = RegSetValueEx(hKey, NULL, NULL, REG_SZ,
            (PBYTE)VFDEXT_DESCRIPTION, sizeof(VFDEXT_DESCRIPTION));
 
        RegCloseKey(hKey);
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
    }
 
    //
    //  Register the executable path
    //
    sprintf(buf, "CLSID\\%s\\InProcServer32", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    ret = RegCreateKeyEx(
        HKEY_CLASSES_ROOT, buf, 0, NULL,
        0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    temp = GetModuleFileName(g_hDllModule, buf, sizeof(buf));
 
    VFDTRACE(0, ("@=%s\n", buf));
 
    ret = RegSetValueEx(
        hKey, NULL, NULL, REG_SZ, (PBYTE)buf, temp + 1);
 
    if (ret != ERROR_SUCCESS) {
        RegCloseKey(hKey);
        return ret;
    }
 
    VFDTRACE(0, ("ThreadingModel=Apartment\n"));
 
    ret = RegSetValueEx(hKey, "ThreadingModel", NULL, REG_SZ,
        (PBYTE)"Apartment", sizeof("Apartment"));
 
    RegCloseKey(hKey);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //
    //  Register context menu handler
    //
    VFDTRACE(0, ("HKCR\\" VFDEXT_MENU_REGKEY "\n"));
 
    ret = RegCreateKeyEx(
        HKEY_CLASSES_ROOT, VFDEXT_MENU_REGKEY, 0, NULL,
        0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    VFDTRACE(0, ("@=%s\n", guid_str));
 
    ret = RegSetValueEx(hKey, NULL, NULL, REG_SZ,
        (PBYTE)guid_str, strlen(guid_str) + 1);
 
    RegCloseKey(hKey);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //
    //  Register Drag&Drop handler
    //
    if (!IS_WINDOWS_NT()) {
        //
        //  Windows NT does not support Drag&Drop handlers ???
        //
        VFDTRACE(0, ("HKCR\\" VFDEXT_DND_REGKEY "\n"));
 
        ret = RegCreateKeyEx(
            HKEY_CLASSES_ROOT, VFDEXT_DND_REGKEY, 0, NULL,
            0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
 
        VFDTRACE(0, ("@=%s\n", guid_str));
 
        ret = RegSetValueEx(hKey, NULL, NULL, REG_SZ,
            (PBYTE)guid_str, strlen(guid_str) + 1);
 
        RegCloseKey(hKey);
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
    }
 
    //
    //  Register property sheet handler
    //
    VFDTRACE(0, ("HKCR\\" VFDEXT_PROP_REGKEY "\n"));
 
    ret = RegCreateKeyEx(
        HKEY_CLASSES_ROOT, VFDEXT_PROP_REGKEY, 0, NULL,
        0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    VFDTRACE(0, ("@=%s\n", guid_str));
 
    ret = RegSetValueEx(hKey, NULL, NULL, REG_SZ,
        (PBYTE)guid_str, strlen(guid_str) + 1);
 
    RegCloseKey(hKey);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    //
    //  Register approved extensions entry
    //
    VFDTRACE(0, ("HKLM\\" REGKEY_APPROVED "\n"));
 
    ret = RegCreateKeyEx(
        HKEY_LOCAL_MACHINE, REGKEY_APPROVED,
        0, NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    VFDTRACE(0,
        ("%s=" VFDEXT_DESCRIPTION "\n", guid_str));
 
    ret = RegSetValueEx(hKey, guid_str, NULL, REG_SZ,
        (PBYTE)VFDEXT_DESCRIPTION, sizeof(VFDEXT_DESCRIPTION));
 
    RegCloseKey(hKey);
 
    return ret;
}

Referenced by Shell().

VfdRemoveDriver()

DWORD WINAPI VfdRemoveDriver

(

)

Definition at line 557 of file vfdctl.c.

{
#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;
}

Referenced by Remove().

VfdSaveImage()

DWORD WINAPI VfdSaveImage	(	HANDLE	hDevice,
		PCSTR	sFileName,
		BOOL	bOverWrite,
		BOOL	bTruncate
	)

Definition at line 2685 of file vfdctl.c.

{
#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;
}

Referenced by OnOK(), and Save().

VfdSetGlobalLink()

DWORD WINAPI VfdSetGlobalLink	(	HANDLE	hDevice,
		CHAR	cLetter
	)

Definition at line 1984 of file vfdctl.c.

{
#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;
    }
}

Referenced by Link(), and Unlink().

VfdSetLocalLink()

DWORD WINAPI VfdSetLocalLink	(	HANDLE	hDevice,
		CHAR	cLetter
	)

Definition at line 2154 of file vfdctl.c.

{
#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;
    }
}

Referenced by Link(), Open(), Unlink(), and VfdStopDriver().

VfdStartDriver()

DWORD WINAPI VfdStartDriver

(

PDWORD

pState

)

Definition at line 647 of file vfdctl.c.

{
#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;
}

Referenced by Start().

VfdStopDriver()

DWORD WINAPI VfdStopDriver

(

PDWORD

pState

)

Definition at line 801 of file vfdctl.c.

{
#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;
}

Referenced by Stop().

VfdToolTip()

void WINAPI VfdToolTip	(	HWND	hParent,
		PCSTR	sText,
		int	pos_x,
		int	pos_y,
		BOOL	stick
	)

Definition at line 134 of file vfdguitip.c.

{
#ifndef __REACTOS__
    HWND            hWnd;
#endif
    WNDCLASS        wc = {0};
    LOGFONT         lf;
    HFONT           font;
    HDC             dc;
    int             len;
    SIZE            sz;
    RECT            rc;
    int             scr_x;
    int             scr_y;
 
    //
    //  Register Window Class
    //
 
    wc.lpfnWndProc      = ToolTipProc;
    wc.hInstance        = g_hDllModule;
    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)(COLOR_INFOBK + 1);
    wc.lpszClassName    = VFD_INFOTIP_WNDCLASS;
 
    RegisterClass(&wc);
 
    //
    //  Create Tool Tip Font (== Icon title font)
    //
 
    SystemParametersInfo(
        SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0);
 
    font = CreateFontIndirect(&lf);
 
    //
    //  Calculate Tool Tip Window size
    //
 
    dc = GetDC(hParent);
 
    SelectObject(dc, font);
 
    len = strlen(sText);
 
    GetTextExtentPoint32(dc, sText, len, &sz);
 
    rc.left     = 0;
    rc.top      = 0;
    rc.right    = sz.cx;
    rc.bottom   = sz.cy;
 
    DrawText(dc, sText, len, &rc, DT_CALCRECT | DT_LEFT | DT_TOP);
 
    ReleaseDC(hParent, dc);
 
    sz.cx = rc.right - rc.left + 16;
    sz.cy = rc.bottom - rc.top + 16;
 
    //
    //  Decide the window position
    //
    if (pos_x == -1 || pos_y == -1) {
        //
        //  Use current cursor position
        //
        POINT   pt;
 
        GetCursorPos(&pt);
 
        pos_x = pt.x - (sz.cx / 2);
        pos_y = pt.y - (sz.cy / 2);
    }
    else {
        pos_x = pos_x - (sz.cx / 2);
    }
 
    //
    //  make sure the tip window fits in visible area
    //
    scr_x = GetSystemMetrics(SM_CXSCREEN);
    scr_y = GetSystemMetrics(SM_CYSCREEN);
 
    if (pos_x < 0) {
        pos_x = 0;
    }
    if (pos_x + sz.cx > scr_x) {
        pos_x = scr_x - sz.cx;
    }
    if (pos_y < 0) {
        pos_y = 0;
    }
    if (pos_y + sz.cy > scr_y) {
        pos_y = scr_y - sz.cy;
    }
 
    //
    //  Create the tool tip window
    //
#ifndef __REACTOS__
    hWnd = CreateWindowEx(
#else
    CreateWindowEx(
#endif
        stick ? 0 : WS_EX_TOPMOST,
        VFD_INFOTIP_WNDCLASS,
        sText,
        WS_BORDER | WS_POPUP | WS_VISIBLE,
        pos_x, pos_y,
        sz.cx, sz.cy,
        hParent,
        NULL,
        NULL,
        (PVOID)font);
 
    //
    //  Give focus if it is not a stick tool-tip
    //
    if (!stick) {
        SetFocus(hParent);
    }
}

Referenced by ShowHelpWindow(), and VfdImageTip().

VfdUnregisterHandlers()

DWORD WINAPI VfdUnregisterHandlers

(

)

Definition at line 297 of file vfdshutil.cpp.

{
    TCHAR   buf[MAX_PATH];
    TCHAR   guid_str[40];
    HKEY    hKey;
    DWORD   temp;
    DWORD   ret;
 
    MakeGuidString(guid_str, CLSID_VfdShellExt);
 
    sprintf(buf, "CLSID\\%s", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    temp = sizeof(buf);
 
    ret = RegQueryValue(HKEY_CLASSES_ROOT, buf, buf, (PLONG)&temp);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    if (_stricmp(buf, VFDEXT_DESCRIPTION)) {
        return ERROR_PATH_NOT_FOUND;
    }
 
    sprintf(buf, "CLSID\\%s\\InProcServer32", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    ret = RegDeleteKey(HKEY_CLASSES_ROOT, buf);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    sprintf(buf, "CLSID\\%s", guid_str);
 
    VFDTRACE(0, ("HKCR\\%s\n", buf));
 
    ret = RegDeleteKey(HKEY_CLASSES_ROOT, buf);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    VFDTRACE(0, ("HKCR\\" VFDEXT_MENU_REGKEY "\n"));
 
    ret = RegDeleteKey(HKEY_CLASSES_ROOT, VFDEXT_MENU_REGKEY);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    if (!IS_WINDOWS_NT()) {
 
        //  Windows NT doesn't support Drag & Drop handlers ???
 
        VFDTRACE(0, ("HKCR\\" VFDEXT_DND_REGKEY "\n"));
 
        ret = RegDeleteKey(HKEY_CLASSES_ROOT, VFDEXT_DND_REGKEY);
 
        if (ret != ERROR_SUCCESS) {
            return ret;
        }
    }
 
    VFDTRACE(0, ("HKCR\\" VFDEXT_PROP_REGKEY "\n"));
 
    ret = RegDeleteKey(HKEY_CLASSES_ROOT, VFDEXT_PROP_REGKEY);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    VFDTRACE(0, ("HKLM\\" REGKEY_APPROVED "\n"));
 
    ret = RegCreateKeyEx(
        HKEY_LOCAL_MACHINE,
        REGKEY_APPROVED,
        0, NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
 
    if (ret != ERROR_SUCCESS) {
        return ret;
    }
 
    ret = RegDeleteValue(hKey, guid_str);
 
    RegCloseKey(hKey);
 
    return ret;
}

Referenced by Shell().

VfdWriteProtect()

DWORD WINAPI VfdWriteProtect	(	HANDLE	hDevice,
		BOOL	bProtect
	)

Definition at line 2484 of file vfdctl.c.

{
#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;
}

Referenced by CVfdShExt::DoVfdProtect(), Protect(), and VfdOpenImage().