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:             subsystems/win32/win32k/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                                0,
 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()
 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[3], pSignaledObject = NULL;
 136     ULONG cWaitObjects = 0, cMaxWaitObjects = 1;
 137     MOUSE_INPUT_DATA MouseInput;
 138     KEYBOARD_INPUT_DATA KeyInput;
 139
 140     ByteOffset.QuadPart = (LONGLONG)0;
 141     //WaitTimeout.QuadPart = (LONGLONG)(-10000000);
 142
 143     ptiRawInput = GetW32ThreadInfo();
 144     ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
 145     ptiRawInput->pClientInfo->dwTIFlags = ptiRawInput->TIF_flags;
 146
 147     TRACE("Raw Input Thread %p\n", ptiRawInput);
 148
 149     KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
 150                         LOW_REALTIME_PRIORITY + 3);
 151
 152     UserEnterExclusive();
 153     StartTheTimers();
 154     UserLeave();
 155
 156     for(;;)
 157     {
 158         if (!ghMouseDevice)
 159         {
 160             /* Check if mouse device already exists */
 161             Status = OpenInputDevice(&ghMouseDevice, &pMouDevice, L"\\Device\\PointerClass0" );
 162             if (NT_SUCCESS(Status))
 163             {
 164                 ++cMaxWaitObjects;
 165                 TRACE("Mouse connected!\n");
 166             }
 167         }
 168         if (!ghKeyboardDevice)
 169         {
 170             /* Check if keyboard device already exists */
 171             Status = OpenInputDevice(&ghKeyboardDevice, &pKbdDevice, L"\\Device\\KeyboardClass0");
 172             if (NT_SUCCESS(Status))
 173             {
 174                 ++cMaxWaitObjects;
 175                 TRACE("Keyboard connected!\n");
 176                 // Get and load keyboard attributes.
 177                 UserInitKeyboard(ghKeyboardDevice);
 178                 UserEnterExclusive();
 179                 // Register the Window hotkey.
 180                 UserRegisterHotKey(PWND_BOTTOM, IDHK_WINKEY, MOD_WIN, 0);
 181                 // Register the debug hotkeys.
 182                 StartDebugHotKeys();
 183                 UserLeave();
 184             }
 185         }
 186
 187         /* Reset WaitHandles array */
 188         cWaitObjects = 0;
 189         WaitObjects[cWaitObjects++] = MasterTimer;
 190
 191         if (ghMouseDevice)
 192         {
 193             /* Try to read from mouse if previous reading is not pending */
 194             if (MouStatus != STATUS_PENDING)
 195             {
 196                 MouStatus = ZwReadFile(ghMouseDevice,
 197                                        NULL,
 198                                        NULL,
 199                                        NULL,
 200                                        &MouIosb,
 201                                        &MouseInput,
 202                                        sizeof(MOUSE_INPUT_DATA),
 203                                        &ByteOffset,
 204                                        NULL);
 205             }
 206
 207             if (MouStatus == STATUS_PENDING)
 208                 WaitObjects[cWaitObjects++] = &pMouDevice->Event;
 209         }
 210
 211         if (ghKeyboardDevice)
 212         {
 213             /* Try to read from keyboard if previous reading is not pending */
 214             if (KbdStatus != STATUS_PENDING)
 215             {
 216                 KbdStatus = ZwReadFile(ghKeyboardDevice,
 217                                        NULL,
 218                                        NULL,
 219                                        NULL,
 220                                        &KbdIosb,
 221                                        &KeyInput,
 222                                        sizeof(KEYBOARD_INPUT_DATA),
 223                                        &ByteOffset,
 224                                        NULL);
 225
 226             }
 227             if (KbdStatus == STATUS_PENDING)
 228                 WaitObjects[cWaitObjects++] = &pKbdDevice->Event;
 229         }
 230
 231         /* If all objects are pending, wait for them */
 232         if (cWaitObjects == cMaxWaitObjects)
 233         {
 234             Status = KeWaitForMultipleObjects(cWaitObjects,
 235                                               WaitObjects,
 236                                               WaitAny,
 237                                               UserRequest,
 238                                               KernelMode,
 239                                               TRUE,
 240                                               NULL,//&WaitTimeout,
 241                                               NULL);
 242
 243             if ((Status >= STATUS_WAIT_0) &&
 244                 (Status < (STATUS_WAIT_0 + (LONG)cWaitObjects)))
 245             {
 246                 /* Some device has finished reading */
 247                 pSignaledObject = WaitObjects[Status - STATUS_WAIT_0];
 248
 249                 /* Check if it is mouse or keyboard and update status */
 250                 if (pSignaledObject == &pMouDevice->Event)
 251                     MouStatus = MouIosb.Status;
 252                 else if (pSignaledObject == &pKbdDevice->Event)
 253                     KbdStatus = KbdIosb.Status;
 254                 else if (pSignaledObject == MasterTimer)
 255                 {
 256                     ProcessTimers();
 257                 }
 258                 else ASSERT(FALSE);
 259             }
 260         }
 261
 262         /* Have we successed reading from mouse? */
 263         if (NT_SUCCESS(MouStatus) && MouStatus != STATUS_PENDING)
 264         {
 265             TRACE("MouseEvent\n");
 266
 267             /* Set LastInputTick */
 268             IntLastInputTick(TRUE);
 269
 270             /* Process data */
 271             UserEnterExclusive();
 272             UserProcessMouseInput(&MouseInput);
 273             UserLeave();
 274         }
 275         else if (MouStatus != STATUS_PENDING)
 276             ERR("Failed to read from mouse: %x.\n", MouStatus);
 277
 278         /* Have we successed reading from keyboard? */
 279         if (NT_SUCCESS(KbdStatus) && KbdStatus != STATUS_PENDING)
 280         {
 281             TRACE("KeyboardEvent: %s %04x\n",
 282                   (KeyInput.Flags & KEY_BREAK) ? "up" : "down",
 283                   KeyInput.MakeCode);
 284
 285             /* Set LastInputTick */
 286             IntLastInputTick(TRUE);
 287
 288             /* Process data */
 289             UserEnterExclusive();
 290             UserProcessKeyboardInput(&KeyInput);
 291             UserLeave();
 292         }
 293         else if (KbdStatus != STATUS_PENDING)
 294             ERR("Failed to read from keyboard: %x.\n", KbdStatus);
 295     }
 296     ERR("Raw Input Thread Exit!\n");
 297 }
 298
 299 /*
 300  * CreateSystemThreads
 301  *
 302  * Called form dedicated thread in CSRSS. RIT is started in context of this
 303  * thread because it needs valid Win32 process with TEB initialized
 304  */
 305 DWORD NTAPI
 306 CreateSystemThreads(UINT Type)
 307 {
 308     UserLeave();
 309
 310     switch (Type)
 311     {
 312         case 0: RawInputThreadMain(); break;
 313         case 1: DesktopThreadMain(); break;
 314         default: ERR("Wrong type: %x\n", Type);
 315     }
 316
 317     UserEnterShared();
 318
 319     return 0;
 320 }
 321
 322 /*
 323  * InitInputImpl
 324  *
 325  * Inits input implementation
 326  */
 327 INIT_FUNCTION
 328 NTSTATUS
 329 NTAPI
 330 InitInputImpl(VOID)
 331 {
 332     MasterTimer = ExAllocatePoolWithTag(NonPagedPool, sizeof(KTIMER), USERTAG_SYSTEM);
 333     if (!MasterTimer)
 334     {
 335         ERR("Failed to allocate memory\n");
 336         ASSERT(FALSE);
 337         return STATUS_UNSUCCESSFUL;
 338     }
 339     KeInitializeTimer(MasterTimer);
 340
 341     return STATUS_SUCCESS;
 342 }
 343
 344 BOOL FASTCALL
 345 IntBlockInput(PTHREADINFO pti, BOOL BlockIt)
 346 {
 347     PTHREADINFO OldBlock;
 348     ASSERT(pti);
 349
 350     if(!pti->rpdesk || ((pti->TIF_flags & TIF_INCLEANUP) && BlockIt))
 351     {
 352         /*
 353          * Fail blocking if exiting the thread
 354          */
 355
 356         return FALSE;
 357     }
 358
 359     /*
 360      * FIXME: Check access rights of the window station
 361      *        e.g. services running in the service window station cannot block input
 362      */
 363     if(!ThreadHasInputAccess(pti) ||
 364        !IntIsActiveDesktop(pti->rpdesk))
 365     {
 366         EngSetLastError(ERROR_ACCESS_DENIED);
 367         return FALSE;
 368     }
 369
 370     ASSERT(pti->rpdesk);
 371     OldBlock = pti->rpdesk->BlockInputThread;
 372     if(OldBlock)
 373     {
 374         if(OldBlock != pti)
 375         {
 376             EngSetLastError(ERROR_ACCESS_DENIED);
 377             return FALSE;
 378         }
 379         pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
 380         return OldBlock == NULL;
 381     }
 382
 383     pti->rpdesk->BlockInputThread = (BlockIt ? pti : NULL);
 384     return OldBlock == NULL;
 385 }
 386
 387 BOOL
 388 APIENTRY
 389 NtUserBlockInput(
 390     BOOL BlockIt)
 391 {
 392     BOOL ret;
 393
 394     TRACE("Enter NtUserBlockInput\n");
 395     UserEnterExclusive();
 396
 397     ret = IntBlockInput(PsGetCurrentThreadWin32Thread(), BlockIt);
 398
 399     UserLeave();
 400     TRACE("Leave NtUserBlockInput, ret=%i\n", ret);
 401
 402     return ret;
 403 }
 404
 405 PTHREADINFO FASTCALL
 406 IsThreadAttach(PTHREADINFO ptiTo)
 407 {
 408     PATTACHINFO pai;
 409
 410     if (!gpai) return NULL;
 411
 412     pai = gpai;
 413     do
 414     {
 415         if (pai->pti2 == ptiTo) break;
 416         pai = pai->paiNext;
 417     } while (pai);
 418
 419     if (!pai) return NULL;
 420
 421     // Return ptiFrom.
 422     return pai->pti1;
 423 }
 424
 425 NTSTATUS FASTCALL
 426 UserAttachThreadInput(PTHREADINFO ptiFrom, PTHREADINFO ptiTo, BOOL fAttach)
 427 {
 428     MSG msg;
 429     PATTACHINFO pai;
 430
 431     /* Can not be the same thread. */
 432     if (ptiFrom == ptiTo) return STATUS_INVALID_PARAMETER;
 433
 434     /* Do not attach to system threads or between different desktops. */
 435     if (ptiFrom->TIF_flags & TIF_DONTATTACHQUEUE ||
 436         ptiTo->TIF_flags & TIF_DONTATTACHQUEUE ||
 437         ptiFrom->rpdesk != ptiTo->rpdesk)
 438         return STATUS_ACCESS_DENIED;
 439
 440     /* MSDN Note:
 441        Keyboard and mouse events received by both threads are processed by the thread specified by the idAttachTo.
 442      */
 443
 444     /* If Attach set, allocate and link. */
 445     if (fAttach)
 446     {
 447         pai = ExAllocatePoolWithTag(PagedPool, sizeof(ATTACHINFO), USERTAG_ATTACHINFO);
 448         if (!pai) return STATUS_NO_MEMORY;
 449
 450         pai->paiNext = gpai;
 451         pai->pti1 = ptiFrom;
 452         pai->pti2 = ptiTo;
 453         gpai = pai;
 454         paiCount++;
 455         ERR("Attach Allocated! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 456
 457         if (ptiTo->MessageQueue == ptiFrom->MessageQueue)
 458         {
 459            ERR("Attach Threads are already associated!\n");
 460         }
 461
 462         ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 463
 464         /* Keep the original queue in pqAttach (ie do not trash it in a second attachment) */
 465         if (ptiFrom->pqAttach == NULL)
 466            ptiFrom->pqAttach = ptiFrom->MessageQueue;
 467         ptiFrom->MessageQueue = ptiTo->MessageQueue;
 468
 469         ptiFrom->MessageQueue->cThreads++;
 470         ERR("ptiTo S Share count %lu\n", ptiFrom->MessageQueue->cThreads);
 471
 472         // FIXME: conditions?
 473         if (ptiFrom->pqAttach == gpqForeground)
 474         {
 475            ERR("ptiFrom is Foreground\n");
 476         ptiFrom->MessageQueue->spwndActive = ptiFrom->pqAttach->spwndActive;
 477         ptiFrom->MessageQueue->spwndFocus = ptiFrom->pqAttach->spwndFocus;
 478         ptiFrom->MessageQueue->CursorObject = ptiFrom->pqAttach->CursorObject;
 479         ptiFrom->MessageQueue->spwndCapture = ptiFrom->pqAttach->spwndCapture;
 480         ptiFrom->MessageQueue->QF_flags ^= ((ptiFrom->MessageQueue->QF_flags ^ ptiFrom->pqAttach->QF_flags) & QF_CAPTURELOCKED);
 481         ptiFrom->MessageQueue->CaretInfo = ptiFrom->pqAttach->CaretInfo;
 482         }
 483         else
 484         {
 485            ERR("ptiFrom NOT Foreground\n");
 486         }
 487         if (ptiTo->MessageQueue == gpqForeground)
 488         {
 489            ERR("ptiTo is Foreground\n");
 490         }
 491         else
 492         {
 493            ERR("ptiTo NOT Foreground\n");
 494         }
 495     }
 496     else /* If clear, unlink and free it. */
 497     {
 498         BOOL Hit = FALSE;
 499         PATTACHINFO *ppai;
 500
 501         if (!gpai) return STATUS_INVALID_PARAMETER;
 502
 503         /* Search list and free if found or return false. */
 504         ppai = &gpai;
 505         while (*ppai != NULL)
 506         {
 507            if ( (*ppai)->pti2 == ptiTo && (*ppai)->pti1 == ptiFrom )
 508            {
 509               pai = *ppai;
 510               /* Remove it from the list */
 511               *ppai = (*ppai)->paiNext;
 512               ExFreePoolWithTag(pai, USERTAG_ATTACHINFO);
 513               paiCount--;
 514               Hit = TRUE;
 515               break;
 516            }
 517            ppai = &((*ppai)->paiNext);
 518         }
 519
 520         if (!Hit) return STATUS_INVALID_PARAMETER;
 521
 522         ASSERT(ptiFrom->pqAttach);
 523
 524         ERR("Attach Free! ptiFrom 0x%p  ptiTo 0x%p paiCount %d\n",ptiFrom,ptiTo,paiCount);
 525
 526         /* Search list and check if the thread is attached one more time */
 527         pai = gpai;
 528         while(pai)
 529         {
 530             /* If the thread is attached again , we are done */
 531             if (pai->pti1 == ptiFrom)
 532             {
 533                 ptiFrom->MessageQueue->cThreads--;
 534                 ERR("ptiTo L Share count %lu\n", ptiFrom->MessageQueue->cThreads);
 535                 /* Use the message queue of the last attachment */
 536                 ptiFrom->MessageQueue = pai->pti2->MessageQueue;
 537                 ptiFrom->MessageQueue->CursorObject = NULL;
 538                 ptiFrom->MessageQueue->spwndActive = NULL;
 539                 ptiFrom->MessageQueue->spwndFocus = NULL;
 540                 ptiFrom->MessageQueue->spwndCapture = NULL;
 541                 return STATUS_SUCCESS;
 542             }
 543             pai = pai->paiNext;
 544         }
 545
 546         ptiFrom->MessageQueue->cThreads--;
 547         ERR("ptiTo E Share count %lu\n", ptiFrom->MessageQueue->cThreads);
 548         ptiFrom->MessageQueue = ptiFrom->pqAttach;
 549         // FIXME: conditions?
 550         ptiFrom->MessageQueue->CursorObject = NULL;
 551         ptiFrom->MessageQueue->spwndActive = NULL;
 552         ptiFrom->MessageQueue->spwndFocus = NULL;
 553         ptiFrom->MessageQueue->spwndCapture = NULL;
 554         ptiFrom->pqAttach = NULL;
 555         ptiTo->MessageQueue->iCursorLevel -= ptiFrom->iCursorLevel;
 556     }
 557     /* Note that key state, which can be ascertained by calls to the GetKeyState
 558        or GetKeyboardState function, is reset after a call to AttachThreadInput.
 559        ATM which one?
 560      */
 561     RtlCopyMemory(ptiTo->MessageQueue->afKeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
 562
 563     /* Generate mouse move message */
 564     msg.message = WM_MOUSEMOVE;
 565     msg.wParam = UserGetMouseButtonsState();
 566     msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
 567     msg.pt = gpsi->ptCursor;
 568     co_MsqInsertMouseMessage(&msg, 0, 0, TRUE);
 569
 570     return STATUS_SUCCESS;
 571 }
 572
 573 /*
 574  * NtUserSendInput
 575  *
 576  * Generates input events from software
 577  */
 578 UINT
 579 APIENTRY
 580 NtUserSendInput(
 581     UINT nInputs,
 582     LPINPUT pInput,
 583     INT cbSize)
 584 {
 585     PTHREADINFO pti;
 586     UINT uRet = 0;
 587
 588     TRACE("Enter NtUserSendInput\n");
 589     UserEnterExclusive();
 590
 591     pti = PsGetCurrentThreadWin32Thread();
 592     ASSERT(pti);
 593
 594     if (!pti->rpdesk)
 595     {
 596         goto cleanup;
 597     }
 598
 599     if (!nInputs || !pInput || cbSize != sizeof(INPUT))
 600     {
 601         EngSetLastError(ERROR_INVALID_PARAMETER);
 602         goto cleanup;
 603     }
 604
 605     /*
 606      * FIXME: Check access rights of the window station
 607      *        e.g. services running in the service window station cannot block input
 608      */
 609     if (!ThreadHasInputAccess(pti) ||
 610         !IntIsActiveDesktop(pti->rpdesk))
 611     {
 612         EngSetLastError(ERROR_ACCESS_DENIED);
 613         goto cleanup;
 614     }
 615
 616     while (nInputs--)
 617     {
 618         INPUT SafeInput;
 619         NTSTATUS Status;
 620
 621         Status = MmCopyFromCaller(&SafeInput, pInput++, sizeof(INPUT));
 622         if (!NT_SUCCESS(Status))
 623         {
 624             SetLastNtError(Status);
 625             goto cleanup;
 626         }
 627
 628         switch (SafeInput.type)
 629         {
 630             case INPUT_MOUSE:
 631                 if (UserSendMouseInput(&SafeInput.mi, TRUE))
 632                     uRet++;
 633                 break;
 634             case INPUT_KEYBOARD:
 635                 if (UserSendKeyboardInput(&SafeInput.ki, TRUE))
 636                     uRet++;
 637                 break;
 638             case INPUT_HARDWARE:
 639                 FIXME("INPUT_HARDWARE not supported!");
 640                 break;
 641             default:
 642                 ERR("SendInput(): Invalid input type: 0x%x\n", SafeInput.type);
 643                 break;
 644         }
 645     }
 646
 647 cleanup:
 648     TRACE("Leave NtUserSendInput, ret=%u\n", uRet);
 649     UserLeave();
 650     return uRet;
 651 }
 652
 653 /* EOF */