vcdcontroltool.c File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <wingdi.h>
#include <winsvc.h>
#include <winreg.h>
#include <commctrl.h>
#include <commdlg.h>
#include <wchar.h>
#include <ndk/rtltypes.h>
#include <ndk/rtlfuncs.h>
#include <vcdioctl.h>
#include "resource.h"

Include dependency graph for vcdcontroltool.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	IOCTL_CDROM_BASE   FILE_DEVICE_CD_ROM
#define	IOCTL_CDROM_EJECT_MEDIA   CTL_CODE(IOCTL_CDROM_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)

Functions
static HANDLE	OpenMaster (VOID)
static HANDLE	OpenLetter (WCHAR Letter)
static VOID	RefreshDevicesList (WCHAR Letter)
VOID	SetServiceState (BOOLEAN Started)
INT_PTR	QueryDriverInfo (HWND hDlg)
static VOID	StartDriver (VOID)
static VOID	StopDriver (VOID)
static INT_PTR	HandleDriverCommand (WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	DriverDialogProc (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
static VOID	DriverControl (VOID)
static INT_PTR	SetMountFileName (HWND hDlg, LPARAM lParam)
FORCEINLINE DWORD	Min (DWORD a, DWORD b)
static VOID	PerformMount (VOID)
static INT_PTR	HandleMountCommand (WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	MountDialogProc (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
static VOID	AddDrive (VOID)
static WCHAR	GetSelectedDriveLetter (VOID)
static VOID	MountImage (VOID)
static VOID	RemountImage (VOID)
static VOID	EjectDrive (VOID)
static VOID	RemoveDrive (VOID)
static INT_PTR	HandleCommand (WPARAM wParam, LPARAM lParam)
static VOID	ResetStats (VOID)
static INT_PTR	HandleNotify (LPARAM lParam)
static INT_PTR	CreateListViewColumns (HWND hDlg)
static INT_PTR CALLBACK	MainDialogProc (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
INT WINAPI	wWinMain (HINSTANCE hInst, HINSTANCE hPrev, LPWSTR Cmd, int iCmd)

Variables
HWND	hWnd
HWND	hMountWnd
HWND	hDriverWnd
HINSTANCE	hInstance
WCHAR	wMountLetter

Macro Definition Documentation

IOCTL_CDROM_BASE

#define IOCTL_CDROM_BASE   FILE_DEVICE_CD_ROM

Definition at line 25 of file vcdcontroltool.c.

IOCTL_CDROM_EJECT_MEDIA

#define IOCTL_CDROM_EJECT_MEDIA   CTL_CODE(IOCTL_CDROM_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 26 of file vcdcontroltool.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 10 of file vcdcontroltool.c.

Function Documentation

AddDrive()

static VOID AddDrive ( VOID  )

static

Definition at line 555 of file vcdcontroltool.c.

{
    WCHAR Letter;
    BOOLEAN Res;
    DWORD BytesRead;
    HANDLE hMaster;
 
    /* Open the driver */
    hMaster = OpenMaster();
    if (hMaster != INVALID_HANDLE_VALUE)
    {
        /* Issue the create IOCTL */
        Res = DeviceIoControl(hMaster, IOCTL_VCDROM_CREATE_DRIVE, NULL, 0, &Letter, sizeof(WCHAR), &BytesRead, NULL);
        CloseHandle(hMaster);
 
        /* If it failed, reset the drive letter */
        if (!Res)
        {
            Letter = 0;
        }
 
        /* Refresh devices list. If it succeed, we pass the created drive letter
         * So that, user can directly click on "mount" to mount an image, without
         * needing to select appropriate device.
         */
        RefreshDevicesList(Letter);
    }
}

Referenced by HandleCommand().

CreateListViewColumns()

static INT_PTR CreateListViewColumns ( HWND  hDlg )

static

Definition at line 878 of file vcdcontroltool.c.

{
    WCHAR szText[255];
    LVCOLUMNW lvColumn;
    HWND hListView;
 
    hWnd = hDlg;
    hListView = GetDlgItem(hDlg, IDC_MAINDEVICES);
 
    /* Select the whole line, not just the first column */
    SendMessage(hListView, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
 
    /* Set up the first column */
    ZeroMemory(&lvColumn, sizeof(LVCOLUMNW));
    lvColumn.pszText = szText;
    lvColumn.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
    lvColumn.fmt = LVCFMT_LEFT;
    lvColumn.cx = 100;
    szText[0] = 0;
    LoadString(hInstance, IDS_DRIVE, szText, sizeof(szText) / sizeof(WCHAR));
    szText[(sizeof(szText) / sizeof(WCHAR)) - 1] = L'\0';
    SendMessage(hListView, LVM_INSERTCOLUMNW, 0, (LPARAM)&lvColumn);
 
    /* Set up the second column */
    szText[0] = 0;
    lvColumn.cx = 350;
    LoadString(hInstance, IDS_MAPPEDIMAGE, szText, sizeof(szText) / sizeof(WCHAR));
    szText[(sizeof(szText) / sizeof(WCHAR)) - 1] = L'\0';
    SendMessage(hListView, LVM_INSERTCOLUMNW, 1, (LPARAM)&lvColumn);
 
    /* Make sure stats are at 0 */
    ResetStats();
 
    /* And populate our device list */
    RefreshDevicesList(0);
 
    return TRUE;
}

Referenced by MainDialogProc().

DriverControl()

static VOID DriverControl ( VOID  )

static

Definition at line 387 of file vcdcontroltool.c.

{
    /* Just create a new window with our driver control dialog */
    CreateDialogParamW(hInstance,
                       MAKEINTRESOURCE(IDD_DRIVERWINDOW),
                       NULL,
                       DriverDialogProc,
                       0);
}

Referenced by HandleCommand().

DriverDialogProc()

static INT_PTR CALLBACK DriverDialogProc ( HWND  hDlg, UINT  Message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 364 of file vcdcontroltool.c.

{
    /* Dispatch the message */
    switch (Message)
    {
        case WM_INITDIALOG:
            return QueryDriverInfo(hDlg);
 
        case WM_COMMAND:
            return HandleDriverCommand(wParam, lParam);
 
        case WM_CLOSE:
            return DestroyWindow(hDlg);
    }
 
    return FALSE;
}

Referenced by DriverControl().

EjectDrive()

static VOID EjectDrive ( VOID  )

static

Definition at line 693 of file vcdcontroltool.c.

{
    WCHAR Letter;
    HANDLE hLet;
    DWORD BytesRead;
 
    /* Get the select drive letter */
    Letter = GetSelectedDriveLetter();
    if (Letter != 0)
    {
        /* Open it */
        hLet = OpenLetter(Letter);
        if (hLet != INVALID_HANDLE_VALUE)
        {
            /* And ask the driver for an ejection */
            DeviceIoControl(hLet, IOCTL_CDROM_EJECT_MEDIA, NULL, 0, NULL, 0, &BytesRead, NULL);
 
            CloseHandle(hLet);
 
            /* Refresh the list, to display the fact the image is now unmounted but
             * still known by the driver
             * Make sure it's selected as it was previously selected.
             */
            RefreshDevicesList(Letter);
        }
    }
}

Referenced by HandleCommand().

GetSelectedDriveLetter()

static WCHAR GetSelectedDriveLetter ( VOID  )

static

Definition at line 586 of file vcdcontroltool.c.

{
    INT iItem;
    HWND hListView;
    LVITEM lvItem;
    WCHAR szText[255];
 
    /* Get the select device in the list view */
    hListView = GetDlgItem(hWnd, IDC_MAINDEVICES);
    iItem = SendMessage(hListView, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
    /* If there's one... */
    if (iItem != -1)
    {
        ZeroMemory(&lvItem, sizeof(LVITEM));
        lvItem.pszText = szText;
        lvItem.cchTextMax = sizeof(szText) / sizeof(WCHAR);
        szText[0] = 0;
 
        /* Get the item text, it will be the drive letter */
        SendMessage(hListView, LVM_GETITEMTEXT, iItem, (LPARAM)&lvItem);
        return szText[0];
    }
 
    /* Nothing selected */
    return 0;
}

Referenced by EjectDrive(), HandleNotify(), MountImage(), RemountImage(), and RemoveDrive().

HandleCommand()

static INT_PTR HandleCommand ( WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 750 of file vcdcontroltool.c.

{
    WORD Msg;
 
    /* Dispatch the message for the controls we manage */
    Msg = LOWORD(wParam);
    switch (Msg)
    {
        case IDC_MAINCONTROL:
            DriverControl();
            return TRUE;
 
        case IDC_MAINOK:
            DestroyWindow(hWnd);
            return TRUE;
 
        case IDC_MAINADD:
            AddDrive();
            return TRUE;
 
        case IDC_MAINMOUNT:
            MountImage();
            return TRUE;
 
        case IDC_MAINREMOUNT:
            RemountImage();
            return TRUE;
 
        case IDC_MAINEJECT:
            EjectDrive();
            return TRUE;
 
        case IDC_MAINREMOVE:
            RemoveDrive();
            return TRUE;
    }
 
    return FALSE;
}

Referenced by MainDialogProc().

HandleDriverCommand()

static INT_PTR HandleDriverCommand ( WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 336 of file vcdcontroltool.c.

{
    WORD Msg;
 
    /* Dispatch the message for the controls we manage */
    Msg = LOWORD(wParam);
    switch (Msg)
    {
        case IDC_DRIVEROK:
            DestroyWindow(hDriverWnd);
            return TRUE;
 
        case IDC_DRIVERSTART:
            StartDriver();
            return TRUE;
 
        case IDC_DRIVERSTOP:
            StopDriver();
            return TRUE;
    }
 
    return FALSE;
}

Referenced by DriverDialogProc().

HandleMountCommand()

static INT_PTR HandleMountCommand ( WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 508 of file vcdcontroltool.c.

{
    WORD Msg;
 
    /* Dispatch the message for the controls we manage */
    Msg = LOWORD(wParam);
    switch (Msg)
    {
        case IDC_MOUNTCANCEL:
            DestroyWindow(hMountWnd);
            return TRUE;
 
        case IDC_MOUNTOK:
            PerformMount();
            return TRUE;
    }
 
    return FALSE;
}

Referenced by MountDialogProc().

HandleNotify()

static INT_PTR HandleNotify ( LPARAM  lParam )

static

Definition at line 815 of file vcdcontroltool.c.

{
    WCHAR Letter;
    LPNMHDR NmHdr;
    WCHAR szText[255];
    HWND hEditText;
    DWORD ClusterSector, SectorSize, FreeClusters, Clusters, Sectors;
 
    NmHdr = (LPNMHDR)lParam;
 
    /* We only want notifications on click on our devices list */
    if (NmHdr->code == NM_CLICK &&
        NmHdr->idFrom == IDC_MAINDEVICES)
    {
        /* Get the newly selected device */
        Letter = GetSelectedDriveLetter();
        if (Letter != 0)
        {
            /* Setup its name */
            szText[0] = Letter;
            szText[1] = L':';
            szText[2] = 0;
 
            /* And get its capacities */
            if (GetDiskFreeSpace(szText, &ClusterSector, &SectorSize, &FreeClusters, &Clusters))
            {
                /* Nota: the application returns the total amount of clusters and sectors
                 * So, compute it
                 */
                Sectors = ClusterSector * Clusters;
 
                /* And now, update statistics about the device */
                hEditText = GetDlgItem(hWnd, IDC_MAINSECTORS);
                wsprintf(szText, L"%ld", Sectors);
                SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
                hEditText = GetDlgItem(hWnd, IDC_MAINSIZE);
                wsprintf(szText, L"%ld", SectorSize);
                SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
                hEditText = GetDlgItem(hWnd, IDC_MAINFREE);
                wsprintf(szText, L"%ld", FreeClusters);
                SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
                hEditText = GetDlgItem(hWnd, IDC_MAINTOTAL);
                wsprintf(szText, L"%ld", Clusters);
                SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
                return TRUE;
            }
        }
 
        /* We failed somewhere, make sure we're at 0 */
        ResetStats();
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by MainDialogProc().

MainDialogProc()

static INT_PTR CALLBACK MainDialogProc ( HWND  hDlg, UINT  Message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 920 of file vcdcontroltool.c.

{
    /* Dispatch the message */
    switch (Message)
    {
        case WM_INITDIALOG:
            return CreateListViewColumns(hDlg);
 
        case WM_COMMAND:
            return HandleCommand(wParam, lParam);
 
        case WM_NOTIFY:
            return HandleNotify(lParam);
 
        case WM_CLOSE:
            return DestroyWindow(hDlg);
 
        case WM_DESTROY:
            PostQuitMessage(0);
            return TRUE;
    }
 
    return FALSE;
}

Referenced by wWinMain().

Min()

FORCEINLINE DWORD Min	(	DWORD	a,
		DWORD	b
	)

Definition at line 418 of file vcdcontroltool.c.

{
    return (a > b ? b : a);
}

MountDialogProc()

static INT_PTR CALLBACK MountDialogProc ( HWND  hDlg, UINT  Message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 532 of file vcdcontroltool.c.

{
    /* Dispatch the message */
    switch (Message)
    {
        case WM_INITDIALOG:
            return SetMountFileName(hDlg, lParam);
 
        case WM_COMMAND:
            return HandleMountCommand(wParam, lParam);
 
        case WM_CLOSE:
            return DestroyWindow(hDlg);
    }
 
    return FALSE;
}

Referenced by MountImage().

MountImage()

static VOID MountImage ( VOID  )

static

Definition at line 615 of file vcdcontroltool.c.

{
    WCHAR szFilter[255];
    WCHAR szFileName[MAX_PATH];
    OPENFILENAMEW ImageOpen;
 
    /* Get the selected drive letter
     * FIXME: I make it global, because I don't know how to pass
     * it properly to the later involved functions.
     * Feel free to improve (without breaking ;-))
     */
    wMountLetter = GetSelectedDriveLetter();
    /* We can only mount if we have a device */
    if (wMountLetter != 0)
    {
        /* First of all, we need an image to mount */
        ZeroMemory(&ImageOpen, sizeof(OPENFILENAMEW));
 
        ImageOpen.lStructSize = sizeof(ImageOpen);
        ImageOpen.hwndOwner = NULL;
        ImageOpen.lpstrFilter = szFilter;
        ImageOpen.lpstrFile = szFileName;
        ImageOpen.nMaxFile = MAX_PATH;
        ImageOpen.Flags = OFN_EXPLORER| OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
 
        /* Get our filter (only supported images) */
        szFileName[0] = 0;
        szFilter[0] = 0;
        LoadString(hInstance, IDS_FILTER, szFilter, sizeof(szFilter) / sizeof(WCHAR));
        szFilter[(sizeof(szFilter) / sizeof(WCHAR)) - 1] = L'\0';
 
        /* Get the image name */
        if (!GetOpenFileName(&ImageOpen))
        {
            /* The user canceled... */
            return;
        }
 
        /* Start the mount dialog, so that user can select mount options */
        CreateDialogParamW(hInstance,
                           MAKEINTRESOURCE(IDD_MOUNTWINDOW),
                           NULL,
                           MountDialogProc,
                           (LPARAM)szFileName);
    }
}

Referenced by HandleCommand().

OpenLetter()

static HANDLE OpenLetter ( WCHAR  Letter )

static

Definition at line 48 of file vcdcontroltool.c.

{
    WCHAR Device[255];
 
    /* Make name */
    wsprintf(Device, L"\\\\.\\%c:", Letter);
 
    /* And open */
    return CreateFile(Device, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}

Referenced by EjectDrive(), PerformMount(), RefreshDevicesList(), RemountImage(), and RemoveDrive().

OpenMaster()

static HANDLE OpenMaster ( VOID  )

static

Definition at line 39 of file vcdcontroltool.c.

{
    /* Just open the device */
    return CreateFile(L"\\\\.\\\\VirtualCdRom", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}

Referenced by AddDrive(), and RefreshDevicesList().

PerformMount()

static VOID PerformMount ( VOID  )

static

Definition at line 425 of file vcdcontroltool.c.

{
    HWND hControl;
    WCHAR szFileName[MAX_PATH];
    MOUNT_PARAMETERS MountParams;
    UNICODE_STRING NtPathName;
    HANDLE hLet;
    DWORD BytesRead;
    BOOLEAN bPersist, Res;
    WCHAR szKeyName[256];
    HKEY hKey;
 
    /* Zero our input structure */
    ZeroMemory(&MountParams, sizeof(MOUNT_PARAMETERS));
 
    /* Do we have to suppress UDF? */
    hControl = GetDlgItem(hMountWnd, IDC_MOUNTUDF);
    if (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED)
    {
        MountParams.Flags |= MOUNT_FLAG_SUPP_UDF;
    }
 
    /* Do we have to suppress Joliet? */
    hControl = GetDlgItem(hMountWnd, IDC_MOUNTJOLIET);
    if (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED)
    {
        MountParams.Flags |= MOUNT_FLAG_SUPP_JOLIET;
    }
 
    /* Should the mount be persistent? */
    hControl = GetDlgItem(hMountWnd, IDC_MOUNTPERSIST);
    bPersist = (SendMessage(hControl, BM_GETCHECK, 0, 0) == BST_CHECKED);
 
    /* Get the file name */
    hControl = GetDlgItem(hMountWnd, IDC_MOUNTIMAGE);
    GetWindowText(hControl, szFileName, sizeof(szFileName) / sizeof(WCHAR));
 
    /* Get NT path for the driver */
    if (RtlDosPathNameToNtPathName_U(szFileName, &NtPathName, NULL, NULL))
    {
        /* Copy it in the parameter structure */
        wcsncpy(MountParams.Path, NtPathName.Buffer, 255);
        MountParams.Length = Min(NtPathName.Length, 255 * sizeof(WCHAR));
        RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathName.Buffer);
 
        /* Open the device */
        hLet = OpenLetter(wMountLetter);
        if (hLet != INVALID_HANDLE_VALUE)
        {
            /* And issue the mount IOCTL */
            Res = DeviceIoControl(hLet, IOCTL_VCDROM_MOUNT_IMAGE, &MountParams, sizeof(MountParams), NULL, 0, &BytesRead, NULL);
 
            CloseHandle(hLet);
 
            /* Refresh the list so that our mount appears */
            RefreshDevicesList(0);
 
            /* If mount succeed and has to persistent, write it to registry */
            if (Res && bPersist)
            {
                wsprintf(szKeyName, L"SYSTEM\\CurrentControlSet\\Services\\Vcdrom\\Parameters\\Device%c", wMountLetter);
                if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_CREATE_SUB_KEY | KEY_SET_VALUE, NULL, &hKey, NULL) == ERROR_SUCCESS)
                {
                    wcsncpy(szKeyName, MountParams.Path, MountParams.Length);
                    szKeyName[MountParams.Length / sizeof(WCHAR)] = 0;
                    RegSetValueExW(hKey, L"IMAGE", 0, REG_SZ, (BYTE *)szKeyName, MountParams.Length);
 
                    szKeyName[0] = wMountLetter;
                    szKeyName[1] = L':';
                    szKeyName[2] = 0;
                    RegSetValueExW(hKey, L"DRIVE", 0, REG_SZ, (BYTE *)szKeyName, 3 * sizeof(WCHAR));
 
                    RegCloseKey(hKey);
                }
            }
        }
    }
 
    DestroyWindow(hMountWnd);
}

Referenced by HandleMountCommand().

QueryDriverInfo()

INT_PTR QueryDriverInfo

(

HWND

hDlg

)

Definition at line 200 of file vcdcontroltool.c.

{
    DWORD dwSize;
    SC_HANDLE hMgr, hSvc;
    LPQUERY_SERVICE_CONFIGW pConfig;
    WCHAR szText[2 * MAX_PATH];
    HWND hControl;
    SERVICE_STATUS Status;
 
    hDriverWnd = hDlg;
 
    /* Open service manager */
    hMgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (hMgr != NULL)
    {
        /* Open our service */
        hSvc = OpenService(hMgr, L"Vcdrom", SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS);
        if (hSvc != NULL)
        {
            /* Probe its config size */
            if (!QueryServiceConfig(hSvc, NULL, 0, &dwSize) &&
                GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            {
                /* And get its config */
                pConfig = HeapAlloc(GetProcessHeap(), 0, dwSize);
 
                if (QueryServiceConfig(hSvc, pConfig, dwSize, &dwSize))
                {
                    /* Display name & driver */
                    wsprintf(szText, L"%s:\n(%s)", pConfig->lpDisplayName, pConfig->lpBinaryPathName);
                    hControl = GetDlgItem(hDriverWnd, IDC_DRIVERINFO);
                    SendMessage(hControl, WM_SETTEXT, 0, (LPARAM)szText);
                }
 
                HeapFree(GetProcessHeap(), 0, pConfig);
            }
 
            /* Get its status */
            if (QueryServiceStatus(hSvc, &Status))
            {
                if (Status.dwCurrentState != SERVICE_RUNNING &&
                    Status.dwCurrentState != SERVICE_START_PENDING)
                {
                    SetServiceState(FALSE);
                }
                else
                {
                    SetServiceState(TRUE);
                }
            }
 
            CloseServiceHandle(hSvc);
        }
 
        CloseServiceHandle(hMgr);
    }
 
    /* FIXME: we don't allow uninstall/install */
    {
        hControl = GetDlgItem(hDriverWnd, IDC_DRIVERINSTALL);
        EnableWindow(hControl, FALSE);
        hControl = GetDlgItem(hDriverWnd, IDC_DRIVERREMOVE);
        EnableWindow(hControl, FALSE);
    }
 
    /* Display our sub window */
    ShowWindow(hDlg, SW_SHOW);
 
    return TRUE;
}

Referenced by DriverDialogProc().

RefreshDevicesList()

static VOID RefreshDevicesList ( WCHAR  Letter )

static

Definition at line 62 of file vcdcontroltool.c.

{
    HWND hListView;
    WCHAR szFormat[50];
    WCHAR szText[MAX_PATH + 50];
    WCHAR szImage[MAX_PATH];
    HANDLE hMaster, hLet;
    DWORD BytesRead, i;
    DRIVES_LIST Drives;
    BOOLEAN Res;
    IMAGE_PATH Image;
    LVITEMW lvItem;
    LRESULT lResult;
    INT iSelected;
 
    /* Get our list view */
    hListView = GetDlgItem(hWnd, IDC_MAINDEVICES);
 
    /* Purge it */
    SendMessage(hListView, LVM_DELETEALLITEMS, 0, 0);
 
    /* Now, query the driver for all the devices */
    hMaster = OpenMaster();
    if (hMaster != INVALID_HANDLE_VALUE)
    {
        Res = DeviceIoControl(hMaster, IOCTL_VCDROM_ENUMERATE_DRIVES, NULL, 0, &Drives, sizeof(Drives), &BytesRead, NULL);
        CloseHandle(hMaster);
 
        if (Res)
        {
            /* Loop to add all the devices to the list */
            iSelected = -1;
            for (i = 0; i < Drives.Count; ++i)
            {
                /* We'll query device one by one */
                hLet = OpenLetter(Drives.Drives[i]);
                if (hLet != INVALID_HANDLE_VALUE)
                {
                    /* Get info about the mounted image */
                    Res = DeviceIoControl(hLet, IOCTL_VCDROM_GET_IMAGE_PATH, NULL, 0, &Image, sizeof(Image), &BytesRead, NULL);
                    if (Res)
                    {
                        /* First of all, add our driver letter to the list */
                        ZeroMemory(&lvItem, sizeof(LVITEMW));
                        lvItem.mask = LVIF_TEXT;
                        lvItem.pszText = szText;
                        lvItem.iItem = i;
                        szText[0] = Drives.Drives[i];
                        szText[1] = L':';
                        szText[2] = 0;
 
                        /* If it worked, we'll complete with the info about the device:
                         * (mounted? which image?)
                         */
                        lResult = SendMessage(hListView, LVM_INSERTITEM, 0, (LPARAM)&lvItem);
                        if (lResult != -1)
                        {
                            /* If it matches arg, that's the letter to select at the end */
                            if (Drives.Drives[i] == Letter)
                            {
                                iSelected = lResult;
                            }
 
                            /* We'll fill second column with info */
                            lvItem.iSubItem = 1;
 
                            /* Gather the image path */
                            if (Image.Length != 0)
                            {
                                memcpy(szImage, Image.Path, Image.Length);
                                szImage[(Image.Length / sizeof(WCHAR))] = L'\0';
                            }
 
                            /* It's not mounted... */
                            if (Image.Mounted == 0)
                            {
                                /* If we don't have an image, set default text instead */
                                if (Image.Length == 0)
                                {
                                    szImage[0] = 0;
                                    LoadString(hInstance, IDS_NONE, szImage, sizeof(szImage) / sizeof(WCHAR));
                                    szImage[(sizeof(szImage) / sizeof(WCHAR)) - 1] = L'\0';
                                }
 
                                /* Display the last known image */
                                szFormat[0] = 0;
                                LoadString(hInstance, IDS_NOMOUNTED, szFormat, sizeof(szFormat) / sizeof(WCHAR));
                                szFormat[(sizeof(szFormat) / sizeof(WCHAR)) - 1] = L'\0';
 
                                swprintf(szText, szFormat, szImage);
                                lvItem.pszText = szText;
                            }
                            else
                            {
                                /* Mounted, just display the image path */
                                lvItem.pszText = szImage;
                            }
 
                            /* Set text */
                            SendMessage(hListView, LVM_SETITEM, lResult, (LPARAM)&lvItem);
                        }
                    }
 
                    /* Don't leak our device */
                    CloseHandle(hLet);
                }
            }
 
            /* If we had something to select, then just do it */
            if (iSelected != -1)
            {
                ZeroMemory(&lvItem, sizeof(LVITEMW));
 
                lvItem.mask = LVIF_STATE;
                lvItem.iItem = iSelected;
                lvItem.state = LVIS_FOCUSED | LVIS_SELECTED;
                lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
                SendMessage(hListView, LVM_SETITEMSTATE, iSelected, (LPARAM)&lvItem);
            }
        }
    }
}

Referenced by AddDrive(), CreateListViewColumns(), EjectDrive(), PerformMount(), RemountImage(), RemoveDrive(), StartDriver(), and StopDriver().

RemountImage()

static VOID RemountImage ( VOID  )

static

Definition at line 664 of file vcdcontroltool.c.

{
    WCHAR Letter;
    HANDLE hLet;
    DWORD BytesRead;
 
    /* Get the select drive letter */
    Letter = GetSelectedDriveLetter();
    if (Letter != 0)
    {
        /* Open it */
        hLet = OpenLetter(Letter);
        if (hLet != INVALID_HANDLE_VALUE)
        {
            /* And ask the driver for a remount */
            DeviceIoControl(hLet, IOCTL_STORAGE_LOAD_MEDIA, NULL, 0, NULL, 0, &BytesRead, NULL);
 
            CloseHandle(hLet);
 
            /* Refresh the list, to display the fact the image is now mounted.
             * Make sure it's selected as it was previously selected.
             */
            RefreshDevicesList(Letter);
        }
    }
}

Referenced by HandleCommand().

RemoveDrive()

static VOID RemoveDrive ( VOID  )

static

Definition at line 723 of file vcdcontroltool.c.

{
    WCHAR Letter;
    HANDLE hLet;
    DWORD BytesRead;
 
    /* Get the select drive letter */
    Letter = GetSelectedDriveLetter();
    if (Letter != 0)
    {
        /* Open it */
        hLet = OpenLetter(Letter);
        if (hLet != INVALID_HANDLE_VALUE)
        {
            /* And ask the driver for a deletion */
            DeviceIoControl(hLet, IOCTL_VCDROM_DELETE_DRIVE, NULL, 0, NULL, 0, &BytesRead, NULL);
 
            CloseHandle(hLet);
 
            /* Refresh the list, to make the device disappear */
            RefreshDevicesList(0);
        }
    }
}

Referenced by HandleCommand().

ResetStats()

static VOID ResetStats ( VOID  )

static

Definition at line 792 of file vcdcontroltool.c.

{
    HWND hEditText;
    static const WCHAR szText[] = { L'0', 0 };
 
    /* Simply set '0' in all the edittext controls we
     * manage regarding statistics.
     */
    hEditText = GetDlgItem(hWnd, IDC_MAINSECTORS);
    SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
    hEditText = GetDlgItem(hWnd, IDC_MAINSIZE);
    SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
    hEditText = GetDlgItem(hWnd, IDC_MAINFREE);
    SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
 
    hEditText = GetDlgItem(hWnd, IDC_MAINTOTAL);
    SendMessage(hEditText, WM_SETTEXT, 0, (LPARAM)szText);
}

Referenced by CreateListViewColumns(), and HandleNotify().

SetMountFileName()

static INT_PTR SetMountFileName ( HWND  hDlg, LPARAM  lParam  )

static

Definition at line 399 of file vcdcontroltool.c.

{
    HWND hEditText;
 
    hMountWnd = hDlg;
 
    /* Set the file name that was passed when creating dialog */
    hEditText = GetDlgItem(hMountWnd, IDC_MOUNTIMAGE);
    SendMessage(hEditText, WM_SETTEXT, 0, lParam);
 
    /* Show our window */
    ShowWindow(hDlg, SW_SHOW);
 
    return TRUE;
}

Referenced by MountDialogProc().

SetServiceState()

VOID SetServiceState

(

BOOLEAN

Started

)

Definition at line 186 of file vcdcontroltool.c.

{
    HWND hControl;
 
    /* If started, disable start button */
    hControl = GetDlgItem(hDriverWnd, IDC_DRIVERSTART);
    EnableWindow(hControl, !Started);
 
    /* If started, enable stop button */
    hControl = GetDlgItem(hDriverWnd, IDC_DRIVERSTOP);
    EnableWindow(hControl, Started);
}

Referenced by DECLARE_INTERFACE_(), QueryDriverInfo(), StartDriver(), and StopDriver().

StartDriver()

static VOID StartDriver ( VOID  )

static

Definition at line 273 of file vcdcontroltool.c.

{
    SC_HANDLE hMgr, hSvc;
 
    /* Open the SC manager */
    hMgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (hMgr != NULL)
    {
        /* Open the service matching our driver */
        hSvc = OpenService(hMgr, L"Vcdrom", SERVICE_START);
        if (hSvc != NULL)
        {
            /* Start it */
            /* FIXME: improve */
            StartService(hSvc, 0, NULL);
 
            CloseServiceHandle(hSvc);
 
            /* Refresh the list in case there were persistent mounts */
            RefreshDevicesList(0);
 
            /* Update buttons */
            SetServiceState(TRUE);
        }
 
        CloseServiceHandle(hMgr);
    }
}

Referenced by HandleDriverCommand().

StopDriver()

static VOID StopDriver ( VOID  )

static

Definition at line 304 of file vcdcontroltool.c.

{
    SC_HANDLE hMgr, hSvc;
    SERVICE_STATUS Status;
 
    /* Open the SC manager */
    hMgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    if (hMgr != NULL)
    {
        /* Open the service matching our driver */
        hSvc = OpenService(hMgr, L"Vcdrom", SERVICE_STOP);
        if (hSvc != NULL)
        {
            /* Stop it */
            /* FIXME: improve */
            ControlService(hSvc, SERVICE_CONTROL_STOP, &Status);
 
            CloseServiceHandle(hSvc);
 
            /* Refresh the list to clear it */
            RefreshDevicesList(0);
 
            /* Update buttons */
            SetServiceState(FALSE);
        }
 
        CloseServiceHandle(hMgr);
    }
}

Referenced by HandleDriverCommand(), and UsermodeMethod().

wWinMain()

INT WINAPI wWinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		LPWSTR	lpCmdLine,
		int	nShowCmd
	)

This file has no copyright assigned and is placed in the Public Domain. This file is part of the w64 mingw-runtime package. No warranty is given; refer to the file DISCLAIMER.PD within this package.

Definition at line 950 of file vcdcontroltool.c.

{
    MSG Msg;
 
    hInstance = hInst;
 
    /* Just start our main window */
    hWnd = CreateDialogParamW(hInst,
                              MAKEINTRESOURCE(IDD_MAINWINDOW),
                              NULL,
                              MainDialogProc,
                              0);
    /* And dispatch messages in case of a success */
    if (hWnd != NULL)
    {
        while (GetMessageW(&Msg, NULL, 0, 0) != 0)
        {
            TranslateMessage(&Msg);
            DispatchMessageW(&Msg);
        }
    }
 
    return 0;
}

Variable Documentation

hDriverWnd

HWND hDriverWnd

Definition at line 32 of file vcdcontroltool.c.

Referenced by HandleDriverCommand(), QueryDriverInfo(), and SetServiceState().

hInstance

HINSTANCE hInstance

Definition at line 33 of file vcdcontroltool.c.

Referenced by CreateListViewColumns(), DriverControl(), MountImage(), RefreshDevicesList(), and wWinMain().

hMountWnd

HWND hMountWnd

Definition at line 31 of file vcdcontroltool.c.

Referenced by HandleMountCommand(), PerformMount(), and SetMountFileName().

hWnd

HWND hWnd

Definition at line 30 of file vcdcontroltool.c.

Referenced by CreateListViewColumns(), GetSelectedDriveLetter(), HandleCommand(), HandleNotify(), RefreshDevicesList(), ResetStats(), and wWinMain().

wMountLetter

WCHAR wMountLetter

Definition at line 35 of file vcdcontroltool.c.

Referenced by MountImage(), and PerformMount().