reactos/win32ss/user/ntuser/ntstubs.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS Win32k subsystem
   4  * PURPOSE:          Native User stubs
   5  * FILE:             win32ss/user/ntuser/ntstubs.c
   6  * PROGRAMER:        Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  */
   8
   9 #include <win32k.h>
  10 DBG_DEFAULT_CHANNEL(UserMisc);
  11
  12 DWORD
  13 APIENTRY
  14 NtUserAssociateInputContext(
  15     DWORD dwUnknown1,
  16     DWORD dwUnknown2,
  17     DWORD dwUnknown3)
  18 {
  19     STUB
  20     return 0;
  21 }
  22
  23 //
  24 // Works like BitBlt, http://msdn.microsoft.com/en-us/library/ms532278(VS.85).aspx
  25 //
  26 BOOL
  27 APIENTRY
  28 NtUserBitBltSysBmp(
  29    HDC hdc,
  30    INT nXDest,
  31    INT nYDest,
  32    INT nWidth,
  33    INT nHeight,
  34    INT nXSrc,
  35    INT nYSrc,
  36    DWORD dwRop )
  37 {
  38    BOOL Ret = FALSE;
  39    UserEnterExclusive();
  40
  41    Ret = NtGdiBitBlt( hdc,
  42                    nXDest,
  43                    nYDest,
  44                    nWidth,
  45                   nHeight,
  46                 hSystemBM,
  47                     nXSrc,
  48                     nYSrc,
  49                     dwRop,
  50                         0,
  51                         0);
  52
  53    UserLeave();
  54    return Ret;
  55 }
  56
  57 DWORD
  58 APIENTRY
  59 NtUserBuildHimcList(
  60     DWORD dwUnknown1,
  61     DWORD dwUnknown2,
  62     DWORD dwUnknown3,
  63     DWORD dwUnknown4)
  64 {
  65     STUB;
  66     return 0;
  67 }
  68
  69 DWORD
  70 APIENTRY
  71 NtUserDragObject(
  72    HWND    hwnd1,
  73    HWND    hwnd2,
  74    UINT    u1,
  75    DWORD   dw1,
  76    HCURSOR hc1
  77 )
  78 {
  79    STUB
  80
  81    return 0;
  82 }
  83
  84 BOOL
  85 APIENTRY
  86 NtUserDrawAnimatedRects(
  87    HWND hwnd,
  88    INT idAni,
  89    RECT *lprcFrom,
  90    RECT *lprcTo)
  91 {
  92    STUB
  93
  94    return 0;
  95 }
  96
  97 DWORD
  98 APIENTRY
  99 NtUserEvent(
 100    DWORD Unknown0)
 101 {
 102    STUB
 103
 104    return 0;
 105 }
 106
 107 DWORD
 108 APIENTRY
 109 NtUserExcludeUpdateRgn(
 110   HDC hDC,
 111   HWND hWnd)
 112 {
 113    STUB
 114
 115    return 0;
 116 }
 117
 118 BOOL
 119 APIENTRY
 120 NtUserGetAltTabInfo(
 121    HWND hwnd,
 122    INT  iItem,
 123    PALTTABINFO pati,
 124    LPWSTR pszItemText,
 125    UINT   cchItemText,
 126    BOOL   Ansi)
 127 {
 128    STUB
 129
 130    return 0;
 131 }
 132
 133 NTSTATUS
 134 APIENTRY
 135 NtUserInitializeClientPfnArrays(
 136   PPFNCLIENT pfnClientA,
 137   PPFNCLIENT pfnClientW,
 138   PPFNCLIENTWORKER pfnClientWorker,
 139   HINSTANCE hmodUser)
 140 {
 141    NTSTATUS Status = STATUS_SUCCESS;
 142    TRACE("Enter NtUserInitializeClientPfnArrays User32 0x%p\n", hmodUser);
 143
 144    if (ClientPfnInit) return Status;
 145
 146    UserEnterExclusive();
 147
 148    _SEH2_TRY
 149    {
 150       ProbeForRead( pfnClientA, sizeof(PFNCLIENT), 1);
 151       ProbeForRead( pfnClientW, sizeof(PFNCLIENT), 1);
 152       ProbeForRead( pfnClientWorker, sizeof(PFNCLIENTWORKER), 1);
 153       RtlCopyMemory(&gpsi->apfnClientA, pfnClientA, sizeof(PFNCLIENT));
 154       RtlCopyMemory(&gpsi->apfnClientW, pfnClientW, sizeof(PFNCLIENT));
 155       RtlCopyMemory(&gpsi->apfnClientWorker, pfnClientWorker, sizeof(PFNCLIENTWORKER));
 156
 157       //// FIXME: HAX! Temporary until server side is finished.
 158       //// Copy the client side procs for now.
 159       RtlCopyMemory(&gpsi->aStoCidPfn, pfnClientW, sizeof(gpsi->aStoCidPfn));
 160
 161       hModClient = hmodUser;
 162       ClientPfnInit = TRUE;
 163    }
 164    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 165    {
 166       Status =_SEH2_GetExceptionCode();
 167    }
 168    _SEH2_END
 169
 170    if (!NT_SUCCESS(Status))
 171    {
 172       ERR("Failed reading Client Pfns from user space.\n");
 173       SetLastNtError(Status);
 174    }
 175
 176    UserLeave();
 177    return Status;
 178 }
 179
 180 DWORD
 181 APIENTRY
 182 NtUserInitTask(
 183    DWORD Unknown0,
 184    DWORD Unknown1,
 185    DWORD Unknown2,
 186    DWORD Unknown3,
 187    DWORD Unknown4,
 188    DWORD Unknown5,
 189    DWORD Unknown6,
 190    DWORD Unknown7,
 191    DWORD Unknown8,
 192    DWORD Unknown9,
 193    DWORD Unknown10,
 194    DWORD Unknown11)
 195 {
 196    STUB
 197
 198    return 0;
 199 }
 200
 201 DWORD
 202 APIENTRY
 203 NtUserMNDragLeave(VOID)
 204 {
 205    STUB
 206
 207    return 0;
 208 }
 209
 210 DWORD
 211 APIENTRY
 212 NtUserMNDragOver(
 213    DWORD Unknown0,
 214    DWORD Unknown1)
 215 {
 216    STUB
 217
 218    return 0;
 219 }
 220
 221 DWORD
 222 APIENTRY
 223 NtUserModifyUserStartupInfoFlags(
 224    DWORD Unknown0,
 225    DWORD Unknown1)
 226 {
 227    STUB
 228
 229    return 0;
 230 }
 231
 232 DWORD
 233 APIENTRY
 234 NtUserQueryUserCounters(
 235    DWORD Unknown0,
 236    DWORD Unknown1,
 237    DWORD Unknown2,
 238    DWORD Unknown3,
 239    DWORD Unknown4)
 240 {
 241    STUB
 242
 243    return 0;
 244 }
 245
 246 DWORD
 247 APIENTRY
 248 NtUserRegisterTasklist(
 249    DWORD Unknown0)
 250 {
 251    STUB
 252
 253    return 0;
 254 }
 255
 256 DWORD
 257 APIENTRY
 258 NtUserSetConsoleReserveKeys(
 259    DWORD Unknown0,
 260    DWORD Unknown1)
 261 {
 262    STUB
 263
 264    return 0;
 265 }
 266
 267 DWORD
 268 APIENTRY
 269 NtUserSetDbgTag(
 270    DWORD Unknown0,
 271    DWORD Unknown1)
 272 {
 273    STUB
 274
 275    return 0;
 276 }
 277
 278 DWORD
 279 APIENTRY
 280 NtUserSetRipFlags(
 281    DWORD Unknown0,
 282    DWORD Unknown1)
 283 {
 284    STUB
 285
 286    return 0;
 287 }
 288
 289 BOOL
 290 APIENTRY
 291 NtUserSetSysColors(
 292    int cElements,
 293    IN CONST INT *lpaElements,
 294    IN CONST COLORREF *lpaRgbValues,
 295    FLONG Flags)
 296 {
 297    DWORD Ret = TRUE;
 298
 299    if (cElements == 0)
 300       return TRUE;
 301
 302    /* We need this check to prevent overflow later */
 303    if ((ULONG)cElements >= 0x40000000)
 304    {
 305       EngSetLastError(ERROR_NOACCESS);
 306       return FALSE;
 307    }
 308
 309    UserEnterExclusive();
 310
 311    _SEH2_TRY
 312    {
 313       ProbeForRead(lpaElements, cElements * sizeof(INT), 1);
 314       ProbeForRead(lpaRgbValues, cElements * sizeof(COLORREF), 1);
 315
 316       IntSetSysColors(cElements, lpaElements, lpaRgbValues);
 317    }
 318    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 319    {
 320       SetLastNtError(_SEH2_GetExceptionCode());
 321       Ret = FALSE;
 322    }
 323    _SEH2_END;
 324
 325    if (Ret)
 326    {
 327       UserSendNotifyMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
 328
 329       UserRedrawDesktop();
 330    }
 331
 332    UserLeave();
 333    return Ret;
 334 }
 335
 336 DWORD
 337 APIENTRY
 338 NtUserUpdateInputContext(
 339    DWORD Unknown0,
 340    DWORD Unknown1,
 341    DWORD Unknown2)
 342 {
 343    STUB
 344
 345    return 0;
 346 }
 347
 348 DWORD
 349 APIENTRY
 350 NtUserUpdateInstance(
 351    DWORD Unknown0,
 352    DWORD Unknown1,
 353    DWORD Unknown2)
 354 {
 355    STUB
 356
 357    return 0;
 358 }
 359
 360 BOOL
 361 APIENTRY
 362 NtUserUserHandleGrantAccess(
 363    IN HANDLE hUserHandle,
 364    IN HANDLE hJob,
 365    IN BOOL bGrant)
 366 {
 367    STUB
 368
 369    return 0;
 370 }
 371
 372 DWORD
 373 APIENTRY
 374 NtUserWaitForMsgAndEvent(
 375    DWORD Unknown0)
 376 {
 377    STUB
 378
 379    return 0;
 380 }
 381
 382 DWORD
 383 APIENTRY
 384 NtUserWin32PoolAllocationStats(
 385    DWORD Unknown0,
 386    DWORD Unknown1,
 387    DWORD Unknown2,
 388    DWORD Unknown3,
 389    DWORD Unknown4,
 390    DWORD Unknown5)
 391 {
 392    STUB
 393
 394    return 0;
 395 }
 396
 397 DWORD
 398 APIENTRY
 399 NtUserYieldTask(VOID)
 400 {
 401    STUB
 402
 403    return 0;
 404 }
 405
 406 NTSTATUS
 407 APIENTRY
 408 NtUserConsoleControl(
 409     IN CONSOLECONTROL ConsoleCtrl,
 410     IN PVOID ConsoleCtrlInfo,
 411     IN ULONG ConsoleCtrlInfoLength)
 412 {
 413     NTSTATUS Status = STATUS_SUCCESS;
 414
 415     /* Allow only the Console Server to perform this operation (via CSRSS) */
 416     if (PsGetCurrentProcess() != gpepCSRSS)
 417         return STATUS_ACCESS_DENIED;
 418
 419     UserEnterExclusive();
 420
 421     switch (ConsoleCtrl)
 422     {
 423         case GuiConsoleWndClassAtom:
 424         {
 425             if (ConsoleCtrlInfoLength != sizeof(ATOM))
 426             {
 427                 Status = STATUS_INFO_LENGTH_MISMATCH;
 428                 break;
 429             }
 430
 431             _SEH2_TRY
 432             {
 433                 ProbeForRead(ConsoleCtrlInfo, ConsoleCtrlInfoLength, 1);
 434                 gaGuiConsoleWndClass = *(ATOM*)ConsoleCtrlInfo;
 435             }
 436             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 437             {
 438                 Status = _SEH2_GetExceptionCode();
 439             }
 440             _SEH2_END;
 441
 442             break;
 443         }
 444
 445         case ConsoleMakePalettePublic:
 446         {
 447             HPALETTE hPalette;
 448
 449             if (ConsoleCtrlInfoLength != sizeof(HPALETTE))
 450             {
 451                 Status = STATUS_INFO_LENGTH_MISMATCH;
 452                 break;
 453             }
 454
 455             _SEH2_TRY
 456             {
 457                 ProbeForRead(ConsoleCtrlInfo, ConsoleCtrlInfoLength, 1);
 458                 hPalette = *(HPALETTE*)ConsoleCtrlInfo;
 459             }
 460             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 461             {
 462                 Status = _SEH2_GetExceptionCode();
 463             }
 464             _SEH2_END;
 465
 466             /* Make the palette handle public */
 467             GreSetObjectOwnerEx(hPalette,
 468                                 GDI_OBJ_HMGR_PUBLIC,
 469                                 GDIOBJFLAG_IGNOREPID);
 470
 471             break;
 472         }
 473
 474         case ConsoleAcquireDisplayOwnership:
 475         {
 476             ERR("NtUserConsoleControl - ConsoleAcquireDisplayOwnership is UNIMPLEMENTED\n");
 477             Status = STATUS_NOT_IMPLEMENTED;
 478             break;
 479         }
 480
 481         default:
 482             ERR("Calling invalid control %lu in NtUserConsoleControl\n", ConsoleCtrl);
 483             Status = STATUS_INVALID_INFO_CLASS;
 484             break;
 485     }
 486
 487     UserLeave();
 488
 489     return Status;
 490 }
 491
 492 DWORD
 493 APIENTRY
 494 NtUserCreateInputContext(
 495     DWORD dwUnknown1)
 496 {
 497     STUB;
 498     return 0;
 499 }
 500
 501 DWORD
 502 APIENTRY
 503 NtUserDestroyInputContext(
 504     DWORD dwUnknown1)
 505 {
 506     STUB;
 507     return 0;
 508 }
 509
 510 DWORD
 511 APIENTRY
 512 NtUserGetRawInputBuffer(
 513     PRAWINPUT pData,
 514     PUINT pcbSize,
 515     UINT cbSizeHeader)
 516 {
 517     STUB;
 518     return 0;
 519 }
 520
 521 DWORD
 522 APIENTRY
 523 NtUserGetRawInputData(
 524     HRAWINPUT hRawInput,
 525     UINT uiCommand,
 526     LPVOID pData,
 527     PUINT pcbSize,
 528     UINT cbSizeHeader)
 529 {
 530     STUB;
 531     return 0;
 532 }
 533
 534 DWORD
 535 APIENTRY
 536 NtUserGetRawInputDeviceInfo(
 537     HANDLE hDevice,
 538     UINT uiCommand,
 539     LPVOID pData,
 540     PUINT pcbSize
 541 )
 542 {
 543     STUB;
 544     return 0;
 545 }
 546
 547 DWORD
 548 APIENTRY
 549 NtUserGetRawInputDeviceList(
 550     PRAWINPUTDEVICELIST pRawInputDeviceList,
 551     PUINT puiNumDevices,
 552     UINT cbSize)
 553 {
 554     STUB;
 555     return 0;
 556 }
 557
 558 DWORD
 559 APIENTRY
 560 NtUserGetRegisteredRawInputDevices(
 561     PRAWINPUTDEVICE pRawInputDevices,
 562     PUINT puiNumDevices,
 563     UINT cbSize)
 564 {
 565     STUB;
 566     return 0;
 567 }
 568
 569 DWORD
 570 APIENTRY
 571 NtUserHardErrorControl(
 572     DWORD dwUnknown1,
 573     DWORD dwUnknown2,
 574     DWORD dwUnknown3)
 575 {
 576     STUB;
 577     return 0;
 578 }
 579
 580 BOOL
 581 NTAPI
 582 NtUserNotifyProcessCreate(
 583     HANDLE NewProcessId,
 584     HANDLE ParentThreadId,
 585     ULONG  dwUnknown,
 586     ULONG  CreateFlags)
 587 {
 588     // STUB;
 589     TRACE("NtUserNotifyProcessCreate is UNIMPLEMENTED\n");
 590     return FALSE;
 591 }
 592
 593 NTSTATUS
 594 APIENTRY
 595 NtUserProcessConnect(
 596     IN  HANDLE ProcessHandle,
 597     OUT PUSERCONNECT pUserConnect,
 598     IN  ULONG Size)
 599 {
 600     NTSTATUS Status;
 601     PEPROCESS Process = NULL;
 602     PPROCESSINFO W32Process;
 603
 604     TRACE("NtUserProcessConnect\n");
 605
 606     if ( pUserConnect == NULL ||
 607          Size         != sizeof(*pUserConnect) )
 608     {
 609         return STATUS_UNSUCCESSFUL;
 610     }
 611
 612     /* Get the process object the user handle was referencing */
 613     Status = ObReferenceObjectByHandle(ProcessHandle,
 614                                        PROCESS_VM_OPERATION,
 615                                        *PsProcessType,
 616                                        UserMode,
 617                                        (PVOID*)&Process,
 618                                        NULL);
 619     if (!NT_SUCCESS(Status)) return Status;
 620
 621     UserEnterShared();
 622
 623     /* Get Win32 process information */
 624     W32Process = PsGetProcessWin32Process(Process);
 625
 626     _SEH2_TRY
 627     {
 628         // FIXME: Check that pUserConnect->ulVersion == USER_VERSION;
 629
 630         ProbeForWrite(pUserConnect, sizeof(*pUserConnect), sizeof(PVOID));
 631         pUserConnect->siClient.psi = gpsi;
 632         pUserConnect->siClient.aheList = gHandleTable;
 633         pUserConnect->siClient.ulSharedDelta =
 634             (ULONG_PTR)W32Process->HeapMappings.KernelMapping -
 635             (ULONG_PTR)W32Process->HeapMappings.UserMapping;
 636     }
 637     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 638     {
 639         Status = _SEH2_GetExceptionCode();
 640     }
 641     _SEH2_END;
 642
 643     if (!NT_SUCCESS(Status))
 644         SetLastNtError(Status);
 645
 646     UserLeave();
 647
 648     /* Dereference the process object */
 649     ObDereferenceObject(Process);
 650
 651     return Status;
 652 }
 653
 654 NTSTATUS
 655 APIENTRY
 656 NtUserQueryInformationThread(IN HANDLE ThreadHandle,
 657                              IN USERTHREADINFOCLASS ThreadInformationClass,
 658                              OUT PVOID ThreadInformation,
 659                              IN ULONG ThreadInformationLength)
 660 {
 661     NTSTATUS Status = STATUS_SUCCESS;
 662     PETHREAD Thread;
 663
 664     /* Allow only CSRSS to perform this operation */
 665     if (PsGetCurrentProcess() != gpepCSRSS)
 666         return STATUS_ACCESS_DENIED;
 667
 668     UserEnterExclusive();
 669
 670     /* Get the Thread */
 671     Status = ObReferenceObjectByHandle(ThreadHandle,
 672                                        THREAD_QUERY_INFORMATION,
 673                                        *PsThreadType,
 674                                        UserMode,
 675                                        (PVOID)&Thread,
 676                                        NULL);
 677     if (!NT_SUCCESS(Status)) goto Quit;
 678
 679     switch (ThreadInformationClass)
 680     {
 681         default:
 682         {
 683             STUB;
 684             Status = STATUS_NOT_IMPLEMENTED;
 685             break;
 686         }
 687     }
 688
 689     ObDereferenceObject(Thread);
 690
 691 Quit:
 692     UserLeave();
 693     return Status;
 694 }
 695
 696 DWORD
 697 APIENTRY
 698 NtUserQueryInputContext(
 699     DWORD dwUnknown1,
 700     DWORD dwUnknown2)
 701 {
 702     STUB;
 703     return 0;
 704 }
 705
 706 BOOL
 707 APIENTRY
 708 NtUserRealInternalGetMessage(
 709     LPMSG lpMsg,
 710     HWND hWnd,
 711     UINT wMsgFilterMin,
 712     UINT wMsgFilterMax,
 713     UINT wRemoveMsg,
 714     BOOL bGMSG)
 715 {
 716     STUB;
 717     return 0;
 718 }
 719
 720 BOOL
 721 APIENTRY
 722 NtUserRealWaitMessageEx(
 723     DWORD dwWakeMask,
 724     UINT uTimeout)
 725 {
 726     STUB;
 727     return 0;
 728 }
 729
 730 BOOL
 731 APIENTRY
 732 NtUserRegisterRawInputDevices(
 733     IN PCRAWINPUTDEVICE pRawInputDevices,
 734     IN UINT uiNumDevices,
 735     IN UINT cbSize)
 736 {
 737     STUB;
 738     return 0;
 739 }
 740
 741 DWORD
 742 APIENTRY
 743 NtUserResolveDesktop(
 744     DWORD dwUnknown1,
 745     DWORD dwUnknown2,
 746     DWORD dwUnknown3,
 747     DWORD dwUnknown4)
 748 {
 749     STUB;
 750     return 0;
 751 }
 752
 753 DWORD
 754 APIENTRY
 755 NtUserSetInformationProcess(
 756     DWORD dwUnknown1,
 757     DWORD dwUnknown2,
 758     DWORD dwUnknown3,
 759     DWORD dwUnknown4)
 760 {
 761     STUB;
 762     return 0;
 763 }
 764
 765 NTSTATUS
 766 APIENTRY
 767 NtUserSetInformationThread(IN HANDLE ThreadHandle,
 768                            IN USERTHREADINFOCLASS ThreadInformationClass,
 769                            IN PVOID ThreadInformation,
 770                            IN ULONG ThreadInformationLength)
 771 {
 772     NTSTATUS Status = STATUS_SUCCESS;
 773     PETHREAD Thread;
 774
 775     /* Allow only CSRSS to perform this operation */
 776     if (PsGetCurrentProcess() != gpepCSRSS)
 777         return STATUS_ACCESS_DENIED;
 778
 779     UserEnterExclusive();
 780
 781     /* Get the Thread */
 782     Status = ObReferenceObjectByHandle(ThreadHandle,
 783                                        THREAD_SET_INFORMATION,
 784                                        *PsThreadType,
 785                                        UserMode,
 786                                        (PVOID)&Thread,
 787                                        NULL);
 788     if (!NT_SUCCESS(Status)) goto Quit;
 789
 790     switch (ThreadInformationClass)
 791     {
 792         case UserThreadInitiateShutdown:
 793         {
 794             ULONG CapturedFlags = 0;
 795
 796             ERR("Shutdown initiated\n");
 797
 798             if (ThreadInformationLength != sizeof(ULONG))
 799             {
 800                 Status = STATUS_INFO_LENGTH_MISMATCH;
 801                 break;
 802             }
 803
 804             /* Capture the caller value */
 805             Status = STATUS_SUCCESS;
 806             _SEH2_TRY
 807             {
 808                 ProbeForWrite(ThreadInformation, sizeof(CapturedFlags), sizeof(PVOID));
 809                 CapturedFlags = *(PULONG)ThreadInformation;
 810             }
 811             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 812             {
 813                 Status = _SEH2_GetExceptionCode();
 814             }
 815             _SEH2_END;
 816
 817             if (NT_SUCCESS(Status))
 818                 Status = UserInitiateShutdown(Thread, &CapturedFlags);
 819
 820             /* Return the modified value to the caller */
 821             _SEH2_TRY
 822             {
 823                 *(PULONG)ThreadInformation = CapturedFlags;
 824             }
 825             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 826             {
 827                 Status = _SEH2_GetExceptionCode();
 828             }
 829             _SEH2_END;
 830
 831             break;
 832         }
 833
 834         case UserThreadEndShutdown:
 835         {
 836             NTSTATUS ShutdownStatus;
 837
 838             ERR("Shutdown ended\n");
 839
 840             if (ThreadInformationLength != sizeof(ShutdownStatus))
 841             {
 842                 Status = STATUS_INFO_LENGTH_MISMATCH;
 843                 break;
 844             }
 845
 846             /* Capture the caller value */
 847             Status = STATUS_SUCCESS;
 848             _SEH2_TRY
 849             {
 850                 ProbeForRead(ThreadInformation, sizeof(ShutdownStatus), sizeof(PVOID));
 851                 ShutdownStatus = *(NTSTATUS*)ThreadInformation;
 852             }
 853             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 854             {
 855                 Status = _SEH2_GetExceptionCode();
 856             }
 857             _SEH2_END;
 858
 859             if (NT_SUCCESS(Status))
 860                 Status = UserEndShutdown(Thread, ShutdownStatus);
 861
 862             break;
 863         }
 864
 865         case UserThreadCsrApiPort:
 866         {
 867             HANDLE CsrPortHandle;
 868
 869             ERR("Set CSR API Port for Win32k\n");
 870
 871             if (ThreadInformationLength != sizeof(CsrPortHandle))
 872             {
 873                 Status = STATUS_INFO_LENGTH_MISMATCH;
 874                 break;
 875             }
 876
 877             /* Capture the caller value */
 878             Status = STATUS_SUCCESS;
 879             _SEH2_TRY
 880             {
 881                 ProbeForRead(ThreadInformation, sizeof(CsrPortHandle), sizeof(PVOID));
 882                 CsrPortHandle = *(PHANDLE)ThreadInformation;
 883             }
 884             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 885             {
 886                 Status = _SEH2_GetExceptionCode();
 887             }
 888             _SEH2_END;
 889
 890             if (NT_SUCCESS(Status))
 891                 Status = InitCsrApiPort(CsrPortHandle);
 892
 893             break;
 894         }
 895
 896         default:
 897         {
 898             STUB;
 899             Status = STATUS_NOT_IMPLEMENTED;
 900             break;
 901         }
 902     }
 903
 904     ObDereferenceObject(Thread);
 905
 906 Quit:
 907     UserLeave();
 908     return Status;
 909 }
 910
 911 DWORD
 912 APIENTRY
 913 NtUserSetThreadLayoutHandles(
 914     DWORD dwUnknown1,
 915     DWORD dwUnknown2)
 916 {
 917     STUB;
 918     return 0;
 919 }
 920
 921 BOOL
 922 APIENTRY
 923 NtUserSoundSentry(VOID)
 924 {
 925     STUB;
 926     return 0;
 927 }
 928
 929 DWORD
 930 APIENTRY
 931 NtUserTestForInteractiveUser(
 932     DWORD dwUnknown1)
 933 {
 934     STUB;
 935     return 0;
 936 }
 937
 938 /* http://www.cyber-ta.org/releases/malware-analysis/public/SOURCES/b47155634ccb2c30630da7e3666d3d07/b47155634ccb2c30630da7e3666d3d07.trace.html#NtUserGetIconSize */
 939 DWORD
 940 APIENTRY
 941 NtUserCalcMenuBar(
 942     DWORD dwUnknown1,
 943     DWORD dwUnknown2,
 944     DWORD dwUnknown3,
 945     DWORD dwUnknown4,
 946     DWORD dwUnknown5)
 947 {
 948     STUB;
 949     return 0;
 950 }
 951
 952 DWORD
 953 APIENTRY
 954 NtUserPaintMenuBar(
 955     DWORD dwUnknown1,
 956     DWORD dwUnknown2,
 957     DWORD dwUnknown3,
 958     DWORD dwUnknown4,
 959     DWORD dwUnknown5,
 960     DWORD dwUnknown6)
 961 {
 962     STUB;
 963     return 0;
 964 }
 965
 966
 967 DWORD
 968 APIENTRY
 969 NtUserRemoteConnect(
 970     DWORD dwUnknown1,
 971     DWORD dwUnknown2,
 972     DWORD dwUnknown3)
 973 {
 974     STUB;
 975     return 0;
 976 }
 977
 978 DWORD
 979 APIENTRY
 980 NtUserRemoteRedrawRectangle(
 981     DWORD dwUnknown1,
 982     DWORD dwUnknown2,
 983     DWORD dwUnknown3,
 984     DWORD dwUnknown4)
 985 {
 986     STUB;
 987     return 0;
 988 }
 989
 990 DWORD
 991 APIENTRY
 992 NtUserRemoteRedrawScreen(VOID)
 993 {
 994     STUB;
 995     return 0;
 996 }
 997
 998 DWORD
 999 APIENTRY
1000 NtUserRemoteStopScreenUpdates(VOID)
1001 {
1002     STUB;
1003     return 0;
1004 }
1005
1006 DWORD
1007 APIENTRY
1008 NtUserCtxDisplayIOCtl(
1009     DWORD dwUnknown1,
1010     DWORD dwUnknown2,
1011     DWORD dwUnknown3)
1012 {
1013     STUB;
1014     return 0;
1015 }
1016
1017 /*
1018  * @unimplemented
1019  */
1020 DWORD
1021 APIENTRY
1022 NtUserDrawMenuBarTemp(
1023    HWND hWnd,
1024    HDC hDC,
1025    PRECT hRect,
1026    HMENU hMenu,
1027    HFONT hFont)
1028 {
1029    /* We'll use this function just for caching the menu bar */
1030    STUB
1031    return 0;
1032 }
1033
1034 /*
1035  * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
1036  */
1037 /*
1038  * @unimplemented
1039  */
1040 BOOL APIENTRY
1041 NtUserFillWindow(HWND hWndPaint,
1042                  HWND hWndPaint1,
1043                  HDC  hDC,
1044                  HBRUSH hBrush)
1045 {
1046    STUB
1047
1048    return 0;
1049 }
1050
1051 /*
1052  * @unimplemented
1053  */
1054 BOOL APIENTRY
1055 NtUserLockWindowUpdate(HWND hWnd)
1056 {
1057    STUB
1058
1059    return 0;
1060 }
1061
1062 BOOL
1063 APIENTRY
1064 NtUserGetLayeredWindowAttributes(
1065     HWND hwnd,
1066     COLORREF *pcrKey,
1067     BYTE *pbAlpha,
1068     DWORD *pdwFlags)
1069 {
1070     STUB;
1071     return 0;
1072 }
1073
1074 /*
1075  * @unimplemented
1076  */
1077 BOOL APIENTRY
1078 NtUserSetLayeredWindowAttributes(HWND hwnd,
1079                            COLORREF crKey,
1080                            BYTE bAlpha,
1081                            DWORD dwFlags)
1082 {
1083   STUB;
1084   return FALSE;
1085 }
1086
1087 /*
1088  * @unimplemented
1089  */
1090 BOOL
1091 APIENTRY
1092 NtUserUpdateLayeredWindow(
1093    HWND hwnd,
1094    HDC hdcDst,
1095    POINT *pptDst,
1096    SIZE *psize,
1097    HDC hdcSrc,
1098    POINT *pptSrc,
1099    COLORREF crKey,
1100    BLENDFUNCTION *pblend,
1101    DWORD dwFlags,
1102    RECT *prcDirty)
1103 {
1104    STUB
1105
1106    return 0;
1107 }
1108
1109 /*
1110  * NtUserResolveDesktopForWOW
1111  *
1112  * Status
1113  *    @unimplemented
1114  */
1115
1116 DWORD APIENTRY
1117 NtUserResolveDesktopForWOW(DWORD Unknown0)
1118 {
1119    STUB
1120    return 0;
1121 }
1122
1123 /*
1124  * @unimplemented
1125  */
1126 BOOL APIENTRY
1127 NtUserEndMenu(VOID)
1128 {
1129    STUB
1130
1131    return 0;
1132 }
1133
1134 /*
1135  * @implemented
1136  */
1137 /* NOTE: unused function */
1138 BOOL APIENTRY
1139 NtUserTrackPopupMenuEx(
1140    HMENU hMenu,
1141    UINT fuFlags,
1142    int x,
1143    int y,
1144    HWND hWnd,
1145    LPTPMPARAMS lptpm)
1146 {
1147    STUB
1148
1149    return FALSE;
1150 }
1151
1152 DWORD APIENTRY
1153 NtUserQuerySendMessage(DWORD Unknown0)
1154 {
1155     STUB;
1156
1157     return 0;
1158 }
1159
1160 BOOL APIENTRY NtUserAddClipboardFormatListener(
1161     HWND hwnd
1162 )
1163 {
1164     STUB;
1165     return FALSE;
1166 }
1167
1168 BOOL APIENTRY NtUserRemoveClipboardFormatListener(
1169     HWND hwnd
1170 )
1171 {
1172     STUB;
1173     return FALSE;
1174 }
1175
1176 BOOL APIENTRY NtUserGetUpdatedClipboardFormats(
1177     PUINT lpuiFormats,
1178     UINT cFormats,
1179     PUINT pcFormatsOut
1180 )
1181 {
1182     STUB;
1183     return FALSE;
1184 }
1185
1186 /* EOF */