vfdlib.h File Reference

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

Go to the source code of this file.

Classes
struct	_SAVE_PARAM

Macros
#define	VFD_LIBRARY_FILENAME   "vfd.dll"
#define	VFD_NOTIFY_MESSAGE   "VfdNotifyMessage"
#define	VFD_MSGBOX_TITLE   "Virtual Floppy Drive"
#define	VFDEXT_DESCRIPTION   "VFD shell extension"
#define	VFDEXT_MENU_REGKEY   "Drive\\shellex\\ContextMenuHandlers\\VFD"
#define	VFDEXT_DND_REGKEY   "Drive\\shellex\\DragDropHandlers\\VFD"
#define	VFDEXT_PROP_REGKEY   "Drive\\shellex\\PropertySheetHandlers\\VFD"
#define	VFDEXT_INFO_REGKEY   "Drive\\shellex\\{00021500-0000-0000-C000-000000000046}"
#define	IS_WINDOWS_NT()   ((GetVersion() & 0xff) < 5)
#define	VFDTRACE(LEVEL, STRING)
#define	INVALID_FILE_ATTRIBUTES   ((DWORD)-1)

Typedefs
typedef struct _SAVE_PARAM	SAVE_PARAM
typedef struct _SAVE_PARAM	PSAVE_PARAM
typedef const SAVE_PARAM	CSAVE_PARAM
typedef const SAVE_PARAM *	PCSAVE_PARAM

Functions
DWORD	FormatBufferFat (PUCHAR pBuffer, ULONG nSectors)
DWORD	ExtractZipInfo (HANDLE hFile, ULONG *pSize)
DWORD	ExtractZipImage (HANDLE hFile, PUCHAR *pBuffer, PULONG pLength)
DWORD	GuiSaveParam (HWND hParent, PCSAVE_PARAM pParam)
void	ShowContextMenu (HWND hDlg, HWND hCtl, LPARAM lParam)
void	ShowHelpWindow (HWND hDlg, UINT nCtl)
void	SetControlText (HWND hWnd, UINT nCtrl, DWORD nMsg)
PCSTR	SystemMessage (DWORD nError)
PSTR	ModuleMessage (DWORD nFormat,...)

Variables
HINSTANCE	g_hDllModule
UINT	g_cDllRefCnt
UINT	g_nNotifyMsg

Macro Definition Documentation

INVALID_FILE_ATTRIBUTES

#define INVALID_FILE_ATTRIBUTES   ((DWORD)-1)

Definition at line 174 of file vfdlib.h.

IS_WINDOWS_NT

#define IS_WINDOWS_NT

(

)

((GetVersion() & 0xff) < 5)

Definition at line 142 of file vfdlib.h.

VFD_LIBRARY_FILENAME

#define VFD_LIBRARY_FILENAME   "vfd.dll"

Definition at line 17 of file vfdlib.h.

VFD_MSGBOX_TITLE

#define VFD_MSGBOX_TITLE   "Virtual Floppy Drive"

Definition at line 53 of file vfdlib.h.

VFD_NOTIFY_MESSAGE

#define VFD_NOTIFY_MESSAGE   "VfdNotifyMessage"

Definition at line 48 of file vfdlib.h.

VFDEXT_DESCRIPTION

#define VFDEXT_DESCRIPTION   "VFD shell extension"

Definition at line 58 of file vfdlib.h.

VFDEXT_DND_REGKEY

#define VFDEXT_DND_REGKEY   "Drive\\shellex\\DragDropHandlers\\VFD"

Definition at line 60 of file vfdlib.h.

VFDEXT_INFO_REGKEY

#define VFDEXT_INFO_REGKEY   "Drive\\shellex\\{00021500-0000-0000-C000-000000000046}"

Definition at line 62 of file vfdlib.h.

VFDEXT_MENU_REGKEY

#define VFDEXT_MENU_REGKEY   "Drive\\shellex\\ContextMenuHandlers\\VFD"

Definition at line 59 of file vfdlib.h.

VFDEXT_PROP_REGKEY

#define VFDEXT_PROP_REGKEY   "Drive\\shellex\\PropertySheetHandlers\\VFD"

Definition at line 61 of file vfdlib.h.

VFDTRACE

#define VFDTRACE	(		LEVEL,
			STRING
	)

Definition at line 167 of file vfdlib.h.

Typedef Documentation

CSAVE_PARAM

typedef const SAVE_PARAM CSAVE_PARAM

Definition at line 101 of file vfdlib.h.

PCSAVE_PARAM

typedef const SAVE_PARAM * PCSAVE_PARAM

Definition at line 101 of file vfdlib.h.

PSAVE_PARAM

typedef struct _SAVE_PARAM PSAVE_PARAM

SAVE_PARAM

typedef struct _SAVE_PARAM SAVE_PARAM

Function Documentation

ExtractZipImage()

DWORD ExtractZipImage	(	HANDLE	hFile,
		PUCHAR *	pBuffer,
		PULONG	pLength
	)

Definition at line 182 of file vfdzip.c.

{
    UCHAR           buf[VFD_BYTES_PER_SECTOR];
    DWORD           result;
    DWORD           ret;
 
    PZIP_HEADER     zip_hdr;
    ULONG           compressed;
    ULONG           uncompressed;
    PUCHAR          file_cache;
    z_stream        stream;
    int             zlib_ret;
 
    VFDTRACE(0,
        ("[VFD] VfdExtractImz - IN\n"));
 
    *pBuffer = NULL;
    *pLength = 0;
 
    //
    //  Read PKZIP local file header of the first file in the file
    //  -- An IMZ file actually is just a ZIP file with a different
    //  extension, which contains a single floppy image file
    //
    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,(
            "SetFilePointer - %s", SystemMessage(ret)));;
 
        return ret;
    }
 
    if (!ReadFile(hFile, buf, VFD_BYTES_PER_SECTOR, &result, NULL) ||
        result < VFD_BYTES_PER_SECTOR) {
 
        ret = GetLastError();
 
        VFDTRACE(0,(
            "ReadFile - %s", SystemMessage(ret)));;
 
        return ret;
    }
 
    zip_hdr = (PZIP_HEADER)buf;
 
    //  check local file header signature
 
    if (zip_hdr->header_signature != ZIP_LOCAL_SIGNATURE) {
 
        VFDTRACE(0,
            ("[VFD] PKZIP header signature not found.\n"));
 
        return ERROR_INVALID_DATA;
    }
 
    //  check compression method
 
    if (zip_hdr->compression_method != Z_DEFLATED) {
 
        VFDTRACE(0,
            ("[VFD] Bad PKZIP compression method.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    if (zip_hdr->general_flags & 0x01) {
        //  encrypted zip not supported
 
        VFDTRACE(0,
            ("[VFD] PKZIP encrypted.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  check uncompressed image size
 
    compressed = zip_hdr->compressed_size;
    uncompressed = zip_hdr->uncompressed_size;
 
    switch (uncompressed) {
    case VFD_SECTOR_TO_BYTE(320):
    case VFD_SECTOR_TO_BYTE(360):
    case VFD_SECTOR_TO_BYTE(640):
    case VFD_SECTOR_TO_BYTE(720):
    case VFD_SECTOR_TO_BYTE(1280):
    case VFD_SECTOR_TO_BYTE(1440):
    case VFD_SECTOR_TO_BYTE(1640):
    case VFD_SECTOR_TO_BYTE(2400):
    case VFD_SECTOR_TO_BYTE(2880):
    case VFD_SECTOR_TO_BYTE(3360):
    case VFD_SECTOR_TO_BYTE(3444):
    case VFD_SECTOR_TO_BYTE(5760):
        break;
 
    default:
        VFDTRACE(0,
            ("[VFD] Unsupported image size %lu.\n",
            uncompressed));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  check local file header length
    //  -- Just for simplicity, the compressed data must start in the
    //  first sector in the file:  this is not a problem in most cases.
 
    if (FIELD_OFFSET(ZIP_HEADER, file_name) +
        zip_hdr->file_name_length +
        zip_hdr->extra_field_length >= VFD_BYTES_PER_SECTOR) {
 
        VFDTRACE(0,
            ("[VFD] PKZIP header too long.\n"));
 
        return ERROR_NOT_SUPPORTED;
    }
 
    //  allocate memory to store uncompressed data
 
    file_cache = (PUCHAR)LocalAlloc(LPTR, uncompressed);
 
    if (!file_cache) {
 
        VFDTRACE(0,
            ("[VFD] Failed to allocate file cache.\n"));
 
        return ERROR_OUTOFMEMORY;
    }
 
    //  initialize the zlib stream
 
    ZeroMemory(&stream, sizeof(stream));
 
    //  set initial input data information
 
    stream.next_in      = (PUCHAR)zip_hdr->file_name +
        zip_hdr->file_name_length + zip_hdr->extra_field_length;
 
    stream.avail_in     = VFD_BYTES_PER_SECTOR -
        FIELD_OFFSET(ZIP_HEADER, file_name) -
        zip_hdr->file_name_length - zip_hdr->extra_field_length;
 
    //  set output buffer information
 
    stream.next_out     = file_cache;
    stream.avail_out    = uncompressed;
 
    zlib_ret = inflateInit2(&stream, -MAX_WBITS);
 
    //  negative MAX_WBITS value passed to the inflateInit2() function
    //  indicates that there is no zlib header.
    //  In this case inflate() function requires an extra "dummy" byte
    //  after the compressed stream in order to complete decompression
    //  and return Z_STREAM_END.  However, both compressed and uncompressed
    //  data size are already known from the pkzip header, Z_STREAM_END
    //  is not absolutely necessary to know the completion of the operation.
 
    if (zlib_ret != Z_OK) {
        LocalFree(file_cache);
 
        VFDTRACE(0,
            ("[VFD] inflateInit2() failed - %s.\n",
            ZLIB_ERROR(zlib_ret)));
 
        return ERROR_INVALID_FUNCTION;
    }
 
    for (;;) {
 
        //  uncompress current block
 
        zlib_ret = inflate(&stream, Z_NO_FLUSH);
 
        if (zlib_ret != Z_OK) {
            if (zlib_ret == Z_STREAM_END) {
                ret = ERROR_SUCCESS;
            }
            else {
                VFDTRACE(0,
                    ("[VFD] inflate() failed - %s.\n",
                    ZLIB_ERROR(zlib_ret)));
 
                ret = ERROR_INVALID_FUNCTION;
            }
            break;
        }
 
        if (stream.total_out >= uncompressed) {
            //  uncompress completed - no need to wait for Z_STREAM_END
            //  (inflate() would return Z_STREAM_END on the next call)
            ret = ERROR_SUCCESS;
            break;
        }
 
        if (stream.total_in >= compressed) {
            //  somehow there is not enought compressed data
            ret = ERROR_INVALID_FUNCTION;
            break;
        }
 
        //  read next block from file
 
        if (!ReadFile(hFile, buf, VFD_BYTES_PER_SECTOR, &result, NULL) ||
            result <= 0) {
 
            ret = GetLastError();
 
            VFDTRACE(0,
                ("[VFD] Read compressed data - %s.\n",
                SystemMessage(ret)));
            break;
        }
 
        stream.avail_in = result;
        stream.next_in  = buf;
    }
 
    //  cleanup the zlib stream
 
    inflateEnd(&stream);
 
    //  set the return information
 
    if (ret == ERROR_SUCCESS) {
        *pBuffer    = file_cache;
        *pLength    = uncompressed;
    }
    else {
        LocalFree(file_cache);
    }
 
    VFDTRACE(0,
        ("[VFD] VfdExtractImz - OUT\n"));
 
    return ret;
}

Referenced by VfdOpenImage().

ExtractZipInfo()

DWORD ExtractZipInfo	(	HANDLE	hFile,
		ULONG *	pSize
	)

Definition at line 133 of file vfdzip.c.

{
    ZIP_HEADER      zip_hdr;
    DWORD           result;
    DWORD           ret;
 
    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0) {
        ret = GetLastError();
 
        VFDTRACE(0,
            ("SetFilePointer() - %s\n",
            SystemMessage(ret)));
 
        return ret;
    }
 
    if (!ReadFile(hFile, &zip_hdr, sizeof(zip_hdr), &result, NULL)) {
        ret = GetLastError();
 
        VFDTRACE(0,
            ("ReadFile() - %s\n",
            SystemMessage(ret)));
 
        return ret;
    }
 
    if (result != sizeof(zip_hdr)                           ||
        zip_hdr.header_signature != ZIP_LOCAL_SIGNATURE     ||
        zip_hdr.compression_method != ZIP_METHOD_DEFLATED   ||
        (zip_hdr.general_flags & ZIP_FLAG_ENCRYPTED)) {
 
        VFDTRACE(0,
            ("[VFD] Invalid ZIP file\n"));
 
        return ERROR_INVALID_DATA;
    }
 
    //  correct (and supported) ZIP header detected
 
    *pSize = zip_hdr.uncompressed_size;
 
    return ERROR_SUCCESS;
}

Referenced by VfdCheckImageFile().

FormatBufferFat()

DWORD FormatBufferFat	(	PUCHAR	pBuffer,
		ULONG	nSectors
	)

Definition at line 116 of file vfdfat.c.

{
    const DOS_BPB   *bpb;   // BIOS Parameter Block
    PDOS_PBR        pbr;    // Partition Boot Record
    PUCHAR          fat;    // File Allocation Table
    USHORT          idx;
 
    VFDTRACE(0,
        ("[VFD] VfdFormatImage - IN\n"));
 
    //
    //  Select DOS BPB parameters from media size
    //
    bpb = SelectDosBpb((USHORT)nSectors);
 
    if (!bpb) {
        VFDTRACE(0,
            ("[VFD] Unsupported media size %lu\n",
            nSectors));
        return ERROR_INVALID_PARAMETER;
    }
 
    //
    //  Initialize the whole area with the fill data
    //
    FillMemory(pBuffer,
        VFD_SECTOR_TO_BYTE(nSectors),
        VFD_FORMAT_FILL_DATA);
 
    //
    //  Make up the FAT boot record
    //
    ZeroMemory(pBuffer, VFD_BYTES_PER_SECTOR);
 
    pbr = (PDOS_PBR)pBuffer;
 
    CopyMemory(pbr->jump,   VFD_JUMP_CODE,  sizeof(pbr->jump));
    CopyMemory(pbr->oemid,  VFD_OEM_NAME,   sizeof(pbr->oemid));
    CopyMemory(&pbr->bpb,   bpb,            sizeof(pbr->bpb));
 
    //  Make up the extended BPB
 
    pbr->exbpb.BootSignature        = 0x29;
 
    //  use the tick count as the volume serial number
    pbr->exbpb.VolumeSerialNumber   = GetTickCount();
 
    CopyMemory(pbr->exbpb.VolumeLabel,
        VFD_VOLUME_LABEL, sizeof(pbr->exbpb.VolumeLabel));
 
    CopyMemory(pbr->exbpb.FileSystemType,
        VFD_FILESYSTEM, sizeof(pbr->exbpb.FileSystemType));
 
    //  Set the boot record signature
 
    *(pBuffer + VFD_BYTES_PER_SECTOR - 2) = 0x55;
    *(pBuffer + VFD_BYTES_PER_SECTOR - 1) = 0xaa;
 
    //
    //  Clear FAT areas
    //
    fat = pBuffer + VFD_SECTOR_TO_BYTE(bpb->ReservedSectors);
 
    ZeroMemory(
        fat,
        VFD_SECTOR_TO_BYTE(bpb->SectorsPerFAT * bpb->NumberOfFATs));
 
    //
    //  Make up FAT entries for the root directory
    //
    for (idx = 0; idx < bpb->NumberOfFATs; idx++) {
        *fat = bpb->MediaDescriptor;
        *(fat + 1) = 0xff;
        *(fat + 2) = 0xff;
 
        fat += VFD_SECTOR_TO_BYTE(bpb->SectorsPerFAT);
    }
 
    //
    //  Clear root directory entries
    //
    ZeroMemory(fat, bpb->RootEntries * FAT_DIR_ENTRY_SIZE);
 
    VFDTRACE(0,
        ("[VFD] VfdFormatImage - OUT\n"));
 
    return ERROR_SUCCESS;
}

Referenced by VfdCreateImageFile(), VfdFormatMedia(), and VfdOpenImage().

GuiSaveParam()

DWORD GuiSaveParam	(	HWND	hParent,
		PCSAVE_PARAM	pParam
	)

Definition at line 101 of file vfdguisave.c.

{
    switch (DialogBoxParam(
        g_hDllModule,
        MAKEINTRESOURCE(IDD_SAVEDIALOG),
        hParent,
        SaveDialogProc,
        (LPARAM)pParam))
    {
    case IDOK:
        return ERROR_SUCCESS;
 
    case IDCANCEL:
        return ERROR_CANCELLED;
 
    default:
        return GetLastError();
    }
}

Referenced by VfdGuiClose(), and VfdGuiSave().

ModuleMessage()

PSTR ModuleMessage	(	DWORD	nFormat,
			...
	)

Definition at line 124 of file vfdlib.c.

{
    PSTR    p;
    va_list args;
 
    va_start(args, nFormat);
 
    if (!FormatMessage(
        FORMAT_MESSAGE_FROM_HMODULE |
        FORMAT_MESSAGE_ALLOCATE_BUFFER,
        g_hDllModule, nFormat, 0, (LPTSTR)&p, 0, &args)) {
        p = NULL;
    }
 
    va_end(args);
 
    return p;
}

Referenced by AddMenuItem(), CVfdShExt::DoVfdDrop(), OnBrowse(), OnOK(), SetControlText(), ShowHelpWindow(), VfdGuiClose(), VfdGuiFormat(), VfdImageTip(), and VfdMakeFileDesc().

SetControlText()

void SetControlText	(	HWND	hWnd,
		UINT	nCtrl,
		DWORD	nMsg
	)

Definition at line 350 of file vfdguiut.c.

{
    PSTR p = NULL;
 
    if (nMsg) {
        p = ModuleMessage(nMsg);
    }
 
    if (nCtrl) {
        SetDlgItemText(hWnd, nCtrl, p);
    }
    else {
        SetWindowText(hWnd, p);
    }
 
    if (p) {
        LocalFree(p);
    }
}

Referenced by OnImage(), OnInit(), OnMediaType(), OnPropInit(), and OnTarget().

ShowContextMenu()

void ShowContextMenu	(	HWND	hDlg,
		HWND	hCtl,
		LPARAM	lParam
	)

Definition at line 456 of file vfdguiut.c.

{
    POINT           pt;
    UINT            id;
    HMENU           hMenu;
 
    pt.x = ((int)(short)LOWORD(lParam));
    pt.y = ((int)(short)HIWORD(lParam));
 
    if (pt.x == -1 || pt.y == -1) {
        RECT rc;
 
        GetWindowRect(hCtl, &rc);
        pt.x = (rc.left + rc.right) / 2;
        pt.y = (rc.top + rc.bottom) / 2;
 
        id = GetDlgCtrlID(hCtl);
    }
    else {
        POINT pt2 = pt;
 
        ScreenToClient(hDlg, &pt2);
 
        id = GetDlgCtrlID(
            ChildWindowFromPoint(hDlg, pt2));
    }
 
    if (id < IDC_IMAGEFILE_LABEL ||
        id > IDC_TRUNCATE) {
        return;
    }
 
    hMenu = CreatePopupMenu();
 
    AppendMenu(hMenu, MF_STRING, 1, "&What's This");
 
    if (TrackPopupMenu(hMenu, TPM_RETURNCMD,
        pt.x, pt.y, 0, hDlg, NULL))
    {
        ShowHelpWindow(hDlg, id);
    }
 
    DestroyMenu(hMenu);
}

ShowHelpWindow()

void ShowHelpWindow	(	HWND	hDlg,
		UINT	nCtl
	)

Definition at line 507 of file vfdguiut.c.

{
    UINT            msg;
    RECT            rc;
    PSTR            help;
 
    switch (nCtl) {
    case IDC_IMAGEFILE_LABEL:
    case IDC_IMAGEFILE:
        msg = MSG_HELP_IMAGEFILE;
        break;
    case IDC_IMAGEDESC_LABEL:
    case IDC_IMAGEFILE_DESC:
        msg = MSG_HELP_IMAGEDESC;
        break;
    case IDC_TARGETFILE_LABEL:
    case IDC_TARGETFILE:
        msg = MSG_HELP_TARGETFILE;
        break;
    case IDC_DISKTYPE_LABEL:
    case IDC_DISKTYPE:
    case IDC_DISKTYPE_FILE:
    case IDC_DISKTYPE_RAM:
        msg = MSG_HELP_DISKTYPE;
        break;
    case IDC_MEDIATYPE_LABEL:
    case IDC_MEDIATYPE:
        msg = MSG_HELP_MEDIATYPE;
        break;
    case IDC_WRITE_PROTECTED:
        msg = MSG_HELP_PROTECT_NOW;
        break;
    case IDC_OPEN_PROTECTED:
        msg = MSG_HELP_PROTECT_OPEN;
        break;
    case IDC_BROWSE:
        msg = MSG_HELP_BROWSE;
        break;
    case IDC_OPEN:
        msg = MSG_HELP_OPEN;
        break;
    case IDC_SAVE:
        msg = MSG_HELP_SAVE;
        break;
    case IDC_CLOSE:
        msg = MSG_HELP_CLOSE;
        break;
    case IDC_FORMAT:
        msg = MSG_HELP_FORMAT;
        break;
    case IDC_CONTROL:
        msg = MSG_HELP_CONTROL;
        break;
    case IDC_OVERWRITE:
        msg = MSG_HELP_OVERWRITE;
        break;
    case IDC_TRUNCATE:
        msg = MSG_HELP_TRUNCATE;
        break;
    default:
        return;
    }
 
    GetWindowRect(GetDlgItem(hDlg, nCtl), &rc);
 
    help = ModuleMessage(msg);
 
    if (help) {
        VfdToolTip(hDlg, help, rc.left, (rc.top + rc.bottom) / 2, TRUE);
        LocalFree(help);
    }
}

Referenced by OpenDialogProc(), SaveDialogProc(), ShowContextMenu(), and VfdPageDlgProc().

SystemMessage()

PCSTR SystemMessage

(

DWORD

nError

)

Definition at line 147 of file vfdlib.c.

{
    static CHAR     msg[256];
 
    if (!FormatMessage(
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, nError, 0, msg, sizeof(msg), NULL)) {
 
        _snprintf(msg, sizeof(msg),
            "Unknown system error %lu (0x%08x)\n", nError, nError);
    }
 
    return msg;
}

Referenced by CVfdShExt::DoVfdOpen(), ExtractZipImage(), ExtractZipInfo(), CVfdShExt::InvokeCommand(), OnControl(), OnImage(), OnOK(), OnTarget(), UpdateImageInfo(), VfdBroadcastLink(), VfdCheckDriverFile(), VfdCheckImageFile(), VfdCloseImage(), VfdConfigDriver(), VfdCreateImageFile(), VfdDismountVolume(), VfdFormatMedia(), VfdGetDeviceName(), VfdGetDeviceNumber(), VfdGetDriverConfig(), VfdGetDriverState(), VfdGetDriverVersion(), VfdGetGlobalLink(), VfdGetImageInfo(), VfdGetLocalLink(), VfdGetMediaState(), VfdGuiFormat(), VfdImageTip(), VfdInstallDriver(), VfdOpenDevice(), VfdOpenImage(), VfdRemoveDriver(), VfdSaveImage(), VfdSetGlobalLink(), VfdSetLocalLink(), VfdStartDriver(), VfdStopDriver(), and VfdWriteProtect().

Variable Documentation

g_cDllRefCnt

UINT g_cDllRefCnt

extern

g_hDllModule

HINSTANCE g_hDllModule

extern

g_nNotifyMsg

UINT g_nNotifyMsg

extern