input.c File Reference

#include <win32k.h>

Include dependency graph for input.c:

Go to the source code of this file.

Macros
#define	LAST_RIT_EVENT_UPDATE_INTERVAL   1000UL

Functions
	DBG_DEFAULT_CHANNEL (UserInput)
static VOID NTAPI	RITReadApc (_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
static DWORD FASTCALL	IntLastInputTick (BOOL bUpdate)
VOID FASTCALL	DoTheScreenSaver (VOID)
static PINPUT_DEVICE_INFO	CreateInputDevice (_In_ UCHAR DeviceType, _In_ PUNICODE_STRING DeviceName)
static NTSTATUS NTAPI	OpenInputDevice (_In_ PINPUT_DEVICE_INFO DeviceInfo)
static VOID	CloseInputDevice (_In_ PINPUT_DEVICE_INFO DeviceInfo)
static VOID	StartReadInputDevice (_In_ PINPUT_DEVICE_INFO DeviceInfo)
static VOID	ProcessDeviceChanges (VOID)
VOID NTAPI	RawInputThreadMain (VOID)
NTSTATUS NTAPI	InitInputImpl (VOID)
BOOL FASTCALL	IntBlockInput (PTHREADINFO pti, BOOL BlockIt)
BOOL APIENTRY	NtUserBlockInput (BOOL BlockIt)
BOOL FASTCALL	IsRemoveAttachThread (PTHREADINFO pti)
NTSTATUS FASTCALL	UserAttachThreadInput (PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
BOOL APIENTRY	NtUserAttachThreadInput (IN DWORD idAttach, IN DWORD idAttachTo, IN BOOL fAttach)
UINT APIENTRY	NtUserSendInput (UINT nInputs, LPINPUT pInput, INT cbSize)

Variables
PTHREADINFO	ptiRawInput
PKTIMER	MasterTimer = NULL
PATTACHINFO	gpai = NULL
INT	paiCount = 0
HANDLE	ghKeyboardDevice = NULL
PINPUT_DEVICE_INFO	gpInputDeviceInfo = NULL
PERESOURCE	gpDeviceInfoListMutex = NULL
static DWORD	LastInputTick = 0
static PKEVENT	gDeviceListChangedEvent

Macro Definition Documentation

LAST_RIT_EVENT_UPDATE_INTERVAL

#define LAST_RIT_EVENT_UPDATE_INTERVAL   1000UL

Definition at line 17 of file input.c.

Function Documentation

CloseInputDevice()

static VOID CloseInputDevice ( _In_ PINPUT_DEVICE_INFO  DeviceInfo )

static

Definition at line 212 of file input.c.

{
    ASSERT(DeviceInfo->Handle);
    (void)ZwCancelIoFile(DeviceInfo->Handle, &DeviceInfo->Iosb);
    ObCloseHandle(DeviceInfo->Handle, KernelMode);
 
    if (DeviceInfo->Handle == ghKeyboardDevice)
        ghKeyboardDevice = NULL;
}

Referenced by RawInputThreadMain().

CreateInputDevice()

static PINPUT_DEVICE_INFO CreateInputDevice ( _In_ UCHAR  DeviceType, _In_ PUNICODE_STRING  DeviceName  )

static

Definition at line 114 of file input.c.

{
    PINPUT_DEVICE_INFO DeviceInfo;
 
    DeviceInfo = ExAllocatePoolWithTag(PagedPool, sizeof(*DeviceInfo) + DeviceName->Length + sizeof(UNICODE_NULL), USERTAG_PNP);
    if (!DeviceInfo)
    {
        ERR("Failed to allocate memory for INPUT_DEVICE_INFO\n");
        return NULL;
    }
 
    RtlZeroMemory(DeviceInfo, sizeof(*DeviceInfo));
    DeviceInfo->DeviceType = DeviceType;
    DeviceInfo->DeviceName.Buffer = (PWCH)(DeviceInfo + 1);
    DeviceInfo->DeviceName.MaximumLength = DeviceName->Length + sizeof(UNICODE_NULL);
    RtlCopyUnicodeString(&DeviceInfo->DeviceName, DeviceName);
 
    AcquireDeviceInfoListMutex();
    DeviceInfo->pNextDeviceInfo = gpInputDeviceInfo;
    gpInputDeviceInfo = DeviceInfo;
    ReleaseDeviceInfoListMutex();
 
    KeSetEvent(gDeviceListChangedEvent, EVENT_INCREMENT, FALSE);
    return DeviceInfo;
}

Referenced by RawInputThreadMain().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

UserInput

)

DoTheScreenSaver()

VOID FASTCALL DoTheScreenSaver

(

VOID

)

Definition at line 73 of file input.c.

{
    DWORD Test, TO;
 
    if (gspv.iScrSaverTimeout > 0) // Zero means Off.
    {
        Test = EngGetTickCount32();
        Test = Test - LastInputTick;
        TO = 1000 * gspv.iScrSaverTimeout;
        if (Test > TO)
        {
            TRACE("Screensaver Message Start! Tick %lu Timeout %d \n", Test, gspv.iScrSaverTimeout);
 
            if (ppiScrnSaver) // We are or we are not the screensaver, prevent reentry...
            {
                if (!(ppiScrnSaver->W32PF_flags & W32PF_IDLESCREENSAVER))
                {
                    ppiScrnSaver->W32PF_flags |= W32PF_IDLESCREENSAVER;
                    ERR("Screensaver is Idle\n");
                }
            }
            else
            {
                PUSER_MESSAGE_QUEUE ForegroundQueue = IntGetFocusMessageQueue();
                if (ForegroundQueue && ForegroundQueue->spwndActive)
                    UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 1); // lParam 1 == Secure
                else
                    UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0);
            }
        }
    }
}

Referenced by HungAppSysTimerProc().

InitInputImpl()

NTSTATUS NTAPI InitInputImpl

(

VOID

)

Definition at line 537 of file input.c.

{
    MasterTimer = ExAllocatePoolWithTag(NonPagedPool, sizeof(KTIMER), USERTAG_SYSTEM);
    if (!MasterTimer)
    {
        ERR("Failed to allocate memory\n");
        ASSERT(FALSE);
        return STATUS_UNSUCCESSFUL;
    }
    KeInitializeTimer(MasterTimer);
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

IntBlockInput()

BOOL FASTCALL IntBlockInput	(	PTHREADINFO	pti,
		BOOL	BlockIt
	)

Definition at line 552 of file input.c.

{
    PTHREADINFO OldBlock;
    ASSERT(pti);
 
    if(!pti->rpdesk || ((pti->TIF_flags & TIF_INCLEANUP) && BlockIt))
    {
        /*
         * Fail blocking if exiting the thread
         */
 
        return FALSE;
    }
 
    /*
     * FIXME: Check access rights of the window station
     *        e.g. services running in the service window station cannot block input
     */
    if(!ThreadHasInputAccess(pti) ||
       !IntIsActiveDesktop(pti->rpdesk))
    {
        EngSetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
 
    ASSERT(pti->rpdesk);
    OldBlock = pti->rpdesk->BlockInputThread;
    if(OldBlock)
    {
        if(OldBlock != pti)
        {
            EngSetLastError(ERROR_ACCESS_DENIED);
            return FALSE;
        }
        pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
        return OldBlock == NULL;
    }
 
    pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
    return OldBlock == NULL;
}

Referenced by ExitThreadCallback(), and NtUserBlockInput().

IntLastInputTick()

static DWORD FASTCALL IntLastInputTick ( BOOL  bUpdate )

static

Definition at line 48 of file input.c.

{
    if (bUpdate)
    {
        LastInputTick = EngGetTickCount32();
        if (gpsi)
        {
            gpsi->dwLastRITEventTickCount = LastInputTick;
            if (gpsi->dwLastRITEventTickCount - gpsi->dwLastSystemRITEventTickCountUpdate >
                LAST_RIT_EVENT_UPDATE_INTERVAL)
            {
                SharedUserData->LastSystemRITEventTickCount = LastInputTick;
                gpsi->dwLastSystemRITEventTickCountUpdate = LastInputTick;
            }
        }
    }
    return LastInputTick;
}

Referenced by RITReadApc().

IsRemoveAttachThread()

BOOL FASTCALL IsRemoveAttachThread

(

PTHREADINFO

pti

)

Definition at line 614 of file input.c.

{
    NTSTATUS Status;
    PATTACHINFO pai;
    BOOL Ret = TRUE;
    PTHREADINFO ptiFrom = NULL, ptiTo = NULL;
 
    do
    {
       if (!gpai) return TRUE;
 
       pai = gpai; // Bottom of the list.
 
       do
       {
          if (pai->pti2 == pti)
          {
             ptiFrom = pai->pti1;
             ptiTo = pti;
             break;
          }
          if (pai->pti1 == pti)
          {
             ptiFrom = pti;
             ptiTo = pai->pti2;
             break;
          }
          pai = pai->paiNext;
 
       } while (pai);
 
       if (!pai && !ptiFrom && !ptiTo) break;
 
       Status = UserAttachThreadInput(ptiFrom, ptiTo, FALSE);
       if (!NT_SUCCESS(Status)) Ret = FALSE;
 
    } while (Ret);
 
    return Ret;
}

Referenced by ExitThreadCallback().

NtUserAttachThreadInput()

BOOL APIENTRY NtUserAttachThreadInput	(	IN DWORD	idAttach,
		IN DWORD	idAttachTo,
		IN BOOL	fAttach
	)

Definition at line 841 of file input.c.

{
  NTSTATUS Status;
  PTHREADINFO pti, ptiTo;
  BOOL Ret = FALSE;
 
  UserEnterExclusive();
  TRACE("Enter NtUserAttachThreadInput %s\n",(fAttach ? "TRUE" : "FALSE" ));
 
  pti = IntTID2PTI(UlongToHandle(idAttach));
  ptiTo = IntTID2PTI(UlongToHandle(idAttachTo));
 
  if ( !pti || !ptiTo )
  {
     TRACE("AttachThreadInput pti or ptiTo NULL.\n");
     EngSetLastError(ERROR_INVALID_PARAMETER);
     goto Exit;
  }
 
  Status = UserAttachThreadInput( pti, ptiTo, fAttach);
  if (!NT_SUCCESS(Status))
  {
     TRACE("AttachThreadInput Error Status 0x%x. \n",Status);
     EngSetLastError(RtlNtStatusToDosError(Status));
  }
  else Ret = TRUE;
 
Exit:
  TRACE("Leave NtUserAttachThreadInput, ret=%d\n",Ret);
  UserLeave();
  return Ret;
}

NtUserBlockInput()

BOOL APIENTRY NtUserBlockInput

(

BOOL

BlockIt

)

Definition at line 596 of file input.c.

{
    BOOL ret;
 
    TRACE("Enter NtUserBlockInput\n");
    UserEnterExclusive();
 
    ret = IntBlockInput(PsGetCurrentThreadWin32Thread(), BlockIt);
 
    UserLeave();
    TRACE("Leave NtUserBlockInput, ret=%i\n", ret);
 
    return ret;
}

Referenced by BlockInput().

NtUserSendInput()

UINT APIENTRY NtUserSendInput	(	UINT	nInputs,
		LPINPUT	pInput,
		INT	cbSize
	)

Definition at line 884 of file input.c.

{
    PTHREADINFO pti;
    UINT uRet = 0;
 
    TRACE("Enter NtUserSendInput\n");
    UserEnterExclusive();
 
    pti = PsGetCurrentThreadWin32Thread();
    ASSERT(pti);
 
    if (!pti->rpdesk)
    {
        goto cleanup;
    }
 
    if (!nInputs || !pInput || cbSize != sizeof(INPUT))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        goto cleanup;
    }
 
    /*
     * FIXME: Check access rights of the window station
     *        e.g. services running in the service window station cannot block input
     */
    if (!ThreadHasInputAccess(pti) ||
        !IntIsActiveDesktop(pti->rpdesk))
    {
        EngSetLastError(ERROR_ACCESS_DENIED);
        goto cleanup;
    }
 
    while (nInputs--)
    {
        INPUT SafeInput;
        NTSTATUS Status;
 
        Status = MmCopyFromCaller(&SafeInput, pInput++, sizeof(INPUT));
        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            goto cleanup;
        }
 
        switch (SafeInput.type)
        {
            case INPUT_MOUSE:
                if (UserSendMouseInput(&SafeInput.mi, TRUE))
                    uRet++;
                break;
            case INPUT_KEYBOARD:
                if (UserSendKeyboardInput(&SafeInput.ki, TRUE))
                    uRet++;
                break;
            case INPUT_HARDWARE:
                FIXME("INPUT_HARDWARE not supported!\n");
                break;
            default:
                ERR("SendInput(): Invalid input type: 0x%x\n", SafeInput.type);
                break;
        }
    }
 
cleanup:
    TRACE("Leave NtUserSendInput, ret=%u\n", uRet);
    UserLeave();
    return uRet;
}

Referenced by keybd_event(), mouse_event(), and SendInput().

OpenInputDevice()

static NTSTATUS NTAPI OpenInputDevice ( _In_ PINPUT_DEVICE_INFO  DeviceInfo )

static

Definition at line 149 of file input.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    IO_STATUS_BLOCK Iosb;
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &DeviceInfo->DeviceName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    Status = ZwOpenFile(&DeviceInfo->Handle,
                        FILE_ALL_ACCESS,
                        &ObjectAttributes,
                        &Iosb,
                        0,
                        0);
    if (!NT_SUCCESS(Status))
    {
        ERR("ZwOpenFile('%wZ') failed with status 0x%08x\n", &DeviceInfo->DeviceName, Status);
        return Status;
    }
 
    if (DeviceInfo->DeviceType == RIM_TYPEKEYBOARD)
    {
        Status = ZwDeviceIoControlFile(DeviceInfo->Handle,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &DeviceInfo->Iosb,
                                       IOCTL_KEYBOARD_QUERY_ATTRIBUTES,
                                       NULL, 0,
                                       &DeviceInfo->Keyboard.Attributes,
                                       sizeof(DeviceInfo->Keyboard.Attributes));
        if (!NT_SUCCESS(Status))
        {
            ERR("ZwDeviceIoControlFile('%wZ', IOCTL_KEYBOARD_QUERY_ATTRIBUTES) failed with status 0x%08x\n", &DeviceInfo->DeviceName, Status);
        }
    }
    else if (DeviceInfo->DeviceType == RIM_TYPEMOUSE)
    {
        Status = ZwDeviceIoControlFile(DeviceInfo->Handle,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &DeviceInfo->Iosb,
                                       IOCTL_MOUSE_QUERY_ATTRIBUTES,
                                       NULL, 0,
                                       &DeviceInfo->Mouse.Attributes,
                                       sizeof(DeviceInfo->Mouse.Attributes));
        if (!NT_SUCCESS(Status))
        {
            ERR("ZwDeviceIoControlFile('%wZ', IOCTL_MOUSE_QUERY_ATTRIBUTES) failed with status 0x%08x\n", &DeviceInfo->DeviceName, Status);
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by ProcessDeviceChanges().

ProcessDeviceChanges()

static VOID ProcessDeviceChanges ( VOID  )

static

Definition at line 303 of file input.c.

{
    PINPUT_DEVICE_INFO DeviceInfo;
    NTSTATUS Status;
    DWORD NumberOfMice = 0;
    DWORD MaxNumberOfButtons = 0;
    BOOL HasMouseWheel = FALSE;
#if (_WIN32_WINNT >= 0x0600)
    BOOL HasHorizontalMouseWheel = FALSE;
#endif
    DWORD MaxFunctionKeys = 0;
 
    AcquireDeviceInfoListMutex();
    for (DeviceInfo = gpInputDeviceInfo; DeviceInfo; DeviceInfo = DeviceInfo->pNextDeviceInfo)
    {
        if (!DeviceInfo->Handle)
        {
            Status = OpenInputDevice(DeviceInfo);
            if (NT_SUCCESS(Status))
            {
                if (DeviceInfo->DeviceType == RIM_TYPEKEYBOARD)
                {
                    TRACE("Keyboard connected!\n");
                    if (!ghKeyboardDevice)
                    {
                        // Get and load keyboard attributes.
                        UserInitKeyboard(DeviceInfo->Handle);
                        UserEnterExclusive();
                        // Register the Window hotkey.
                        UserRegisterHotKey(PWND_BOTTOM, IDHK_WINKEY, MOD_WIN, 0);
                        // Register the Window Snap hotkey.
                        UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_LEFT, MOD_WIN, VK_LEFT);
                        UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_RIGHT, MOD_WIN, VK_RIGHT);
                        UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_UP, MOD_WIN, VK_UP);
                        UserRegisterHotKey(PWND_BOTTOM, IDHK_SNAP_DOWN, MOD_WIN, VK_DOWN);
                        // Register the debug hotkeys.
                        SetDebugHotKeys();
                        UserLeave();
                    }
                }
                else if (DeviceInfo->DeviceType == RIM_TYPEMOUSE)
                {
                    TRACE("Mouse connected!\n");
                }
                StartReadInputDevice(DeviceInfo);
            }
        }
 
        if (DeviceInfo->DeviceType == RIM_TYPEKEYBOARD)
        {
            if (DeviceInfo->Keyboard.Attributes.KeyboardIdentifier.Type == 4 /* Enhanced 101- or 102-key keyboard */ ||
                DeviceInfo->Keyboard.Attributes.KeyboardIdentifier.Type == 7 /* Japanese keyboard */ ||
                DeviceInfo->Keyboard.Attributes.KeyboardIdentifier.Type == 8 /* Korean keyboard */)
            {
                DWORD FunctionKeys = DeviceInfo->Keyboard.Attributes.NumberOfFunctionKeys;
                /* Keep current keyboard description */
                gKeyboardInfo = DeviceInfo->Keyboard.Attributes;
                if (FunctionKeys > MaxFunctionKeys)
                    MaxFunctionKeys = FunctionKeys;
            }
        }
        else if (DeviceInfo->DeviceType == RIM_TYPEMOUSE)
        {
            DWORD MouseIdentifier = DeviceInfo->Mouse.Attributes.MouseIdentifier & ~HORIZONTAL_WHEEL_PRESENT;
            DWORD NumberOfButtons = DeviceInfo->Mouse.Attributes.NumberOfButtons;
 
            NumberOfMice++;
            if (NumberOfButtons > MaxNumberOfButtons)
                MaxNumberOfButtons = NumberOfButtons;
            HasMouseWheel |= MouseIdentifier == WHEELMOUSE_I8042_HARDWARE
                          || MouseIdentifier == WHEELMOUSE_SERIAL_HARDWARE
                          || MouseIdentifier == WHEELMOUSE_HID_HARDWARE;
#if (_WIN32_WINNT >= 0x0600)
            HasHorizontalMouseWheel |= DeviceInfo->Mouse.Attributes.MouseIdentifier & HORIZONTAL_WHEEL_PRESENT;
#endif
        }
    }
    ReleaseDeviceInfoListMutex();
 
    /* Update metrics */
    gpsi->aiSysMet[SM_MOUSEPRESENT] = NumberOfMice > 0 ? 1 : 0;
    gpsi->aiSysMet[SM_CMOUSEBUTTONS] = MaxNumberOfButtons;
    gpsi->aiSysMet[SM_MOUSEWHEELPRESENT] = HasMouseWheel ? 1 : 0;
#if (_WIN32_WINNT >= 0x0600)
    gpsi->aiSysMet[SM_MOUSEHORIZONTALWHEELPRESENT] = HasHorizontalMouseWheel ? 1 : 0;
#endif
    /* FIXME: show/hide cursor depending of mouse presence */
    TRACE("Mouse present %u, buttons %u, wheel %u\n",
          gpsi->aiSysMet[SM_MOUSEPRESENT],
          gpsi->aiSysMet[SM_CMOUSEBUTTONS],
          gpsi->aiSysMet[SM_MOUSEWHEELPRESENT]);
 
    gKeyboardInfo.NumberOfFunctionKeys = MaxFunctionKeys;
    TRACE("Keyboard type %u, subtype %u and number of func keys %u\n",
          gKeyboardInfo.KeyboardIdentifier.Type,
          gKeyboardInfo.KeyboardIdentifier.Subtype,
          gKeyboardInfo.NumberOfFunctionKeys);
}

Referenced by RawInputThreadMain().

RawInputThreadMain()

VOID NTAPI RawInputThreadMain

(

VOID

)

Definition at line 409 of file input.c.

{
    PINPUT_DEVICE_INFO DeviceInfo;
    NTSTATUS Status;
    //LARGE_INTEGER WaitTimeout;
    PVOID WaitObjects[3], pSignaledObject = NULL;
    KWAIT_BLOCK WaitBlockArray[RTL_NUMBER_OF(WaitObjects)];
    PVOID ShutdownEvent;
    HWINSTA hWinSta;
    PINPUT_DEVICE_INFO Mouse;
    PINPUT_DEVICE_INFO Keyboard;
    UNICODE_STRING LegacyMouseName = RTL_CONSTANT_STRING(L"\\Device\\PointerClass0");
    UNICODE_STRING LegacyKeyboardName = RTL_CONSTANT_STRING(L"\\Device\\KeyboardClass0");
 
    gDeviceListChangedEvent = ExAllocatePoolWithTag(NonPagedPool, sizeof(*gDeviceListChangedEvent), USERTAG_PNP);
    ASSERT(gDeviceListChangedEvent);
    KeInitializeEvent(gDeviceListChangedEvent, SynchronizationEvent, FALSE);
 
    //WaitTimeout.QuadPart = (LONGLONG)(-10000000);
 
    ptiRawInput = GetW32ThreadInfo();
    ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
    ptiRawInput->pClientInfo->dwTIFlags = ptiRawInput->TIF_flags;
 
    TRACE("Raw Input Thread %p\n", ptiRawInput);
 
    KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
                        LOW_REALTIME_PRIORITY + 3);
 
    Status = ObOpenObjectByPointer(InputWindowStation,
                                   0,
                                   NULL,
                                   MAXIMUM_ALLOWED,
                                   ExWindowStationObjectType,
                                   UserMode,
                                   (PHANDLE)&hWinSta);
    if (NT_SUCCESS(Status))
    {
        UserSetProcessWindowStation(hWinSta);
    }
    else
    {
        ASSERT(FALSE);
        /* Failed to open the interactive winsta! What now? */
    }
 
    gpDeviceInfoListMutex = ExAllocatePoolWithTag(NonPagedPool, sizeof(*gpDeviceInfoListMutex), USERTAG_SYSTEM);
    ASSERT(gpDeviceInfoListMutex);
    Status = ExInitializeResourceLite(gpDeviceInfoListMutex);
    ASSERT(NT_SUCCESS(Status));
 
    Mouse = CreateInputDevice(RIM_TYPEMOUSE, &LegacyMouseName);
    ASSERT(Mouse);
    Keyboard = CreateInputDevice(RIM_TYPEKEYBOARD, &LegacyKeyboardName);
    ASSERT(Keyboard);
 
    UserEnterExclusive();
    StartTheTimers();
    UserLeave();
 
    NT_ASSERT(ghKeyboardDevice == NULL);
    ghKeyboardDevice = Keyboard->Handle;
 
    PoRequestShutdownEvent(&ShutdownEvent);
    for (;;)
    {
        /* Reset WaitHandles array */
        WaitObjects[0] = ShutdownEvent;
        WaitObjects[1] = MasterTimer;
        WaitObjects[2] = gDeviceListChangedEvent;
 
        Status = KeWaitForMultipleObjects(RTL_NUMBER_OF(WaitObjects),
                                          WaitObjects,
                                          WaitAny,
                                          UserRequest,
                                          KernelMode,
                                          TRUE,
                                          NULL,//&WaitTimeout,
                                          WaitBlockArray);
 
        if ((Status >= STATUS_WAIT_0) &&
            (Status < (STATUS_WAIT_0 + RTL_NUMBER_OF(WaitObjects))))
        {
            /* Some device has finished reading */
            pSignaledObject = WaitObjects[Status - STATUS_WAIT_0];
 
            if (pSignaledObject == gDeviceListChangedEvent)
            {
                ProcessDeviceChanges();
            }
            else if (pSignaledObject == MasterTimer)
            {
                ProcessTimers();
            }
            else if (pSignaledObject == ShutdownEvent)
            {
                break;
            }
            else ASSERT(FALSE);
        }
    }
 
    AcquireDeviceInfoListMutex();
    while (gpInputDeviceInfo)
    {
        DeviceInfo = gpInputDeviceInfo;
        gpInputDeviceInfo = DeviceInfo->pNextDeviceInfo;
        CloseInputDevice(DeviceInfo);
        ExFreePoolWithTag(DeviceInfo, USERTAG_PNP);
    }
    gpInputDeviceInfo = NULL;
    ReleaseDeviceInfoListMutex();
 
    ExDeleteResourceLite(gpDeviceInfoListMutex);
    ExFreePoolWithTag(gpDeviceInfoListMutex, USERTAG_SYSTEM);
    ExFreePoolWithTag(gDeviceListChangedEvent, USERTAG_PNP);
 
    ERR("Raw Input Thread Exit!\n");
}

Referenced by UserSystemThreadProc().

RITReadApc()

static VOID NTAPI RITReadApc ( _In_ PVOID  ApcContext, _In_ PIO_STATUS_BLOCK  IoStatusBlock, _In_ ULONG  Reserved  )

static

Definition at line 261 of file input.c.

{
    PINPUT_DEVICE_INFO DeviceInfo = ApcContext;
 
    if (DeviceInfo->Handle && NT_SUCCESS(IoStatusBlock->Status))
    {
        if (DeviceInfo->DeviceType == RIM_TYPEKEYBOARD)
        {
            TRACE("KeyboardEvent: %s %04x\n",
                  (DeviceInfo->Keyboard.Data.Flags & KEY_BREAK) ? "up" : "down",
                  DeviceInfo->Keyboard.Data.MakeCode);
 
            /* Set LastInputTick */
            IntLastInputTick(TRUE);
 
            /* Process data */
            UserEnterExclusive();
            UserProcessKeyboardInput(DeviceInfo, &DeviceInfo->Keyboard.Data);
            UserLeave();
        }
        else if (DeviceInfo->DeviceType == RIM_TYPEMOUSE)
        {
            TRACE("MouseEvent\n");
 
            /* Set LastInputTick */
            IntLastInputTick(TRUE);
 
            /* Process data */
            UserEnterExclusive();
            UserProcessMouseInput(DeviceInfo, &DeviceInfo->Mouse.Data);
            UserLeave();
        }
    }
 
    StartReadInputDevice(DeviceInfo);
}

Referenced by StartReadInputDevice().

StartReadInputDevice()

static VOID StartReadInputDevice ( _In_ PINPUT_DEVICE_INFO  DeviceInfo )

static

Definition at line 225 of file input.c.

{
    PVOID Buffer;
    SIZE_T BufferSize;
    LARGE_INTEGER ByteOffset;
 
    ByteOffset.QuadPart = (LONGLONG)0;
 
    if (DeviceInfo->DeviceType == RIM_TYPEKEYBOARD)
    {
        Buffer = &DeviceInfo->Keyboard.Data,
        BufferSize = sizeof(DeviceInfo->Keyboard.Data);
    }
    else if (DeviceInfo->DeviceType == RIM_TYPEMOUSE)
    {
        Buffer = &DeviceInfo->Mouse.Data,
        BufferSize = sizeof(DeviceInfo->Mouse.Data);
    }
    else
        return;
 
    DeviceInfo->Status = ZwReadFile(
        DeviceInfo->Handle,
        NULL,
        RITReadApc,
        DeviceInfo,
        &DeviceInfo->Iosb,
        Buffer,
        BufferSize,
        &ByteOffset,
        NULL);
}

Referenced by ProcessDeviceChanges(), and RITReadApc().

UserAttachThreadInput()

NTSTATUS FASTCALL UserAttachThreadInput	(	PTHREADINFO	ptiFrom,
		PTHREADINFO	ptiTo,
		BOOL	fAttach
	)

Definition at line 656 of file input.c.

{
    MSG msg;
    PATTACHINFO pai;
    PCURICON_OBJECT CurIcon;
 
    /* Can not be the same thread. */
    if (ptiFrom == ptiTo) return STATUS_INVALID_PARAMETER;
 
    /* Do not attach to system threads or between different desktops. */
    if (ptiFrom->TIF_flags & TIF_DONTATTACHQUEUE ||
        ptiTo->TIF_flags & TIF_DONTATTACHQUEUE ||
        ptiFrom->rpdesk != ptiTo->rpdesk)
        return STATUS_ACCESS_DENIED;
 
    /* MSDN Note:
       Keyboard and mouse events received by both threads are processed by the thread specified by the idAttachTo.
     */
 
    /* If Attach set, allocate and link. */
    if (fAttach)
    {
        pai = ExAllocatePoolWithTag(PagedPool, sizeof(ATTACHINFO), USERTAG_ATTACHINFO);
        if (!pai) return STATUS_NO_MEMORY;
 
        pai->paiNext = gpai;
        pai->pti1 = ptiFrom;
        pai->pti2 = ptiTo;
        gpai = pai;
        paiCount++;
        ERR("Attach Allocated! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 
        if (ptiTo->MessageQueue != ptiFrom->MessageQueue)
        {
 
           ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 
           if (ptiFrom->MessageQueue == gpqForeground)
           {
              ERR("ptiFrom is Foreground\n");
              ptiTo->MessageQueue->spwndActive  = ptiFrom->MessageQueue->spwndActive;
              ptiTo->MessageQueue->spwndFocus   = ptiFrom->MessageQueue->spwndFocus;
              ptiTo->MessageQueue->spwndCapture = ptiFrom->MessageQueue->spwndCapture;
              ptiTo->MessageQueue->QF_flags    ^= ((ptiTo->MessageQueue->QF_flags ^ ptiFrom->MessageQueue->QF_flags) & QF_CAPTURELOCKED);
              RtlCopyMemory(&ptiTo->MessageQueue->CaretInfo,
                            &ptiFrom->MessageQueue->CaretInfo,
                            sizeof(ptiTo->MessageQueue->CaretInfo));
              IntSetFocusMessageQueue(NULL);
              IntSetFocusMessageQueue(ptiTo->MessageQueue);
              gptiForeground = ptiTo;
           }
           else
           {
              ERR("ptiFrom NOT Foreground\n");
              if ( ptiTo->MessageQueue->spwndActive == 0 )
                  ptiTo->MessageQueue->spwndActive = ptiFrom->MessageQueue->spwndActive;
              if ( ptiTo->MessageQueue->spwndFocus == 0 )
                  ptiTo->MessageQueue->spwndFocus  = ptiFrom->MessageQueue->spwndFocus;
           }
 
           CurIcon = ptiFrom->MessageQueue->CursorObject;
 
           MsqDestroyMessageQueue(ptiFrom);
 
           if (CurIcon)
           {
              // Could be global. Keep it above the water line!
              UserReferenceObject(CurIcon);
           }
 
           if (CurIcon && UserObjectInDestroy(UserHMGetHandle(CurIcon)))
           {
              UserDereferenceObject(CurIcon);
              CurIcon = NULL;
           }
 
           ptiFrom->MessageQueue = ptiTo->MessageQueue;
 
           // Pass cursor From if To is null. Pass test_SetCursor parent_id == current pti ID.
           if (CurIcon && ptiTo->MessageQueue->CursorObject == NULL)
           {
              ERR("ptiTo receiving ptiFrom Cursor\n");
              ptiTo->MessageQueue->CursorObject = CurIcon;
           }
 
           ptiFrom->MessageQueue->cThreads++;
           ERR("ptiTo S Share count %u\n", ptiFrom->MessageQueue->cThreads);
 
           IntReferenceMessageQueue(ptiTo->MessageQueue);
        }
        else
        {
           ERR("Attach Threads are already associated!\n");
        }
    }
    else /* If clear, unlink and free it. */
    {
        BOOL Hit = FALSE;
        PATTACHINFO *ppai;
 
        if (!gpai) return STATUS_INVALID_PARAMETER;
 
        /* Search list and free if found or return false. */
        ppai = &gpai;
        while (*ppai != NULL)
        {
           if ( (*ppai)->pti2 == ptiTo && (*ppai)->pti1 == ptiFrom )
           {
              pai = *ppai;
              /* Remove it from the list */
              *ppai = (*ppai)->paiNext;
              ExFreePoolWithTag(pai, USERTAG_ATTACHINFO);
              paiCount--;
              Hit = TRUE;
              break;
           }
           ppai = &((*ppai)->paiNext);
        }
 
        if (!Hit) return STATUS_INVALID_PARAMETER;
 
        ERR("Attach Free! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 
        if (ptiTo->MessageQueue == ptiFrom->MessageQueue)
        {
           PWND spwndActive = ptiTo->MessageQueue->spwndActive;
           PWND spwndFocus  = ptiTo->MessageQueue->spwndFocus;
 
           if (gptiForeground == ptiFrom)
           {
              ERR("ptiTo is now pti FG.\n");
              // MessageQueue foreground is set so switch threads.
              gptiForeground = ptiTo;
           }
           ptiTo->MessageQueue->cThreads--;
           ERR("ptiTo E Share count %u\n", ptiTo->MessageQueue->cThreads);
           ASSERT(ptiTo->MessageQueue->cThreads >= 1);
 
           IntDereferenceMessageQueue(ptiTo->MessageQueue);
 
           ptiFrom->MessageQueue = MsqCreateMessageQueue(ptiFrom);
 
           if (spwndActive)
           {
              if (spwndActive->head.pti == ptiFrom)
              {
                 ptiFrom->MessageQueue->spwndActive = spwndActive;
                 ptiTo->MessageQueue->spwndActive = 0;
              }
           }
           if (spwndFocus)
           {
              if (spwndFocus->head.pti == ptiFrom)
              {
                 ptiFrom->MessageQueue->spwndFocus = spwndFocus;
                 ptiTo->MessageQueue->spwndFocus = 0;
              }
           }
           ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
        }
        else
        {
           ERR("Detaching Threads are not associated!\n");
        }
    }
    /* Note that key state, which can be ascertained by calls to the GetKeyState
       or GetKeyboardState function, is reset after a call to AttachThreadInput.
       ATM which one?
     */
    RtlCopyMemory(ptiTo->MessageQueue->afKeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
 
    ptiTo->MessageQueue->msgDblClk.message = 0;
 
    /* Generate mouse move message */
    msg.message = WM_MOUSEMOVE;
    msg.wParam = UserGetMouseButtonsState();
    msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
    msg.pt = gpsi->ptCursor;
    co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
 
    return STATUS_SUCCESS;
}

Referenced by co_IntSetParent(), co_UserCreateWindowEx(), co_UserDestroyWindow(), IntCreateWindow(), IntProcessOwnerSwap(), IsRemoveAttachThread(), and NtUserAttachThreadInput().

Variable Documentation

gDeviceListChangedEvent

PKEVENT gDeviceListChangedEvent

static

Definition at line 38 of file input.c.

Referenced by CreateInputDevice(), and RawInputThreadMain().

ghKeyboardDevice

HANDLE ghKeyboardDevice = NULL

Definition at line 33 of file input.c.

Referenced by CloseInputDevice(), ProcessDeviceChanges(), ProcessKeyEvent(), and RawInputThreadMain().

gpai

PATTACHINFO gpai = NULL

Definition at line 31 of file input.c.

Referenced by IsRemoveAttachThread(), and UserAttachThreadInput().

gpDeviceInfoListMutex

PERESOURCE gpDeviceInfoListMutex = NULL

Definition at line 35 of file input.c.

Referenced by AcquireDeviceInfoListMutex(), RawInputThreadMain(), and ReleaseDeviceInfoListMutex().

gpInputDeviceInfo

PINPUT_DEVICE_INFO gpInputDeviceInfo = NULL

Definition at line 34 of file input.c.

Referenced by CreateInputDevice(), NtUserGetRawInputDeviceInfo(), NtUserGetRawInputDeviceList(), ProcessDeviceChanges(), and RawInputThreadMain().

LastInputTick

DWORD LastInputTick = 0

static

Definition at line 37 of file input.c.

Referenced by DoTheScreenSaver(), and IntLastInputTick().

MasterTimer

PKTIMER MasterTimer = NULL

Definition at line 30 of file input.c.

Referenced by InitInputImpl(), IntSetTimer(), ProcessTimers(), and RawInputThreadMain().

paiCount

INT paiCount = 0

Definition at line 32 of file input.c.

Referenced by UserAttachThreadInput().

ptiRawInput

PTHREADINFO ptiRawInput

Definition at line 29 of file input.c.

Referenced by IntSetTimer(), and RawInputThreadMain().