DeviceIoControl.c File Reference

#include "precomp.h"
#include <winioctl.h>
#include <mountdev.h>

Include dependency graph for DeviceIoControl.c:

Go to the source code of this file.

Macros
#define	ok_type(condition, format, ...)   ok(condition, "(%d): " format, DriveType, ##__VA_ARGS__)
#define	skip_type(format, ...)   skip("(%d): " format, DriveType, ##__VA_ARGS__)
#define	IOCTL_KSEC_RANDOM_FILL_BUFFER    CTL_CODE(FILE_DEVICE_KSEC, 0x02, METHOD_BUFFERED, FILE_ANY_ACCESS)

Functions
static void	Test_DeviceIoControl_Parameters (void)
static BOOL	GetDiskGeometry (VOID)
static VOID	QueryDeviceName (VOID)
static VOID	QueryUniqueId (VOID)
static VOID	QuerySuggestedLinkName (VOID)
	START_TEST (DeviceIoControl)

Variables
WCHAR	Letter
HANDLE	Device
UINT	DriveType

Macro Definition Documentation

IOCTL_KSEC_RANDOM_FILL_BUFFER

#define IOCTL_KSEC_RANDOM_FILL_BUFFER    CTL_CODE(FILE_DEVICE_KSEC, 0x02, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 20 of file DeviceIoControl.c.

ok_type

#define ok_type	(		condition,
			format,
			...
	)		ok(condition, "(%d): " format, DriveType, ##__VA_ARGS__)

Definition at line 17 of file DeviceIoControl.c.

skip_type

#define skip_type	(		format,
			...
	)		skip("(%d): " format, DriveType, ##__VA_ARGS__)

Definition at line 18 of file DeviceIoControl.c.

Function Documentation

GetDiskGeometry()

static BOOL GetDiskGeometry ( VOID  )

static

Definition at line 58 of file DeviceIoControl.c.

{
    UINT Ret;
    DISK_GEOMETRY DG;
    DWORD Size, Error;
    DISK_GEOMETRY_EX DGE;
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &DG, sizeof(DG) - 1, &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    ok_type(Error == ERROR_INSUFFICIENT_BUFFER, "Expecting ERROR_INSUFFICIENT_BUFFER, got %ld\n", Error);
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &DG, sizeof(DG), &Size, NULL);
    /* Specific for CDROM, no disk present */
    if (Ret == 0 && GetLastError() == ERROR_NOT_READY)
    {
        skip_type("No CDROM present\n");
        return FALSE;
    }
    ok_type(Ret != 0, "DeviceIoControl failed: %ld\n", GetLastError());
    ok_type(Size == sizeof(DG), "Invalid output size: %ld\n", Size);
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, &DGE, FIELD_OFFSET(DISK_GEOMETRY_EX, Data) - 1, &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    ok_type(Error == ERROR_INSUFFICIENT_BUFFER, "Expecting ERROR_INSUFFICIENT_BUFFER, got %ld\n", Error);
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, &DGE, FIELD_OFFSET(DISK_GEOMETRY_EX, Data), &Size, NULL);
    ok_type(Ret != 0, "DeviceIoControl failed: %ld\n", GetLastError());
    ok_type(Size == FIELD_OFFSET(DISK_GEOMETRY_EX, Data), "Invalid output size: %ld\n", Size);
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0, &DGE, sizeof(DGE), &Size, NULL);
    ok_type(Ret != 0, "DeviceIoControl failed: %ld\n", GetLastError());
    if (DriveType == DRIVE_FIXED)
    {
        ok_type(Size == sizeof(DGE), "Invalid output size: %ld\n", Size);
    }
    else
    {
        ok_type(Size == FIELD_OFFSET(DISK_GEOMETRY_EX, Data), "Invalid output size: %ld\n", Size);
    }
 
    return TRUE;
}

Referenced by START_TEST().

QueryDeviceName()

static VOID QueryDeviceName ( VOID  )

static

Definition at line 112 of file DeviceIoControl.c.

{
    UINT Ret;
    BOOL IsValid;
    DWORD Size, Error;
    MOUNTDEV_NAME MDN, *AllocatedMDN;
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &MDN, sizeof(MDN) - 1, &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    if (DriveType == DRIVE_FIXED)
    {
        ok_type(Error == ERROR_INVALID_PARAMETER, "Expecting ERROR_INVALID_PARAMETER, got %ld\n", Error);
    }
    else
    {
        ok_type(Error == ERROR_INSUFFICIENT_BUFFER, "Expecting ERROR_INSUFFICIENT_BUFFER, got %ld\n", Error);
    }
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
 
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, &MDN, sizeof(MDN), &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    ok_type(Error == ERROR_MORE_DATA, "Expecting ERROR_MORE_DATA, got %ld\n", Error);
    ok_type(Size == sizeof(MOUNTDEV_NAME), "Invalid output size: %ld\n", Size);
 
    AllocatedMDN = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MOUNTDEV_NAME, Name) + MDN.NameLength + sizeof(UNICODE_NULL));
    if (AllocatedMDN == NULL)
    {
        skip_type("Memory allocation failure\n");
        return;
    }
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_DEVICE_NAME, NULL, 0, AllocatedMDN, FIELD_OFFSET(MOUNTDEV_NAME, Name) + MDN.NameLength, &Size, NULL);
    ok_type(Ret != 0, "DeviceIoControl failed: %ld\n", GetLastError());
    ok_type(Size == FIELD_OFFSET(MOUNTDEV_NAME, Name) + MDN.NameLength, "Invalid output size: %ld\n", Size);
    ok_type(AllocatedMDN->NameLength == MDN.NameLength, "Mismatching sizes: %d %d\n", AllocatedMDN->NameLength, MDN.NameLength);
 
    if (Ret != 0)
    {
        IsValid = FALSE;
        AllocatedMDN->Name[AllocatedMDN->NameLength / sizeof(WCHAR) - 1] = UNICODE_NULL;
 
        if ((DriveType == DRIVE_FIXED && wcsstr(AllocatedMDN->Name, L"\\Device\\HarddiskVolume") != NULL) ||
            (DriveType == DRIVE_CDROM && wcsstr(AllocatedMDN->Name, L"\\Device\\CdRom") != NULL))
        {
            IsValid = TRUE;
        }
        else if (wcsstr(AllocatedMDN->Name, L"\\DosDevices\\") != NULL)
        {
            IsValid = (AllocatedMDN->Name[12] == Letter && AllocatedMDN->Name[13] == L':');
        }
 
        ok_type(IsValid, "Invalid name: %.*S\n", AllocatedMDN->NameLength, AllocatedMDN->Name);
    }
    else
    {
        skip_type("Failed to query device name\n");
    }
 
    HeapFree(GetProcessHeap(), 0, AllocatedMDN);
}

Referenced by START_TEST().

QuerySuggestedLinkName()

static VOID QuerySuggestedLinkName ( VOID  )

static

Definition at line 223 of file DeviceIoControl.c.

{
    UINT Ret;
    DWORD Size, Error;
    MOUNTDEV_SUGGESTED_LINK_NAME MSLN;
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME, NULL, 0, &MSLN, sizeof(MSLN) - 1, &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    if (DriveType == DRIVE_FIXED)
    {
        ok_type(Error == ERROR_INVALID_PARAMETER, "Expecting ERROR_INVALID_PARAMETER, got %ld\n", Error);
    }
    else
    {
        ok_type(Error == ERROR_INSUFFICIENT_BUFFER, "Expecting ERROR_INSUFFICIENT_BUFFER, got %ld\n", Error);
    }
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
 
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME, NULL, 0, &MSLN, sizeof(MSLN), &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    if (DriveType == DRIVE_FIXED)
    {
        ok_type(Error == ERROR_NOT_FOUND, "Expecting ERROR_NOT_FOUND, got %ld\n", Error);
    }
    else
    {
        ok_type(Error == ERROR_FILE_NOT_FOUND, "Expecting ERROR_FILE_NOT_FOUND, got %ld\n", Error);
    }
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
}

Referenced by START_TEST().

QueryUniqueId()

static VOID QueryUniqueId ( VOID  )

static

Definition at line 179 of file DeviceIoControl.c.

{
    UINT Ret;
    DWORD Size, Error;
    MOUNTDEV_UNIQUE_ID MUI, *AllocatedMUI;
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_UNIQUE_ID, NULL, 0, &MUI, sizeof(MUI) - 1, &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    if (DriveType == DRIVE_FIXED)
    {
        ok_type(Error == ERROR_INVALID_PARAMETER, "Expecting ERROR_INVALID_PARAMETER, got %ld\n", Error);
    }
    else
    {
        ok_type(Error == ERROR_INSUFFICIENT_BUFFER, "Expecting ERROR_INSUFFICIENT_BUFFER, got %ld\n", Error);
    }
    ok_type(Size == 0, "Invalid output size: %ld\n", Size);
 
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_UNIQUE_ID, NULL, 0, &MUI, sizeof(MUI), &Size, NULL);
    ok_type(Ret == 0, "DeviceIoControl succeed\n");
    Error = GetLastError();
    ok_type(Error == ERROR_MORE_DATA, "Expecting ERROR_MORE_DATA, got %ld\n", Error);
    ok_type(Size == sizeof(MOUNTDEV_UNIQUE_ID), "Invalid output size: %ld\n", Size);
 
    AllocatedMUI = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId) + MUI.UniqueIdLength + sizeof(UNICODE_NULL));
    if (AllocatedMUI == NULL)
    {
        skip_type("Memory allocation failure\n");
        return;
    }
 
    Size = 0;
    Ret = DeviceIoControl(Device, IOCTL_MOUNTDEV_QUERY_UNIQUE_ID, NULL, 0, AllocatedMUI, FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId) + MUI.UniqueIdLength, &Size, NULL);
    ok_type(Ret != 0, "DeviceIoControl failed: %ld\n", GetLastError());
    ok_type(Size == FIELD_OFFSET(MOUNTDEV_UNIQUE_ID, UniqueId) + MUI.UniqueIdLength, "Invalid output size: %ld\n", Size);
    ok_type(AllocatedMUI->UniqueIdLength == MUI.UniqueIdLength, "Mismatching sizes: %d %d\n", AllocatedMUI->UniqueIdLength, MUI.UniqueIdLength);
 
    HeapFree(GetProcessHeap(), 0, AllocatedMUI);
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

DeviceIoControl

)

Definition at line 257 of file DeviceIoControl.c.

{
    UINT Ret;
    WCHAR Path[MAX_PATH];
    DWORD DriveMap, Current;
    BOOL DiskDone, CdRomDone;
 
    Test_DeviceIoControl_Parameters();
 
    DiskDone = FALSE;
    CdRomDone = FALSE;
    DriveMap = GetLogicalDrives();
    for (Current = 0; Current < 26; ++Current)
    {
        if (DriveMap & (1 << Current))
        {
            Ret = StringCchPrintfW(Path, MAX_PATH, L"%c:\\", Current + L'A');
            ok(Ret == S_OK, "StringCchPrintfW failed: %d\n", Ret);
 
            DriveType = GetDriveTypeW(Path);
            if ((DriveType == DRIVE_FIXED && !DiskDone) ||
                (DriveType == DRIVE_CDROM && !CdRomDone))
            {
                Ret = StringCchPrintfW(Path, MAX_PATH, L"\\\\?\\%c:", Current + L'A');
                ok(Ret == S_OK, "StringCchPrintfW failed: %d\n", Ret);
 
                Device = CreateFileW(Path, 0, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
                if (Device == INVALID_HANDLE_VALUE)
                {
                    skip_type("CreateFileW for %S failed: %ld\n", Path, GetLastError());
                    continue;
                }
 
                DiskDone = (DiskDone || (DriveType == DRIVE_FIXED));
                CdRomDone = (CdRomDone || (DriveType == DRIVE_CDROM));
 
                if (GetDiskGeometry())
                {
                    QueryDeviceName();
                    QueryUniqueId();
                    QuerySuggestedLinkName();
                }
 
                CloseHandle(Device);
            }
 
            if (CdRomDone && DiskDone)
            {
                break;
            }
        }
    }
 
    if (!DiskDone)
    {
        skip("No disk drive found\n");
    }
 
    if (!CdRomDone)
    {
        skip("No CDROM drive found\n");
    }
}

Test_DeviceIoControl_Parameters()

static void Test_DeviceIoControl_Parameters ( void  )

static

Definition at line 23 of file DeviceIoControl.c.

{
    static const PWSTR KsecDevicePath = L"\\\\.\\Global\\GLOBALROOT\\Device\\KsecDD";
    UCHAR Buffer[16];
    HANDLE hDevice;
    BOOL ret;
 
    /* Open ksecdd device */
    hDevice = CreateFileW(KsecDevicePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    if (hDevice == INVALID_HANDLE_VALUE)
    {
        skip("CreateFile failed: %lu\n", GetLastError());
        return;
    }
 
    /* Test NULL lpBytesReturned (used by wine's wbemprox) */
    SetLastError(0xDEADBEEF);
    StartSeh()
        ret = DeviceIoControl(hDevice,
                              IOCTL_KSEC_RANDOM_FILL_BUFFER,
                              NULL,
                              0,
                              Buffer,
                              sizeof(Buffer),
                              NULL, /* lpBytesReturned */
                              NULL);
        ok_eq_bool(ret, TRUE);
        ok_eq_ulong(GetLastError(), 0xDEADBEEF);
    EndSeh(is_reactos() || (GetNTVersion() >= _WIN32_WINNT_WIN8) ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER);
 
    CloseHandle(hDevice);
}

Referenced by START_TEST().

Variable Documentation

Device

HANDLE Device

Definition at line 14 of file DeviceIoControl.c.

DriveType

UINT DriveType

Definition at line 15 of file DeviceIoControl.c.

Referenced by CDrivesExtractIcon_CreateInstance(), DiskOpen(), DosDeviceIoControlDrive(), DosIsFileOnCdRom(), DriveType(), FormatDrive(), FreeLdrMigrateBootDrivePartWorker(), CDrivesFolder::GetDetailsOf(), GetDiskGeometry(), GetUnattendInfPath(), CDrvDefExt::InitGeneralPage(), ObpProcessDosDeviceSymbolicLink(), PcInitializeBootDevices(), QueryDeviceName(), QuerySuggestedLinkName(), QueryUniqueId(), and START_TEST().

Letter

WCHAR Letter

Definition at line 13 of file DeviceIoControl.c.

Referenced by _tmain(), AddDrive(), AssignDriveLetters(), BasepGetComputerNameFromNtPath(), CreateNewDriveLetterName(), CSR_API(), DefineDosDeviceW(), EjectDrive(), HandleNotify(), IsDriveLetter(), IsLetterOwned(), MountMgrMountedDeviceArrival(), OpenLetter(), QueryDeviceName(), RefreshDevicesList(), RemountImage(), RemoveDrive(), SetMountedDeviceValue(), ViCreateDriveAndMountImage(), ViCreateDriveLetter(), and ViLoadImagesFromRegistry().