reactos/win32ss/user/ntuser/input.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS Win32k subsystem
   4  * PURPOSE:          General input functions
   5  * FILE:             win32ss/user/ntuser/input.c
   6  * PROGRAMERS:       Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  *                   Rafal Harabien (rafalh@reactos.org)
   8  */
   9
  10 #include <win32k.h>
  11 DBG_DEFAULT_CHANNEL(UserInput);
  12
  13 /* GLOBALS *******************************************************************/
  14
  15 PTHREADINFO ptiRawInput;
  16 PKTIMER MasterTimer = NULL;
  17 PATTACHINFO gpai = NULL;
  18 INT paiCount = 0;
  19 HANDLE ghKeyboardDevice = NULL;
  20
  21 static DWORD LastInputTick = 0;
  22 static HANDLE ghMouseDevice;
  23
  24 /* FUNCTIONS *****************************************************************/
  25
  26 /*
  27  * IntLastInputTick
  28  *
  29  * Updates or gets last input tick count
  30  */
  31 static DWORD FASTCALL
  32 IntLastInputTick(BOOL bUpdate)
  33 {
  34     if (bUpdate)
  35     {
  36         LARGE_INTEGER TickCount;
  37         KeQueryTickCount(&TickCount);
  38         LastInputTick = MsqCalculateMessageTime(&TickCount);
  39         if (gpsi) gpsi->dwLastRITEventTickCount = LastInputTick;
  40     }
  41     return LastInputTick;
  42 }
  43
  44 /*
  45  * DoTheScreenSaver
  46  *
  47  * Check if scrensaver should be started and sends message to SAS window
  48  */
  49 VOID FASTCALL
  50 DoTheScreenSaver(VOID)
  51 {
  52     LARGE_INTEGER TickCount;
  53     DWORD Test, TO;
  54
  55     if (gspv.iScrSaverTimeout > 0) // Zero means Off.
  56     {
  57         KeQueryTickCount(&TickCount);
  58         Test = MsqCalculateMessageTime(&TickCount);
  59         Test = Test - LastInputTick;
  60         TO = 1000 * gspv.iScrSaverTimeout;
  61         if (Test > TO)
  62         {
  63             TRACE("Screensaver Message Start! Tick %lu Timeout %d \n", Test, gspv.iScrSaverTimeout);
  64
  65             if (ppiScrnSaver) // We are or we are not the screensaver, prevent reentry...
  66             {
  67                 if (!(ppiScrnSaver->W32PF_flags & W32PF_IDLESCREENSAVER))
  68                 {
  69                     ppiScrnSaver->W32PF_flags |= W32PF_IDLESCREENSAVER;
  70                     ERR("Screensaver is Idle\n");
  71                 }
  72             }
  73             else
  74             {
  75                 PUSER_MESSAGE_QUEUE ForegroundQueue = IntGetFocusMessageQueue();
  76                 if (ForegroundQueue && ForegroundQueue->spwndActive)
  77                     UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 1); // lParam 1 == Secure
  78                 else
  79                     UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_START_SCREENSAVE, 0);
  80             }
  81         }
  82     }
  83 }
  84
  85 /*
  86  * OpenInputDevice
  87  *
  88  * Opens input device for asynchronous access
  89  */
  90 static
  91 NTSTATUS NTAPI
  92 OpenInputDevice(PHANDLE pHandle, PFILE_OBJECT *ppObject, CONST WCHAR *pszDeviceName)
  93 {
  94     UNICODE_STRING DeviceName;
  95     OBJECT_ATTRIBUTES ObjectAttributes;
  96     NTSTATUS Status;
  97     IO_STATUS_BLOCK Iosb;
  98
  99     RtlInitUnicodeString(&DeviceName, pszDeviceName);
 100
 101     InitializeObjectAttributes(&ObjectAttributes,
 102                                &DeviceName,
 103                                OBJ_KERNEL_HANDLE,
 104                                NULL,
 105                                NULL);
 106
 107     Status = ZwOpenFile(pHandle,
 108                         FILE_ALL_ACCESS,
 109                         &ObjectAttributes,
 110                         &Iosb,
 111                         0,
 112                         0);
 113     if (NT_SUCCESS(Status) && ppObject)
 114     {
 115         Status = ObReferenceObjectByHandle(*pHandle, SYNCHRONIZE, NULL, KernelMode, (PVOID*)ppObject, NULL);
 116         ASSERT(NT_SUCCESS(Status));
 117     }
 118
 119     return Status;
 120 }
 121
 122 /*
 123  * RawInputThreadMain
 124  *
 125  * Reads data from input devices and supports win32 timers
 126  */
 127 VOID NTAPI
 128 RawInputThreadMain(VOID)
 129 {
 130     NTSTATUS MouStatus = STATUS_UNSUCCESSFUL, KbdStatus = STATUS_UNSUCCESSFUL, Status;
 131     IO_STATUS_BLOCK MouIosb, KbdIosb;
 132     PFILE_OBJECT pKbdDevice = NULL, pMouDevice = NULL;
 133     LARGE_INTEGER ByteOffset;
 134     //LARGE_INTEGER WaitTimeout;
 135     PVOID WaitObjects[4], pSignaledObject = NULL;
 136     KWAIT_BLOCK WaitBlockArray[RTL_NUMBER_OF(WaitObjects)];
 137     ULONG cWaitObjects = 0, cMaxWaitObjects = 2;
 138     MOUSE_INPUT_DATA MouseInput;
 139     KEYBOARD_INPUT_DATA KeyInput;
 140     PVOID ShutdownEvent;
 141
 142     ByteOffset.QuadPart = (LONGLONG)0;
 143     //WaitTimeout.QuadPart = (LONGLONG)(-10000000);
 144
 145     ptiRawInput = GetW32ThreadInfo();
 146     ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
 147     ptiRawInput->pClientInfo->dwTIFlags = ptiRawInput->TIF_flags;
 148
 149     TRACE("Raw Input Thread %p\n", ptiRawInput);
 150
 151     KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
 152                         LOW_REALTIME_PRIORITY + 3);
 153
 154     UserEnterExclusive();
 155     StartTheTimers();
 156     UserLeave();
 157
 158     NT_ASSERT(ghMouseDevice == NULL);
 159     NT_ASSERT(ghKeyboardDevice == NULL);
 160
 161     PoRequestShutdownEvent(&ShutdownEvent);
 162     for (;;)
 163     {
 164         if (!ghMouseDevice)
 165         {
 166             /* Check if mouse device already exists */
 167             Status = OpenInputDevice(&ghMouseDevice, &pMouDevice, L"\\Device\\PointerClass0" );
 168             if (NT_SUCCESS(Status))
 169             {
 170                 ++cMaxWaitObjects;
 171                 TRACE("Mouse connected!\n");
 172             }
 173         }
 174         if (!ghKeyboardDevice)
 175         {
 176             /* Check if keyboard device already exists */
 177             Status = OpenInputDevice(&ghKeyboardDevice, &pKbdDevice, L"\\Device\\KeyboardClass0");
 178             if (NT_SUCCESS(Status))
 179             {
 180                 ++cMaxWaitObjects;
 181                 TRACE("Keyboard connected!\n");
 182                 // Get and load keyboard attributes.
 183                 UserInitKeyboard(ghKeyboardDevice);
 184                 UserEnterExclusive();
 185                 // Register the Window hotkey.
 186                 UserRegisterHotKey(PWND_BOTTOM, IDHK_WINKEY, MOD_WIN, 0);
 187                 // Register the debug hotkeys.
 188                 StartDebugHotKeys();
 189                 UserLeave();
 190             }
 191         }
 192
 193         /* Reset WaitHandles array */
 194         cWaitObjects = 0;
 195         WaitObjects[cWaitObjects++] = ShutdownEvent;
 196         WaitObjects[cWaitObjects++] = MasterTimer;
 197
 198         if (ghMouseDevice)
 199         {
 200             /* Try to read from mouse if previous reading is not pending */
 201             if (MouStatus != STATUS_PENDING)
 202             {
 203                 MouStatus = ZwReadFile(ghMouseDevice,
 204                                        NULL,
 205                                        NULL,
 206                                        NULL,
 207                                        &MouIosb,
 208                                        &MouseInput,
 209                                        sizeof(MOUSE_INPUT_DATA),
 210                                        &ByteOffset,
 211                                        NULL);
 212             }
 213
 214             if (MouStatus == STATUS_PENDING)
 215                 WaitObjects[cWaitObjects++] = &pMouDevice->Event;
 216         }
 217
 218         if (ghKeyboardDevice)
 219         {
 220             /* Try to read from keyboard if previous reading is not pending */
 221             if (KbdStatus != STATUS_PENDING)
 222             {
 223                 KbdStatus = ZwReadFile(ghKeyboardDevice,
 224                                        NULL,
 225                                        NULL,
 226                                        NULL,
 227                                        &KbdIosb,
 228                                        &KeyInput,
 229                                        sizeof(KEYBOARD_INPUT_DATA),
 230                                        &ByteOffset,
 231                                        NULL);
 232
 233             }
 234             if (KbdStatus == STATUS_PENDING)
 235                 WaitObjects[cWaitObjects++] = &pKbdDevice->Event;
 236         }
 237
 238         /* If all objects are pending, wait for them */
 239         if (cWaitObjects == cMaxWaitObjects)
 240         {
 241             Status = KeWaitForMultipleObjects(cWaitObjects,
 242                                               WaitObjects,
 243                                               WaitAny,
 244                                               UserRequest,
 245                                               KernelMode,
 246                                               TRUE,
 247                                               NULL,//&WaitTimeout,
 248                                               WaitBlockArray);
 249
 250             if ((Status >= STATUS_WAIT_0) &&
 251                 (Status < (STATUS_WAIT_0 + (LONG)cWaitObjects)))
 252             {
 253                 /* Some device has finished reading */
 254                 pSignaledObject = WaitObjects[Status - STATUS_WAIT_0];
 255
 256                 /* Check if it is mouse or keyboard and update status */
 257                 if ((MouStatus == STATUS_PENDING) &&
 258                     (pSignaledObject == &pMouDevice->Event))
 259                 {
 260                     MouStatus = MouIosb.Status;
 261                 }
 262                 else if ((KbdStatus == STATUS_PENDING) &&
 263                          (pSignaledObject == &pKbdDevice->Event))
 264                 {
 265                     KbdStatus = KbdIosb.Status;
 266                 }
 267                 else if (pSignaledObject == MasterTimer)
 268                 {
 269                     ProcessTimers();
 270                 }
 271                 else if (pSignaledObject == ShutdownEvent)
 272                 {
 273                     break;
 274                 }
 275                 else ASSERT(FALSE);
 276             }
 277         }
 278
 279         /* Have we successed reading from mouse? */
 280         if (NT_SUCCESS(MouStatus) && MouStatus != STATUS_PENDING)
 281         {
 282             TRACE("MouseEvent\n");
 283
 284             /* Set LastInputTick */
 285             IntLastInputTick(TRUE);
 286
 287             /* Process data */
 288             UserEnterExclusive();
 289             UserProcessMouseInput(&MouseInput);
 290             UserLeave();
 291         }
 292         else if (MouStatus != STATUS_PENDING)
 293             ERR("Failed to read from mouse: %x.\n", MouStatus);
 294
 295         /* Have we successed reading from keyboard? */
 296         if (NT_SUCCESS(KbdStatus) && KbdStatus != STATUS_PENDING)
 297         {
 298             TRACE("KeyboardEvent: %s %04x\n",
 299                   (KeyInput.Flags & KEY_BREAK) ? "up" : "down",
 300                   KeyInput.MakeCode);
 301
 302             /* Set LastInputTick */
 303             IntLastInputTick(TRUE);
 304
 305             /* Process data */
 306             UserEnterExclusive();
 307             UserProcessKeyboardInput(&KeyInput);
 308             UserLeave();
 309         }
 310         else if (KbdStatus != STATUS_PENDING)
 311             ERR("Failed to read from keyboard: %x.\n", KbdStatus);
 312     }
 313
 314     if (ghMouseDevice)
 315     {
 316         (void)ZwCancelIoFile(ghMouseDevice, &MouIosb);
 317         ObCloseHandle(ghMouseDevice, KernelMode);
 318         ObDereferenceObject(pMouDevice);
 319         ghMouseDevice = NULL;
 320     }
 321
 322     if (ghKeyboardDevice)
 323     {
 324         (void)ZwCancelIoFile(ghKeyboardDevice, &KbdIosb);
 325         ObCloseHandle(ghKeyboardDevice, KernelMode);
 326         ObDereferenceObject(pKbdDevice);
 327         ghKeyboardDevice = NULL;
 328     }
 329
 330     ERR("Raw Input Thread Exit!\n");
 331 }
 332
 333 /*
 334  * CreateSystemThreads
 335  *
 336  * Called form dedicated thread in CSRSS. RIT is started in context of this
 337  * thread because it needs valid Win32 process with TEB initialized.
 338  */
 339 DWORD NTAPI
 340 CreateSystemThreads(UINT Type)
 341 {
 342     UserLeave();
 343
 344     switch (Type)
 345     {
 346         case 0: RawInputThreadMain(); break;
 347         case 1: DesktopThreadMain(); break;
 348         default: ERR("Wrong type: %x\n", Type);
 349     }
 350
 351     UserEnterShared();
 352
 353     return 0;
 354 }
 355
 356 /*
 357  * InitInputImpl
 358  *
 359  * Inits input implementation
 360  */
 361 INIT_FUNCTION
 362 NTSTATUS
 363 NTAPI
 364 InitInputImpl(VOID)
 365 {
 366     MasterTimer = ExAllocatePoolWithTag(NonPagedPool, sizeof(KTIMER), USERTAG_SYSTEM);
 367     if (!MasterTimer)
 368     {
 369         ERR("Failed to allocate memory\n");
 370         ASSERT(FALSE);
 371         return STATUS_UNSUCCESSFUL;
 372     }
 373     KeInitializeTimer(MasterTimer);
 374
 375     return STATUS_SUCCESS;
 376 }
 377
 378 BOOL FASTCALL
 379 IntBlockInput(PTHREADINFO pti, BOOL BlockIt)
 380 {
 381     PTHREADINFO OldBlock;
 382     ASSERT(pti);
 383
 384     if(!pti->rpdesk || ((pti->TIF_flags & TIF_INCLEANUP) && BlockIt))
 385     {
 386         /*
 387          * Fail blocking if exiting the thread
 388          */
 389
 390         return FALSE;
 391     }
 392
 393     /*
 394      * FIXME: Check access rights of the window station
 395      *        e.g. services running in the service window station cannot block input
 396      */
 397     if(!ThreadHasInputAccess(pti) ||
 398        !IntIsActiveDesktop(pti->rpdesk))
 399     {
 400         EngSetLastError(ERROR_ACCESS_DENIED);
 401         return FALSE;
 402     }
 403
 404     ASSERT(pti->rpdesk);
 405     OldBlock = pti->rpdesk->BlockInputThread;
 406     if(OldBlock)
 407     {
 408         if(OldBlock != pti)
 409         {
 410             EngSetLastError(ERROR_ACCESS_DENIED);
 411             return FALSE;
 412         }
 413         pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
 414         return OldBlock == NULL;
 415     }
 416
 417     pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
 418     return OldBlock == NULL;
 419 }
 420
 421 BOOL
 422 APIENTRY
 423 NtUserBlockInput(
 424     BOOL BlockIt)
 425 {
 426     BOOL ret;
 427
 428     TRACE("Enter NtUserBlockInput\n");
 429     UserEnterExclusive();
 430
 431     ret = IntBlockInput(PsGetCurrentThreadWin32Thread(), BlockIt);
 432
 433     UserLeave();
 434     TRACE("Leave NtUserBlockInput, ret=%i\n", ret);
 435
 436     return ret;
 437 }
 438
 439 BOOL
 440 FASTCALL
 441 IsRemoveAttachThread(PTHREADINFO pti)
 442 {
 443     NTSTATUS Status;
 444     PATTACHINFO pai;
 445     BOOL Ret = TRUE;
 446     PTHREADINFO ptiFrom = NULL, ptiTo = NULL;
 447
 448     do
 449     {
 450        if (!gpai) return TRUE;
 451
 452        pai = gpai; // Bottom of the list.
 453
 454        do
 455        {
 456           if (pai->pti2 == pti)
 457           {
 458              ptiFrom = pai->pti1;
 459              ptiTo = pti;
 460              break;
 461           }
 462           if (pai->pti1 == pti)
 463           {
 464              ptiFrom = pti;
 465              ptiTo = pai->pti2;
 466              break;
 467           }
 468           pai = pai->paiNext;
 469
 470        } while (pai);
 471
 472        if (!pai && !ptiFrom && !ptiTo) break;
 473
 474        Status = UserAttachThreadInput(ptiFrom, ptiTo, FALSE);
 475        if (!NT_SUCCESS(Status)) Ret = FALSE;
 476
 477     } while (Ret);
 478
 479     return Ret;
 480 }
 481
 482 NTSTATUS FASTCALL
 483 UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
 484 {
 485     MSG msg;
 486     PATTACHINFO pai;
 487     PCURICON_OBJECT CurIcon;
 488
 489     /* Can not be the same thread. */
 490     if (ptiFrom == ptiTo) return STATUS_INVALID_PARAMETER;
 491
 492     /* Do not attach to system threads or between different desktops. */
 493     if (ptiFrom->TIF_flags & TIF_DONTATTACHQUEUE ||
 494         ptiTo->TIF_flags & TIF_DONTATTACHQUEUE ||
 495         ptiFrom->rpdesk != ptiTo->rpdesk)
 496         return STATUS_ACCESS_DENIED;
 497
 498     /* MSDN Note:
 499        Keyboard and mouse events received by both threads are processed by the thread specified by the idAttachTo.
 500      */
 501
 502     /* If Attach set, allocate and link. */
 503     if (fAttach)
 504     {
 505         pai = ExAllocatePoolWithTag(PagedPool, sizeof(ATTACHINFO), USERTAG_ATTACHINFO);
 506         if (!pai) return STATUS_NO_MEMORY;
 507
 508         pai->paiNext = gpai;
 509         pai->pti1 = ptiFrom;
 510         pai->pti2 = ptiTo;
 511         gpai = pai;
 512         paiCount++;
 513         ERR("Attach Allocated! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 514
 515         if (ptiTo->MessageQueue != ptiFrom->MessageQueue)
 516         {
 517
 518            ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 519
 520            if (ptiFrom->MessageQueue == gpqForeground)
 521            {
 522               ERR("ptiFrom is Foreground\n");
 523               ptiTo->MessageQueue->spwndActive  = ptiFrom->MessageQueue->spwndActive;
 524               ptiTo->MessageQueue->spwndFocus   = ptiFrom->MessageQueue->spwndFocus;
 525               ptiTo->MessageQueue->spwndCapture = ptiFrom->MessageQueue->spwndCapture;
 526               ptiTo->MessageQueue->QF_flags    ^= ((ptiTo->MessageQueue->QF_flags ^ ptiFrom->MessageQueue->QF_flags) & QF_CAPTURELOCKED);
 527               RtlCopyMemory(ptiTo->MessageQueue->CaretInfo,
 528                             ptiFrom->MessageQueue->CaretInfo,
 529                             sizeof(ptiTo->MessageQueue->CaretInfo));
 530               IntSetFocusMessageQueue(NULL);
 531               IntSetFocusMessageQueue(ptiTo->MessageQueue);
 532               gptiForeground = ptiTo;
 533            }
 534            else
 535            {
 536               ERR("ptiFrom NOT Foreground\n");
 537               if ( ptiTo->MessageQueue->spwndActive == 0 )
 538                   ptiTo->MessageQueue->spwndActive = ptiFrom->MessageQueue->spwndActive;
 539               if ( ptiTo->MessageQueue->spwndFocus == 0 )
 540                   ptiTo->MessageQueue->spwndFocus  = ptiFrom->MessageQueue->spwndFocus;
 541            }
 542
 543            CurIcon = ptiFrom->MessageQueue->CursorObject;
 544
 545            MsqDestroyMessageQueue(ptiFrom);
 546
 547            if (CurIcon)
 548            {
 549               // Could be global. Keep it above the water line!
 550               UserReferenceObject(CurIcon);
 551            }
 552
 553            if (CurIcon && UserObjectInDestroy(UserHMGetHandle(CurIcon)))
 554            {
 555               UserDereferenceObject(CurIcon);
 556               CurIcon = NULL;
 557            }
 558
 559            ptiFrom->MessageQueue = ptiTo->MessageQueue;
 560
 561            // Pass cursor From if To is null. Pass test_SetCursor parent_id == current pti ID.
 562            if (CurIcon && ptiTo->MessageQueue->CursorObject == NULL)
 563            {
 564               ERR("ptiTo receiving ptiFrom Cursor\n");
 565               ptiTo->MessageQueue->CursorObject = CurIcon;
 566            }
 567
 568            ptiFrom->MessageQueue->cThreads++;
 569            ERR("ptiTo S Share count %u\n", ptiFrom->MessageQueue->cThreads);
 570
 571            IntReferenceMessageQueue(ptiTo->MessageQueue);
 572         }
 573         else
 574         {
 575            ERR("Attach Threads are already associated!\n");
 576         }
 577     }
 578     else /* If clear, unlink and free it. */
 579     {
 580         BOOL Hit = FALSE;
 581         PATTACHINFO *ppai;
 582
 583         if (!gpai) return STATUS_INVALID_PARAMETER;
 584
 585         /* Search list and free if found or return false. */
 586         ppai = &gpai;
 587         while (*ppai != NULL)
 588         {
 589            if ( (*ppai)->pti2 == ptiTo && (*ppai)->pti1 == ptiFrom )
 590            {
 591               pai = *ppai;
 592               /* Remove it from the list */
 593               *ppai = (*ppai)->paiNext;
 594               ExFreePoolWithTag(pai, USERTAG_ATTACHINFO);
 595               paiCount--;
 596               Hit = TRUE;
 597               break;
 598            }
 599            ppai = &((*ppai)->paiNext);
 600         }
 601
 602         if (!Hit) return STATUS_INVALID_PARAMETER;
 603
 604         ERR("Attach Free! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 605
 606         if (ptiTo->MessageQueue == ptiFrom->MessageQueue)
 607         {
 608            PWND spwndActive = ptiTo->MessageQueue->spwndActive;
 609            PWND spwndFocus  = ptiTo->MessageQueue->spwndFocus;
 610
 611            if (gptiForeground == ptiFrom)
 612            {
 613               ERR("ptiTo is now pti FG.\n");
 614               // MessageQueue foreground is set so switch threads.
 615               gptiForeground = ptiTo;
 616            }
 617            ptiTo->MessageQueue->cThreads--;
 618            ERR("ptiTo E Share count %u\n", ptiTo->MessageQueue->cThreads);
 619            ASSERT(ptiTo->MessageQueue->cThreads >= 1);
 620
 621            IntDereferenceMessageQueue(ptiTo->MessageQueue);
 622
 623            ptiFrom->MessageQueue = MsqCreateMessageQueue(ptiFrom);
 624
 625            if (spwndActive)
 626            {
 627               if (spwndActive->head.pti == ptiFrom)
 628               {
 629                  ptiFrom->MessageQueue->spwndActive = spwndActive;
 630                  ptiTo->MessageQueue->spwndActive = 0;
 631               }
 632            }
 633            if (spwndFocus)
 634            {
 635               if (spwndFocus->head.pti == ptiFrom)
 636               {
 637                  ptiFrom->MessageQueue->spwndFocus = spwndFocus;
 638                  ptiTo->MessageQueue->spwndFocus = 0;
 639               }
 640            }
 641            ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 642         }
 643         else
 644         {
 645            ERR("Detaching Threads are not associated!\n");
 646         }
 647     }
 648     /* Note that key state, which can be ascertained by calls to the GetKeyState
 649        or GetKeyboardState function, is reset after a call to AttachThreadInput.
 650        ATM which one?
 651      */
 652     RtlCopyMemory(ptiTo->MessageQueue->afKeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
 653
 654     ptiTo->MessageQueue->msgDblClk.message = 0;
 655
 656     /* Generate mouse move message */
 657     msg.message = WM_MOUSEMOVE;
 658     msg.wParam = UserGetMouseButtonsState();
 659     msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
 660     msg.pt = gpsi->ptCursor;
 661     co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
 662
 663     return STATUS_SUCCESS;
 664 }
 665
 666 BOOL
 667 APIENTRY
 668 NtUserAttachThreadInput(
 669     IN DWORD idAttach,
 670     IN DWORD idAttachTo,
 671     IN BOOL fAttach)
 672 {
 673   NTSTATUS Status;
 674   PTHREADINFO pti, ptiTo;
 675   BOOL Ret = FALSE;
 676
 677   UserEnterExclusive();
 678   TRACE("Enter NtUserAttachThreadInput %s\n",(fAttach ? "TRUE" : "FALSE" ));
 679
 680   pti = IntTID2PTI((HANDLE)idAttach);
 681   ptiTo = IntTID2PTI((HANDLE)idAttachTo);
 682
 683   if ( !pti || !ptiTo )
 684   {
 685      TRACE("AttachThreadInput pti or ptiTo NULL.\n");
 686      EngSetLastError(ERROR_INVALID_PARAMETER);
 687      goto Exit;
 688   }
 689
 690   Status = UserAttachThreadInput( pti, ptiTo, fAttach);
 691   if (!NT_SUCCESS(Status))
 692   {
 693      TRACE("AttachThreadInput Error Status 0x%x. \n",Status);
 694      EngSetLastError(RtlNtStatusToDosError(Status));
 695   }
 696   else Ret = TRUE;
 697
 698 Exit:
 699   TRACE("Leave NtUserAttachThreadInput, ret=%d\n",Ret);
 700   UserLeave();
 701   return Ret;
 702 }
 703
 704 /*
 705  * NtUserSendInput
 706  *
 707  * Generates input events from software
 708  */
 709 UINT
 710 APIENTRY
 711 NtUserSendInput(
 712     UINT nInputs,
 713     LPINPUT pInput,
 714     INT cbSize)
 715 {
 716     PTHREADINFO pti;
 717     UINT uRet = 0;
 718
 719     TRACE("Enter NtUserSendInput\n");
 720     UserEnterExclusive();
 721
 722     pti = PsGetCurrentThreadWin32Thread();
 723     ASSERT(pti);
 724
 725     if (!pti->rpdesk)
 726     {
 727         goto cleanup;
 728     }
 729
 730     if (!nInputs || !pInput || cbSize != sizeof(INPUT))
 731     {
 732         EngSetLastError(ERROR_INVALID_PARAMETER);
 733         goto cleanup;
 734     }
 735
 736     /*
 737      * FIXME: Check access rights of the window station
 738      *        e.g. services running in the service window station cannot block input
 739      */
 740     if (!ThreadHasInputAccess(pti) ||
 741         !IntIsActiveDesktop(pti->rpdesk))
 742     {
 743         EngSetLastError(ERROR_ACCESS_DENIED);
 744         goto cleanup;
 745     }
 746
 747     while (nInputs--)
 748     {
 749         INPUT SafeInput;
 750         NTSTATUS Status;
 751
 752         Status = MmCopyFromCaller(&SafeInput, pInput++, sizeof(INPUT));
 753         if (!NT_SUCCESS(Status))
 754         {
 755             SetLastNtError(Status);
 756             goto cleanup;
 757         }
 758
 759         switch (SafeInput.type)
 760         {
 761             case INPUT_MOUSE:
 762                 if (UserSendMouseInput(&SafeInput.mi, TRUE))
 763                     uRet++;
 764                 break;
 765             case INPUT_KEYBOARD:
 766                 if (UserSendKeyboardInput(&SafeInput.ki, TRUE))
 767                     uRet++;
 768                 break;
 769             case INPUT_HARDWARE:
 770                 FIXME("INPUT_HARDWARE not supported!");
 771                 break;
 772             default:
 773                 ERR("SendInput(): Invalid input type: 0x%x\n", SafeInput.type);
 774                 break;
 775         }
 776     }
 777
 778 cleanup:
 779     TRACE("Leave NtUserSendInput, ret=%u\n", uRet);
 780     UserLeave();
 781     return uRet;
 782 }
 783
 784 /* EOF */