rawinput.c File Reference

#include <win32k.h>
#include <debug.h>

Include dependency graph for rawinput.c:

Go to the source code of this file.

Classes
struct	_USER_RAWINPUT

Macros
#define	NDEBUG
#define	HID_USAGE_PAGE_GENERIC   0x01
#define	HID_USAGE_GENERIC_MOUSE   0x02
#define	HID_USAGE_GENERIC_KEYBOARD   0x06
#define	MAX_RAWINPUT_PER_QUEUE   256

Typedefs
typedef struct _USER_RAWINPUT	USER_RAWINPUT
typedef struct _USER_RAWINPUT *	PUSER_RAWINPUT

Functions
	C_ASSERT (FIELD_OFFSET(RAWINPUT, data)==sizeof(RAWINPUTHEADER))
	C_ASSERT (sizeof(RAWINPUTHEADER)+sizeof(RAWMOUSE)<=sizeof(RAWINPUT))
	C_ASSERT (sizeof(RAWINPUTHEADER)+sizeof(RAWKEYBOARD)<=sizeof(RAWINPUT))
DWORD APIENTRY	NtUserGetRawInputDeviceInfo (_In_opt_ HANDLE hDevice, _In_ UINT uiCommand, _Inout_opt_ LPVOID pData, _Inout_ PUINT pcbSize)
static INT	RawInputDeviceIndexFromType (DWORD dwType)
static PRAWINPUTDEVICE	RawInputRegistrationFromType (DWORD dwType)
static VOID	RawInputWarnUnimplementedFlags (const RAWINPUTDEVICE *Device)
static PUSER_RAWINPUT	RawInputEntryFromHandle (PUSER_MESSAGE_QUEUE MessageQueue, HRAWINPUT hRawInput)
static VOID	RawInputFreeEntry (PUSER_MESSAGE_QUEUE MessageQueue, PUSER_RAWINPUT RawEntry)
NTSTATUS NTAPI	InitRawInputImpl (VOID)
HRAWINPUT FASTCALL	UserCreateRawInput (PTHREADINFO pti, DWORD dwType, HANDLE hDevice, WPARAM wParam, CONST VOID *pData, UINT cbData)
BOOL FASTCALL	UserFreeRawInput (PUSER_MESSAGE_QUEUE MessageQueue, HRAWINPUT hRawInput)
VOID FASTCALL	UserUpdatePrevRawInput (PTHREADINFO pti, CONST MSG *pMsg)
VOID FASTCALL	UserCleanupRawInput (PUSER_MESSAGE_QUEUE MessageQueue)
BOOL FASTCALL	UserGetRawInputTarget (DWORD dwType, PTHREADINFO *ppti, HWND *phwndTarget, WPARAM *pwParam)
static DWORD	RawInputCopyData (PRAWINPUT RawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader)
DWORD APIENTRY	NtUserGetRawInputBuffer (PRAWINPUT pData, PUINT pcbSize, UINT cbSizeHeader)
DWORD APIENTRY	NtUserGetRawInputDeviceList (_Out_opt_ PRAWINPUTDEVICELIST pRawInputDeviceList, _Inout_ PUINT puiNumDevices, _In_ UINT cbSize)
DWORD NTAPI	NtUserGetRawInputData (HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader)
DWORD APIENTRY	NtUserGetRegisteredRawInputDevices (_Out_opt_ PRAWINPUTDEVICE pRawInputDevices, _Inout_ PUINT puiNumDevices, _In_ UINT cbSize)
BOOL APIENTRY	NtUserRegisterRawInputDevices (IN PCRAWINPUTDEVICE pRawInputDevices, IN UINT uiNumDevices, IN UINT cbSize)

Variables
static PAGED_LOOKASIDE_LIST	gRawInputLookasideList
PRAWINPUTDEVICE	global_pRawInputDevices = NULL
BOOLEAN	RawInputEnabled = FALSE

Macro Definition Documentation

HID_USAGE_GENERIC_KEYBOARD

#define HID_USAGE_GENERIC_KEYBOARD   0x06

Definition at line 21 of file rawinput.c.

HID_USAGE_GENERIC_MOUSE

#define HID_USAGE_GENERIC_MOUSE   0x02

Definition at line 17 of file rawinput.c.

HID_USAGE_PAGE_GENERIC

#define HID_USAGE_PAGE_GENERIC   0x01

Definition at line 13 of file rawinput.c.

MAX_RAWINPUT_PER_QUEUE

#define MAX_RAWINPUT_PER_QUEUE   256

Definition at line 34 of file rawinput.c.

NDEBUG

#define NDEBUG

Definition at line 9 of file rawinput.c.

Typedef Documentation

PUSER_RAWINPUT

typedef struct _USER_RAWINPUT * PUSER_RAWINPUT

USER_RAWINPUT

typedef struct _USER_RAWINPUT USER_RAWINPUT

Function Documentation

C_ASSERT() [1/3]

C_ASSERT

(

FIELD_OFFSET(RAWINPUT, data)

= =sizeof(RAWINPUTHEADER)

)

C_ASSERT() [2/3]

C_ASSERT

(

sizeof(RAWINPUTHEADER)+sizeof(RAWKEYBOARD)<=sizeof(RAWINPUT)

)

C_ASSERT() [3/3]

C_ASSERT

(

sizeof(RAWINPUTHEADER)+sizeof(RAWMOUSE)<=sizeof(RAWINPUT)

)

InitRawInputImpl()

NTSTATUS NTAPI InitRawInputImpl

(

VOID

)

Definition at line 309 of file rawinput.c.

{
    ExInitializePagedLookasideList(&gRawInputLookasideList,
                                   NULL,
                                   NULL,
                                   0,
                                   sizeof(USER_RAWINPUT),
                                   'iwar',
                                   256);
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

NtUserGetRawInputBuffer()

DWORD APIENTRY NtUserGetRawInputBuffer	(	PRAWINPUT	pData,
		PUINT	pcbSize,
		UINT	cbSizeHeader
	)

Definition at line 539 of file rawinput.c.

{
    PTHREADINFO pti;
    PUSER_MESSAGE_QUEUE MessageQueue;
    PUSER_RAWINPUT RawEntry;
    PLIST_ENTRY Entry, NextEntry;
    UINT BufferSize, UsedSize = 0, Count = 0;
 
    if (cbSizeHeader != sizeof(RAWINPUTHEADER) || !pcbSize)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return ~0u;
    }
 
    pti = PsGetCurrentThreadWin32Thread();
    MessageQueue = pti ? pti->MessageQueue : NULL;
    if (!MessageQueue)
    {
        *pcbSize = 0;
        return 0;
    }
 
    Entry = MessageQueue->HardwareMessagesListHead.Flink;
    if (!pData)
    {
        while (Entry != &MessageQueue->HardwareMessagesListHead)
        {
            PUSER_MESSAGE Message = CONTAINING_RECORD(Entry, USER_MESSAGE, ListEntry);
            if (Message->Msg.message == WM_INPUT)
            {
                RawEntry = RawInputEntryFromHandle(MessageQueue, (HRAWINPUT)Message->Msg.lParam);
                *pcbSize = RawEntry ? RawEntry->RawInput.header.dwSize : 0;
                EngSetLastError(ERROR_SUCCESS);
                return 0;
            }
            Entry = Entry->Flink;
        }
 
        *pcbSize = 0;
        return 0;
    }
 
    BufferSize = *pcbSize;
    while (Entry != &MessageQueue->HardwareMessagesListHead)
    {
        PUSER_MESSAGE Message;
        UINT RawSize;
 
        NextEntry = Entry->Flink;
        Message = CONTAINING_RECORD(Entry, USER_MESSAGE, ListEntry);
        Entry = NextEntry;
 
        if (Message->Msg.message != WM_INPUT)
            continue;
 
        RawEntry = RawInputEntryFromHandle(MessageQueue, (HRAWINPUT)Message->Msg.lParam);
        if (!RawEntry)
            continue;
 
        RawSize = RawEntry->RawInput.header.dwSize;
        if (UsedSize + RawSize > BufferSize)
        {
            if (Count == 0)
            {
                *pcbSize = RawSize;
                EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
                return ~0u;
            }
            break;
        }
 
        RtlCopyMemory((PBYTE)pData + UsedSize, &RawEntry->RawInput, RawSize);
        UsedSize += RawSize;
        Count++;
 
        ClearMsgBitsMask(pti, Message->QS_Flags);
        MsqDestroyMessage(Message);
        RawInputFreeEntry(MessageQueue, RawEntry);
    }
 
    return Count;
}

Referenced by GetRawInputBuffer().

NtUserGetRawInputData()

DWORD NTAPI NtUserGetRawInputData	(	HRAWINPUT	hRawInput,
		UINT	uiCommand,
		LPVOID	pData,
		PUINT	pcbSize,
		UINT	cbSizeHeader
	)

Definition at line 687 of file rawinput.c.

{
    PTHREADINFO pti;
    PUSER_MESSAGE_QUEUE MessageQueue;
    PUSER_RAWINPUT RawEntry;
 
    if (cbSizeHeader != sizeof(RAWINPUTHEADER) || !pcbSize)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return ~0u;
    }
 
    if (!hRawInput)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ~0u;
    }
 
    pti = PsGetCurrentThreadWin32Thread();
    MessageQueue = pti ? pti->MessageQueue : NULL;
    RawEntry = RawInputEntryFromHandle(MessageQueue, hRawInput);
    if (!RawEntry)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ~0u;
    }
 
    return RawInputCopyData(&RawEntry->RawInput, uiCommand, pData, pcbSize, cbSizeHeader);
}

NtUserGetRawInputDeviceInfo()

DWORD APIENTRY NtUserGetRawInputDeviceInfo	(	_In_opt_ HANDLE	hDevice,
		_In_ UINT	uiCommand,
		_Inout_opt_ LPVOID	pData,
		_Inout_ PUINT	pcbSize
	)

Definition at line 42 of file rawinput.c.

{
    PINPUT_DEVICE_INFO DeviceInfo;
    UINT cbSize, cbRequiredSize;
    UINT Ret = (UINT)-1;
 
    _SEH2_TRY
    {
        ProbeForRead(pcbSize, sizeof(*pcbSize), sizeof(DWORD));
        cbSize = *pcbSize;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
        _SEH2_YIELD(return Ret);
    }
    _SEH2_END;
 
    AcquireDeviceInfoListMutex();
    for (DeviceInfo = gpInputDeviceInfo; DeviceInfo && DeviceInfo != hDevice; DeviceInfo = DeviceInfo->pNextDeviceInfo)
        ;
    if (!DeviceInfo)
    {
        ReleaseDeviceInfoListMutex();
        EngSetLastError(ERROR_INVALID_HANDLE);
        return Ret;
    }
 
    UserEnterShared();
 
    switch (uiCommand)
    {
        case RIDI_PREPARSEDDATA:
            if (DeviceInfo->DeviceType == RIM_TYPEHID)
                cbRequiredSize = DeviceInfo->Hid.CollectionInformation.DescriptorSize;
            else
                cbRequiredSize = 0;
            break;
        case RIDI_DEVICENAME:
            cbRequiredSize = DeviceInfo->DeviceName.Length / sizeof(WCHAR) + sizeof(ANSI_NULL);
            break;
        case RIDI_DEVICEINFO:
            cbRequiredSize = sizeof(RID_DEVICE_INFO);
            break;
        default:
            EngSetLastError(ERROR_INVALID_PARAMETER);
            goto cleanup;
    }
 
    _SEH2_TRY
    {
        if (!pData)
        {
            ProbeForWrite(pcbSize, sizeof(*pcbSize), sizeof(DWORD));
            *pcbSize = cbRequiredSize;
            Ret = 0;
            _SEH2_LEAVE;
        }
 
        if (cbSize < cbRequiredSize)
        {
            ProbeForWrite(pcbSize, sizeof(*pcbSize), sizeof(DWORD));
            *pcbSize = cbRequiredSize;
            EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
            _SEH2_LEAVE;
        }
 
        ProbeForWrite(pData, cbRequiredSize, sizeof(DWORD));
        switch (uiCommand)
        {
            case RIDI_PREPARSEDDATA:
                if (DeviceInfo->DeviceType == RIM_TYPEHID)
                    RtlCopyMemory(pData, DeviceInfo->Hid.PreparsedData, cbRequiredSize);
                break;
            case RIDI_DEVICENAME:
                // As cbSize/cbRequiredSize are in chars, we didn't probe a big enough buffer
                // Do it again
                ProbeForWrite(pData, DeviceInfo->DeviceName.Length + sizeof(UNICODE_NULL), sizeof(DWORD));
                RtlCopyMemory(pData, DeviceInfo->DeviceName.Buffer, DeviceInfo->DeviceName.Length);
                ((WCHAR*)pData)[cbRequiredSize - 1] = UNICODE_NULL;
                break;
            case RIDI_DEVICEINFO:
            {
                PRID_DEVICE_INFO prdi = pData;
                ProbeForRead(&prdi->cbSize, sizeof(prdi->cbSize), sizeof(DWORD));
                if (prdi->cbSize != cbRequiredSize)
                {
                    EngSetLastError(ERROR_INVALID_PARAMETER);
                    _SEH2_YIELD(break);
                }
 
                ProbeForWrite(prdi, sizeof(*prdi), sizeof(DWORD));
                RtlZeroMemory(prdi, sizeof(*prdi));
                prdi->cbSize = sizeof(*prdi);
                prdi->dwType = DeviceInfo->DeviceType;
 
                switch (DeviceInfo->DeviceType)
                {
                    case RIM_TYPEMOUSE:
                        prdi->mouse.dwId = DeviceInfo->Mouse.Attributes.MouseIdentifier & ~HORIZONTAL_WHEEL_PRESENT;
                        prdi->mouse.dwNumberOfButtons = DeviceInfo->Mouse.Attributes.NumberOfButtons;
                        prdi->mouse.dwSampleRate = DeviceInfo->Mouse.Attributes.SampleRate;
                        prdi->mouse.fHasHorizontalWheel = !!(DeviceInfo->Mouse.Attributes.MouseIdentifier & HORIZONTAL_WHEEL_PRESENT);
                        break;
 
                    case RIM_TYPEKEYBOARD:
                        prdi->keyboard.dwType = DeviceInfo->Keyboard.Attributes.KeyboardIdentifier.Type;
                        prdi->keyboard.dwSubType = DeviceInfo->Keyboard.Attributes.KeyboardIdentifier.Subtype;
                        prdi->keyboard.dwKeyboardMode = DeviceInfo->Keyboard.Attributes.KeyboardMode;
                        prdi->keyboard.dwNumberOfFunctionKeys = DeviceInfo->Keyboard.Attributes.NumberOfFunctionKeys;
                        prdi->keyboard.dwNumberOfIndicators = DeviceInfo->Keyboard.Attributes.NumberOfIndicators;
                        prdi->keyboard.dwNumberOfKeysTotal = DeviceInfo->Keyboard.Attributes.NumberOfKeysTotal;
                        break;
 
                    case RIM_TYPEHID:
                        prdi->hid.dwVendorId = DeviceInfo->Hid.CollectionInformation.VendorID;
                        prdi->hid.dwProductId = DeviceInfo->Hid.CollectionInformation.ProductID;
                        prdi->hid.dwVersionNumber = DeviceInfo->Hid.CollectionInformation.VersionNumber;
                        prdi->hid.usUsagePage = DeviceInfo->Hid.Caps.UsagePage;
                        prdi->hid.usUsage = DeviceInfo->Hid.Caps.Usage;
                        break;
 
                    default:
                        break;
                }
                break;
            }
            default:
                ASSERT(FALSE);
                break;
        }
        Ret = cbRequiredSize;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
cleanup:
    UserLeave();
    ReleaseDeviceInfoListMutex();
    return Ret;
}

NtUserGetRawInputDeviceList()

DWORD APIENTRY NtUserGetRawInputDeviceList	(	_Out_opt_ PRAWINPUTDEVICELIST	pRawInputDeviceList,
		_Inout_ PUINT	puiNumDevices,
		_In_ UINT	cbSize
	)

Definition at line 627 of file rawinput.c.

{
    PINPUT_DEVICE_INFO DeviceInfo;
    UINT cDevices = 0, i, Ret = (UINT)-1;
 
    if (cbSize != sizeof(RAWINPUTDEVICELIST))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return Ret;
    }
 
    AcquireDeviceInfoListMutex();
    for (DeviceInfo = gpInputDeviceInfo; DeviceInfo; DeviceInfo = DeviceInfo->pNextDeviceInfo)
        cDevices++;
 
    UserEnterShared();
 
    _SEH2_TRY
    {
        if (!pRawInputDeviceList)
        {
            ProbeForWrite(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
            *puiNumDevices = cDevices;
            Ret = 0;
            _SEH2_LEAVE;
        }
 
        ProbeForRead(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
        if (*puiNumDevices < cDevices)
        {
            ProbeForWrite(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
            *puiNumDevices = cDevices;
            EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
            _SEH2_LEAVE;
        }
 
        ProbeForWrite(pRawInputDeviceList, cDevices * sizeof(*pRawInputDeviceList), sizeof(PVOID));
        for (DeviceInfo = gpInputDeviceInfo, i = 0; DeviceInfo && i < cDevices; DeviceInfo = DeviceInfo->pNextDeviceInfo, i++)
        {
            pRawInputDeviceList[i].hDevice = DeviceInfo;
            pRawInputDeviceList[i].dwType = DeviceInfo->DeviceType;
        }
        Ret = cDevices;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    UserLeave();
    ReleaseDeviceInfoListMutex();
    return Ret;
}

NtUserGetRegisteredRawInputDevices()

DWORD APIENTRY NtUserGetRegisteredRawInputDevices	(	_Out_opt_ PRAWINPUTDEVICE	pRawInputDevices,
		_Inout_ PUINT	puiNumDevices,
		_In_ UINT	cbSize
	)

Definition at line 725 of file rawinput.c.

{
    RAWINPUTDEVICE Registrations[2];
    PRAWINPUTDEVICE Registration;
    UINT cDevices = 0, uiNumDevices, Ret = (UINT)-1;
 
    if (cbSize != sizeof(*pRawInputDevices))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return Ret;
    }
 
    UserEnterShared();
 
    /* Snapshot the registrations, ordered by usage like Windows does */
    Registration = RawInputRegistrationFromType(RIM_TYPEMOUSE);
    if (Registration)
        Registrations[cDevices++] = *Registration;
 
    Registration = RawInputRegistrationFromType(RIM_TYPEKEYBOARD);
    if (Registration)
        Registrations[cDevices++] = *Registration;
 
    _SEH2_TRY
    {
        if (!pRawInputDevices)
        {
            ProbeForWrite(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
            *puiNumDevices = cDevices;
            Ret = 0;
            _SEH2_LEAVE;
        }
 
        ProbeForRead(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
        uiNumDevices = *puiNumDevices;
        if (uiNumDevices == 0)
        {
            EngSetLastError(ERROR_INVALID_PARAMETER);
            _SEH2_LEAVE;
        }
 
        /* Windows raises an access violation for counts it cannot probe */
        if (uiNumDevices > MAXULONG / sizeof(*pRawInputDevices))
        {
            EngSetLastError(ERROR_NOACCESS);
            _SEH2_LEAVE;
        }
 
        ProbeForWrite(pRawInputDevices, uiNumDevices * sizeof(*pRawInputDevices), sizeof(PVOID));
        if (uiNumDevices < cDevices)
        {
            ProbeForWrite(puiNumDevices, sizeof(*puiNumDevices), sizeof(DWORD));
            *puiNumDevices = cDevices;
            EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
            _SEH2_LEAVE;
        }
 
        RtlCopyMemory(pRawInputDevices, Registrations, cDevices * sizeof(*pRawInputDevices));
        Ret = cDevices;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    UserLeave();
    return Ret;
}

NtUserRegisterRawInputDevices()

BOOL APIENTRY NtUserRegisterRawInputDevices	(	IN PCRAWINPUTDEVICE	pRawInputDevices,
		IN UINT	uiNumDevices,
		IN UINT	cbSize
	)

Definition at line 800 of file rawinput.c.

{
    UINT i;
 
    if (!pRawInputDevices || !uiNumDevices || cbSize != sizeof(RAWINPUTDEVICE))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (!global_pRawInputDevices)
    {
        global_pRawInputDevices = EngAllocMem(NonPagedPool,
                                              2 * sizeof(RAWINPUTDEVICE),
                                              'iwar');
        if (!global_pRawInputDevices)
        {
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
 
        RtlZeroMemory(global_pRawInputDevices, 2 * sizeof(RAWINPUTDEVICE));
    }
 
    for (i = 0; i < uiNumDevices; ++i)
    {
        INT Index;
        const RAWINPUTDEVICE *Device = &pRawInputDevices[i];
 
        if ((Device->dwFlags & RIDEV_INPUTSINK) && !Device->hwndTarget)
        {
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        if ((Device->dwFlags & RIDEV_REMOVE) && Device->hwndTarget)
        {
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
 
        RawInputWarnUnimplementedFlags(Device);
 
        if (Device->usUsagePage != HID_USAGE_PAGE_GENERIC)
            continue;
 
        if (Device->usUsage == HID_USAGE_GENERIC_MOUSE)
            Index = 0;
        else if (Device->usUsage == HID_USAGE_GENERIC_KEYBOARD)
            Index = 1;
        else
            continue;
 
        if (Device->dwFlags & RIDEV_REMOVE)
            RtlZeroMemory(&global_pRawInputDevices[Index], sizeof(RAWINPUTDEVICE));
        else
            global_pRawInputDevices[Index] = *Device;
    }
 
    RawInputEnabled =
        (global_pRawInputDevices[0].usUsage != 0) ||
        (global_pRawInputDevices[1].usUsage != 0);
 
    return TRUE;
}

RawInputCopyData()

static DWORD RawInputCopyData ( PRAWINPUT  RawInput, UINT  uiCommand, LPVOID  pData, PUINT  pcbSize, UINT  cbSizeHeader  )

static

Definition at line 484 of file rawinput.c.

{
    UINT OutputDataSize;
 
    if (cbSizeHeader != sizeof(RAWINPUTHEADER) || !pcbSize)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return ~0u;
    }
 
    switch (uiCommand)
    {
        case RID_INPUT:
            OutputDataSize = RawInput->header.dwSize;
            break;
 
        case RID_HEADER:
            OutputDataSize = sizeof(RAWINPUTHEADER);
            break;
 
        default:
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return ~0u;
    }
 
    if (!pData)
    {
        *pcbSize = OutputDataSize;
        EngSetLastError(ERROR_SUCCESS);
        return 0;
    }
 
    if (*pcbSize < OutputDataSize)
    {
        *pcbSize = OutputDataSize;
        EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
        return ~0u;
    }
 
    if (uiCommand == RID_HEADER)
        RtlCopyMemory(pData, &RawInput->header, OutputDataSize);
    else
        RtlCopyMemory(pData, RawInput, OutputDataSize);
 
    return OutputDataSize;
}

Referenced by NtUserGetRawInputData().

RawInputDeviceIndexFromType()

static INT RawInputDeviceIndexFromType ( DWORD  dwType )

static

Definition at line 194 of file rawinput.c.

{
    switch (dwType)
    {
        case RIM_TYPEMOUSE:
            return 0;
 
        case RIM_TYPEKEYBOARD:
            return 1;
 
        default:
            return -1;
    }
}

Referenced by RawInputRegistrationFromType().

RawInputEntryFromHandle()

static PUSER_RAWINPUT RawInputEntryFromHandle ( PUSER_MESSAGE_QUEUE  MessageQueue, HRAWINPUT  hRawInput  )

static

Definition at line 273 of file rawinput.c.

{
    PLIST_ENTRY Entry;
 
    if (!MessageQueue || !hRawInput)
        return NULL;
 
    for (Entry = MessageQueue->RawInputListHead.Flink;
         Entry != &MessageQueue->RawInputListHead;
         Entry = Entry->Flink)
    {
        PUSER_RAWINPUT RawEntry = CONTAINING_RECORD(Entry, USER_RAWINPUT, ListEntry);
        if ((HRAWINPUT)&RawEntry->RawInput == hRawInput)
            return RawEntry;
    }
 
    return NULL;
}

Referenced by NtUserGetRawInputBuffer(), NtUserGetRawInputData(), and UserFreeRawInput().

RawInputFreeEntry()

static VOID RawInputFreeEntry ( PUSER_MESSAGE_QUEUE  MessageQueue, PUSER_RAWINPUT  RawEntry  )

static

Definition at line 296 of file rawinput.c.

{
    ASSERT(MessageQueue->cRawInput > 0);
    RemoveEntryList(&RawEntry->ListEntry);
    MessageQueue->cRawInput--;
    ExFreeToPagedLookasideList(&gRawInputLookasideList, RawEntry);
}

Referenced by NtUserGetRawInputBuffer(), UserCleanupRawInput(), and UserFreeRawInput().

RawInputRegistrationFromType()

static PRAWINPUTDEVICE RawInputRegistrationFromType ( DWORD  dwType )

static

Definition at line 212 of file rawinput.c.

{
    INT Index = RawInputDeviceIndexFromType(dwType);
 
    if (!global_pRawInputDevices || Index < 0)
        return NULL;
 
    if (global_pRawInputDevices[Index].usUsagePage != HID_USAGE_PAGE_GENERIC)
        return NULL;
 
    if ((dwType == RIM_TYPEMOUSE && global_pRawInputDevices[Index].usUsage != HID_USAGE_GENERIC_MOUSE) ||
        (dwType == RIM_TYPEKEYBOARD && global_pRawInputDevices[Index].usUsage != HID_USAGE_GENERIC_KEYBOARD))
        return NULL;
 
    return &global_pRawInputDevices[Index];
}

Referenced by NtUserGetRegisteredRawInputDevices(), and UserGetRawInputTarget().

RawInputWarnUnimplementedFlags()

static VOID RawInputWarnUnimplementedFlags ( const RAWINPUTDEVICE *  Device )

static

Definition at line 232 of file rawinput.c.

{
    BOOL IsMouse = (Device->usUsagePage == HID_USAGE_PAGE_GENERIC &&
                    Device->usUsage == HID_USAGE_GENERIC_MOUSE);
    BOOL IsKeyboard = (Device->usUsagePage == HID_USAGE_PAGE_GENERIC &&
                       Device->usUsage == HID_USAGE_GENERIC_KEYBOARD);
    DWORD PageFlags = Device->dwFlags & (RIDEV_PAGEONLY | RIDEV_EXCLUDE);
 
    if ((PageFlags == RIDEV_NOLEGACY) && (IsMouse || IsKeyboard))
    {
        DPRINT1("RIDEV_NOLEGACY for raw %s is accepted but not implemented yet.\n",
                IsMouse ? "mouse" : "keyboard");
    }
    else
    {
        if (Device->dwFlags & RIDEV_PAGEONLY)
            DPRINT1("RIDEV_PAGEONLY is accepted but not implemented yet.\n");
 
        if (Device->dwFlags & RIDEV_EXCLUDE)
            DPRINT1("RIDEV_EXCLUDE is accepted but not implemented yet.\n");
    }
 
    if (IsMouse && (Device->dwFlags & RIDEV_CAPTUREMOUSE))
        DPRINT1("RIDEV_CAPTUREMOUSE for raw mouse is accepted but not implemented yet.\n");
 
    if (IsKeyboard && (Device->dwFlags & RIDEV_NOHOTKEYS))
        DPRINT1("RIDEV_NOHOTKEYS for raw keyboard is accepted but not implemented yet.\n");
 
    if (IsKeyboard && (Device->dwFlags & RIDEV_APPKEYS))
        DPRINT1("RIDEV_APPKEYS for raw keyboard is accepted but not implemented yet.\n");
 
    if (Device->dwFlags & RIDEV_EXINPUTSINK)
        DPRINT1("RIDEV_EXINPUTSINK is only partially implemented.\n");
 
    if (Device->dwFlags & RIDEV_DEVNOTIFY)
        DPRINT1("RIDEV_DEVNOTIFY is accepted but not implemented yet.\n");
}

Referenced by NtUserRegisterRawInputDevices().

UserCleanupRawInput()

VOID FASTCALL UserCleanupRawInput

(

PUSER_MESSAGE_QUEUE

MessageQueue

)

Definition at line 398 of file rawinput.c.

{
    while (!IsListEmpty(&MessageQueue->RawInputListHead))
    {
        PUSER_RAWINPUT RawEntry;
        RawEntry = CONTAINING_RECORD(MessageQueue->RawInputListHead.Flink,
                                     USER_RAWINPUT,
                                     ListEntry);
        RawInputFreeEntry(MessageQueue, RawEntry);
    }
}

Referenced by MsqCleanupMessageQueue().

UserCreateRawInput()

HRAWINPUT FASTCALL UserCreateRawInput	(	PTHREADINFO	pti,
		DWORD	dwType,
		HANDLE	hDevice,
		WPARAM	wParam,
		CONST VOID *	pData,
		UINT	cbData
	)

Definition at line 323 of file rawinput.c.

{
    PUSER_RAWINPUT RawEntry;
 
    if (!pti || !pti->MessageQueue || !pData)
        return NULL;
 
    ASSERT(cbData <= sizeof(RawEntry->RawInput.data));
    if (cbData > sizeof(RawEntry->RawInput.data))
        return NULL;
 
    if (pti->MessageQueue->cRawInput >= MAX_RAWINPUT_PER_QUEUE)
    {
        DPRINT("Dropping raw input, queue %p is not being pumped\n", pti->MessageQueue);
        return NULL;
    }
 
    RawEntry = ExAllocateFromPagedLookasideList(&gRawInputLookasideList);
    if (!RawEntry)
        return NULL;
 
    RtlZeroMemory(RawEntry, sizeof(*RawEntry));
    RawEntry->RawInput.header.dwType = dwType;
    RawEntry->RawInput.header.dwSize = sizeof(RAWINPUTHEADER) + cbData;
    RawEntry->RawInput.header.hDevice = hDevice;
    RawEntry->RawInput.header.wParam = wParam;
    RtlCopyMemory(&RawEntry->RawInput.data, pData, cbData);
 
    InsertTailList(&pti->MessageQueue->RawInputListHead, &RawEntry->ListEntry);
    pti->MessageQueue->cRawInput++;
    return (HRAWINPUT)&RawEntry->RawInput;
}

Referenced by UserRawInputMouseProcess(), and UserRawInputProcessKeyboardInput().

UserFreeRawInput()

BOOL FASTCALL UserFreeRawInput	(	PUSER_MESSAGE_QUEUE	MessageQueue,
		HRAWINPUT	hRawInput
	)

Definition at line 364 of file rawinput.c.

{
    PUSER_RAWINPUT RawEntry = RawInputEntryFromHandle(MessageQueue, hRawInput);
 
    if (!RawEntry)
        return FALSE;
 
    RawInputFreeEntry(MessageQueue, RawEntry);
    return TRUE;
}

Referenced by MsqCleanupMessageQueue(), UserRawInputMouseProcess(), UserRawInputProcessKeyboardInput(), and UserUpdatePrevRawInput().

UserGetRawInputTarget()

BOOL FASTCALL UserGetRawInputTarget	(	DWORD	dwType,
		PTHREADINFO *	ppti,
		HWND *	phwndTarget,
		WPARAM *	pwParam
	)

Definition at line 413 of file rawinput.c.

{
    PRAWINPUTDEVICE Registration;
    PUSER_MESSAGE_QUEUE pFocusQueue;
    PWND pWnd = NULL;
    PTHREADINFO pti;
 
    Registration = RawInputRegistrationFromType(dwType);
    if (!Registration)
        return FALSE;
 
    pFocusQueue = IntGetFocusMessageQueue();
    if (!pFocusQueue)
        return FALSE;
 
    if (Registration->hwndTarget)
    {
        pWnd = UserGetWindowObject(Registration->hwndTarget);
        if (!pWnd)
            return FALSE;
    }
    else
    {
        pWnd = pFocusQueue->spwndFocus;
        if (!pWnd)
            pWnd = pFocusQueue->spwndActive;
        if (!pWnd)
            return FALSE;
    }
 
    pti = pWnd->head.pti;
    if (!pti)
        return FALSE;
 
    if (pFocusQueue->ptiKeyboard && pti->rpdesk != pFocusQueue->ptiKeyboard->rpdesk)
        return FALSE;
 
    if (Registration->dwFlags & RIDEV_INPUTSINK)
    {
        *pwParam = (pti->MessageQueue == pFocusQueue) ? RIM_INPUT : RIM_INPUTSINK;
        *phwndTarget = UserHMGetHandle(pWnd);
        *ppti = pti;
        return TRUE;
    }
 
    if (Registration->dwFlags & RIDEV_EXINPUTSINK)
    {
        if (pti->MessageQueue != pFocusQueue)
            return FALSE; /* FIXME: Needs per-process arbitration like Windows */
 
        *pwParam = RIM_INPUT;
        *phwndTarget = UserHMGetHandle(pWnd);
        *ppti = pti;
        return TRUE;
    }
 
    if (pti->MessageQueue != pFocusQueue)
        return FALSE;
 
    *pwParam = RIM_INPUT;
    *phwndTarget = UserHMGetHandle(pWnd);
    *ppti = pti;
    return TRUE;
}

Referenced by UserRawInputMouseProcess(), and UserRawInputProcessKeyboardInput().

UserUpdatePrevRawInput()

VOID FASTCALL UserUpdatePrevRawInput	(	PTHREADINFO	pti,
		CONST MSG *	pMsg
	)

Definition at line 379 of file rawinput.c.

{
    if (pti->hPrevRawInput)
    {
        UserFreeRawInput(pti->MessageQueue, pti->hPrevRawInput);
        pti->hPrevRawInput = NULL;
    }
 
    if (pMsg->message == WM_INPUT &&
        (pMsg->wParam == RIM_INPUT || pMsg->wParam == RIM_INPUTSINK))
    {
        pti->hPrevRawInput = (HRAWINPUT)pMsg->lParam;
    }
}

Referenced by co_IntPeekMessage().

Variable Documentation

global_pRawInputDevices

PRAWINPUTDEVICE global_pRawInputDevices = NULL

Definition at line 37 of file rawinput.c.

Referenced by NtUserRegisterRawInputDevices(), and RawInputRegistrationFromType().

gRawInputLookasideList

PAGED_LOOKASIDE_LIST gRawInputLookasideList

static

Definition at line 36 of file rawinput.c.

Referenced by InitRawInputImpl(), RawInputFreeEntry(), and UserCreateRawInput().

RawInputEnabled

BOOLEAN RawInputEnabled = FALSE

Definition at line 38 of file rawinput.c.

Referenced by NtUserRegisterRawInputDevices(), UserProcessKeyboardInput(), and UserProcessMouseInput().