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 BOOL
 108 APIENTRY
 109 NtUserGetAltTabInfo(
 110    HWND hwnd,
 111    INT  iItem,
 112    PALTTABINFO pati,
 113    LPWSTR pszItemText,
 114    UINT   cchItemText,
 115    BOOL   Ansi)
 116 {
 117    STUB
 118
 119    return 0;
 120 }
 121
 122 NTSTATUS
 123 APIENTRY
 124 NtUserInitializeClientPfnArrays(
 125   PPFNCLIENT pfnClientA,
 126   PPFNCLIENT pfnClientW,
 127   PPFNCLIENTWORKER pfnClientWorker,
 128   HINSTANCE hmodUser)
 129 {
 130    NTSTATUS Status = STATUS_SUCCESS;
 131    TRACE("Enter NtUserInitializeClientPfnArrays User32 0x%p\n", hmodUser);
 132
 133    if (ClientPfnInit) return Status;
 134
 135    UserEnterExclusive();
 136
 137    _SEH2_TRY
 138    {
 139       ProbeForRead( pfnClientA, sizeof(PFNCLIENT), 1);
 140       ProbeForRead( pfnClientW, sizeof(PFNCLIENT), 1);
 141       ProbeForRead( pfnClientWorker, sizeof(PFNCLIENTWORKER), 1);
 142       RtlCopyMemory(&gpsi->apfnClientA, pfnClientA, sizeof(PFNCLIENT));
 143       RtlCopyMemory(&gpsi->apfnClientW, pfnClientW, sizeof(PFNCLIENT));
 144       RtlCopyMemory(&gpsi->apfnClientWorker, pfnClientWorker, sizeof(PFNCLIENTWORKER));
 145
 146       //// FIXME: HAX! Temporary until server side is finished.
 147       //// Copy the client side procs for now.
 148       RtlCopyMemory(&gpsi->aStoCidPfn, pfnClientW, sizeof(gpsi->aStoCidPfn));
 149
 150       hModClient = hmodUser;
 151       ClientPfnInit = TRUE;
 152    }
 153    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 154    {
 155       Status =_SEH2_GetExceptionCode();
 156    }
 157    _SEH2_END
 158
 159    if (!NT_SUCCESS(Status))
 160    {
 161       ERR("Failed reading Client Pfns from user space.\n");
 162       SetLastNtError(Status);
 163    }
 164
 165    UserLeave();
 166    return Status;
 167 }
 168
 169 DWORD
 170 APIENTRY
 171 NtUserInitTask(
 172    DWORD Unknown0,
 173    DWORD Unknown1,
 174    DWORD Unknown2,
 175    DWORD Unknown3,
 176    DWORD Unknown4,
 177    DWORD Unknown5,
 178    DWORD Unknown6,
 179    DWORD Unknown7,
 180    DWORD Unknown8,
 181    DWORD Unknown9,
 182    DWORD Unknown10,
 183    DWORD Unknown11)
 184 {
 185    STUB
 186
 187    return 0;
 188 }
 189
 190 DWORD
 191 APIENTRY
 192 NtUserMNDragLeave(VOID)
 193 {
 194    STUB
 195
 196    return 0;
 197 }
 198
 199 DWORD
 200 APIENTRY
 201 NtUserMNDragOver(
 202    DWORD Unknown0,
 203    DWORD Unknown1)
 204 {
 205    STUB
 206
 207    return 0;
 208 }
 209
 210 DWORD
 211 APIENTRY
 212 NtUserModifyUserStartupInfoFlags(
 213    DWORD Unknown0,
 214    DWORD Unknown1)
 215 {
 216    STUB
 217
 218    return 0;
 219 }
 220
 221 DWORD
 222 APIENTRY
 223 NtUserQueryUserCounters(
 224    DWORD Unknown0,
 225    DWORD Unknown1,
 226    DWORD Unknown2,
 227    DWORD Unknown3,
 228    DWORD Unknown4)
 229 {
 230    STUB
 231
 232    return 0;
 233 }
 234
 235 DWORD
 236 APIENTRY
 237 NtUserRegisterTasklist(
 238    DWORD Unknown0)
 239 {
 240    STUB
 241
 242    return 0;
 243 }
 244
 245 DWORD
 246 APIENTRY
 247 NtUserSetConsoleReserveKeys(
 248    DWORD Unknown0,
 249    DWORD Unknown1)
 250 {
 251    STUB
 252
 253    return 0;
 254 }
 255
 256 DWORD
 257 APIENTRY
 258 NtUserSetDbgTag(
 259    DWORD Unknown0,
 260    DWORD Unknown1)
 261 {
 262    STUB;
 263
 264    return 0;
 265 }
 266
 267 DWORD
 268 APIENTRY
 269 NtUserSetDbgTagCount(
 270     DWORD Unknown0)
 271 {
 272     STUB;
 273
 274     return 0;
 275 }
 276
 277 DWORD
 278 APIENTRY
 279 NtUserSetRipFlags(
 280    DWORD Unknown0)
 281 {
 282    STUB;
 283
 284    return 0;
 285 }
 286
 287 DWORD
 288 APIENTRY
 289 NtUserDbgWin32HeapFail(
 290     DWORD Unknown0,
 291     DWORD Unknown1)
 292 {
 293    STUB
 294
 295    return 0;
 296 }
 297
 298 DWORD
 299 APIENTRY
 300 NtUserDbgWin32HeapStat(
 301     DWORD Unknown0,
 302     DWORD Unknown1)
 303 {
 304    STUB
 305
 306    return 0;
 307 }
 308
 309 BOOL
 310 APIENTRY
 311 NtUserSetSysColors(
 312    int cElements,
 313    IN CONST INT *lpaElements,
 314    IN CONST COLORREF *lpaRgbValues,
 315    FLONG Flags)
 316 {
 317    DWORD Ret = TRUE;
 318
 319    if (cElements == 0)
 320       return TRUE;
 321
 322    /* We need this check to prevent overflow later */
 323    if ((ULONG)cElements >= 0x40000000)
 324    {
 325       EngSetLastError(ERROR_NOACCESS);
 326       return FALSE;
 327    }
 328
 329    UserEnterExclusive();
 330
 331    _SEH2_TRY
 332    {
 333       ProbeForRead(lpaElements, cElements * sizeof(INT), 1);
 334       ProbeForRead(lpaRgbValues, cElements * sizeof(COLORREF), 1);
 335
 336       IntSetSysColors(cElements, lpaElements, lpaRgbValues);
 337    }
 338    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 339    {
 340       SetLastNtError(_SEH2_GetExceptionCode());
 341       Ret = FALSE;
 342    }
 343    _SEH2_END;
 344
 345    if (Ret)
 346    {
 347       UserSendNotifyMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
 348
 349       UserRedrawDesktop();
 350    }
 351
 352    UserLeave();
 353    return Ret;
 354 }
 355
 356 DWORD
 357 APIENTRY
 358 NtUserUpdateInputContext(
 359    DWORD Unknown0,
 360    DWORD Unknown1,
 361    DWORD Unknown2)
 362 {
 363    STUB
 364
 365    return 0;
 366 }
 367
 368 DWORD
 369 APIENTRY
 370 NtUserUpdateInstance(
 371    DWORD Unknown0,
 372    DWORD Unknown1,
 373    DWORD Unknown2)
 374 {
 375    STUB
 376
 377    return 0;
 378 }
 379
 380 BOOL
 381 APIENTRY
 382 NtUserUserHandleGrantAccess(
 383    IN HANDLE hUserHandle,
 384    IN HANDLE hJob,
 385    IN BOOL bGrant)
 386 {
 387    STUB
 388
 389    return 0;
 390 }
 391
 392 DWORD
 393 APIENTRY
 394 NtUserWaitForMsgAndEvent(
 395    DWORD Unknown0)
 396 {
 397    STUB
 398
 399    return 0;
 400 }
 401
 402 DWORD
 403 APIENTRY
 404 NtUserWin32PoolAllocationStats(
 405    DWORD Unknown0,
 406    DWORD Unknown1,
 407    DWORD Unknown2,
 408    DWORD Unknown3,
 409    DWORD Unknown4,
 410    DWORD Unknown5)
 411 {
 412    STUB
 413
 414    return 0;
 415 }
 416
 417 DWORD
 418 APIENTRY
 419 NtUserYieldTask(VOID)
 420 {
 421    STUB
 422
 423    return 0;
 424 }
 425
 426 DWORD
 427 APIENTRY
 428 NtUserCreateInputContext(
 429     DWORD dwUnknown1)
 430 {
 431     STUB;
 432     return 0;
 433 }
 434
 435 DWORD
 436 APIENTRY
 437 NtUserDestroyInputContext(
 438     DWORD dwUnknown1)
 439 {
 440     STUB;
 441     return 0;
 442 }
 443
 444 DWORD
 445 APIENTRY
 446 NtUserGetRawInputBuffer(
 447     PRAWINPUT pData,
 448     PUINT pcbSize,
 449     UINT cbSizeHeader)
 450 {
 451     STUB;
 452     return 0;
 453 }
 454
 455 DWORD
 456 APIENTRY
 457 NtUserGetRawInputData(
 458     HRAWINPUT hRawInput,
 459     UINT uiCommand,
 460     LPVOID pData,
 461     PUINT pcbSize,
 462     UINT cbSizeHeader)
 463 {
 464     STUB;
 465     return 0;
 466 }
 467
 468 DWORD
 469 APIENTRY
 470 NtUserGetRawInputDeviceInfo(
 471     HANDLE hDevice,
 472     UINT uiCommand,
 473     LPVOID pData,
 474     PUINT pcbSize
 475 )
 476 {
 477     STUB;
 478     return 0;
 479 }
 480
 481 DWORD
 482 APIENTRY
 483 NtUserGetRawInputDeviceList(
 484     PRAWINPUTDEVICELIST pRawInputDeviceList,
 485     PUINT puiNumDevices,
 486     UINT cbSize)
 487 {
 488     STUB;
 489     return 0;
 490 }
 491
 492 DWORD
 493 APIENTRY
 494 NtUserGetRegisteredRawInputDevices(
 495     PRAWINPUTDEVICE pRawInputDevices,
 496     PUINT puiNumDevices,
 497     UINT cbSize)
 498 {
 499     STUB;
 500     return 0;
 501 }
 502
 503 DWORD
 504 APIENTRY
 505 NtUserHardErrorControl(
 506     DWORD dwUnknown1,
 507     DWORD dwUnknown2,
 508     DWORD dwUnknown3)
 509 {
 510     STUB;
 511     return 0;
 512 }
 513
 514 BOOL
 515 NTAPI
 516 NtUserNotifyProcessCreate(
 517     HANDLE NewProcessId,
 518     HANDLE ParentThreadId,
 519     ULONG  dwUnknown,
 520     ULONG  CreateFlags)
 521 {
 522     // STUB;
 523     TRACE("NtUserNotifyProcessCreate is UNIMPLEMENTED\n");
 524     return FALSE;
 525 }
 526
 527 NTSTATUS
 528 APIENTRY
 529 NtUserProcessConnect(
 530     IN  HANDLE ProcessHandle,
 531     OUT PUSERCONNECT pUserConnect,
 532     IN  ULONG Size)
 533 {
 534     NTSTATUS Status;
 535     PEPROCESS Process = NULL;
 536     PPROCESSINFO W32Process;
 537
 538     TRACE("NtUserProcessConnect\n");
 539
 540     if ( pUserConnect == NULL ||
 541          Size         != sizeof(*pUserConnect) )
 542     {
 543         return STATUS_UNSUCCESSFUL;
 544     }
 545
 546     /* Get the process object the user handle was referencing */
 547     Status = ObReferenceObjectByHandle(ProcessHandle,
 548                                        PROCESS_VM_OPERATION,
 549                                        *PsProcessType,
 550                                        UserMode,
 551                                        (PVOID*)&Process,
 552                                        NULL);
 553     if (!NT_SUCCESS(Status)) return Status;
 554
 555     UserEnterShared();
 556
 557     /* Get Win32 process information */
 558     W32Process = PsGetProcessWin32Process(Process);
 559
 560     _SEH2_TRY
 561     {
 562         // FIXME: Check that pUserConnect->ulVersion == USER_VERSION;
 563
 564         ProbeForWrite(pUserConnect, sizeof(*pUserConnect), sizeof(PVOID));
 565         pUserConnect->siClient.psi = gpsi;
 566         pUserConnect->siClient.aheList = gHandleTable;
 567         pUserConnect->siClient.ulSharedDelta =
 568             (ULONG_PTR)W32Process->HeapMappings.KernelMapping -
 569             (ULONG_PTR)W32Process->HeapMappings.UserMapping;
 570     }
 571     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 572     {
 573         Status = _SEH2_GetExceptionCode();
 574     }
 575     _SEH2_END;
 576
 577     if (!NT_SUCCESS(Status))
 578         SetLastNtError(Status);
 579
 580     UserLeave();
 581
 582     /* Dereference the process object */
 583     ObDereferenceObject(Process);
 584
 585     return Status;
 586 }
 587
 588 NTSTATUS
 589 APIENTRY
 590 NtUserQueryInformationThread(IN HANDLE ThreadHandle,
 591                              IN USERTHREADINFOCLASS ThreadInformationClass,
 592                              OUT PVOID ThreadInformation,
 593                              IN ULONG ThreadInformationLength)
 594 {
 595     NTSTATUS Status = STATUS_SUCCESS;
 596     PETHREAD Thread;
 597
 598     /* Allow only CSRSS to perform this operation */
 599     if (PsGetCurrentProcess() != gpepCSRSS)
 600         return STATUS_ACCESS_DENIED;
 601
 602     UserEnterExclusive();
 603
 604     /* Get the Thread */
 605     Status = ObReferenceObjectByHandle(ThreadHandle,
 606                                        THREAD_QUERY_INFORMATION,
 607                                        *PsThreadType,
 608                                        UserMode,
 609                                        (PVOID)&Thread,
 610                                        NULL);
 611     if (!NT_SUCCESS(Status)) goto Quit;
 612
 613     switch (ThreadInformationClass)
 614     {
 615         default:
 616         {
 617             STUB;
 618             Status = STATUS_NOT_IMPLEMENTED;
 619             break;
 620         }
 621     }
 622
 623     ObDereferenceObject(Thread);
 624
 625 Quit:
 626     UserLeave();
 627     return Status;
 628 }
 629
 630 DWORD
 631 APIENTRY
 632 NtUserQueryInputContext(
 633     DWORD dwUnknown1,
 634     DWORD dwUnknown2)
 635 {
 636     STUB;
 637     return 0;
 638 }
 639
 640 BOOL
 641 APIENTRY
 642 NtUserRealInternalGetMessage(
 643     LPMSG lpMsg,
 644     HWND hWnd,
 645     UINT wMsgFilterMin,
 646     UINT wMsgFilterMax,
 647     UINT wRemoveMsg,
 648     BOOL bGMSG)
 649 {
 650     STUB;
 651     return 0;
 652 }
 653
 654 BOOL
 655 APIENTRY
 656 NtUserRealWaitMessageEx(
 657     DWORD dwWakeMask,
 658     UINT uTimeout)
 659 {
 660     STUB;
 661     return 0;
 662 }
 663
 664 BOOL
 665 APIENTRY
 666 NtUserRegisterRawInputDevices(
 667     IN PCRAWINPUTDEVICE pRawInputDevices,
 668     IN UINT uiNumDevices,
 669     IN UINT cbSize)
 670 {
 671     STUB;
 672     return 0;
 673 }
 674
 675 DWORD APIENTRY
 676 NtUserResolveDesktopForWOW(DWORD Unknown0)
 677 {
 678     STUB
 679     return 0;
 680 }
 681
 682 DWORD
 683 APIENTRY
 684 NtUserSetInformationProcess(
 685     DWORD dwUnknown1,
 686     DWORD dwUnknown2,
 687     DWORD dwUnknown3,
 688     DWORD dwUnknown4)
 689 {
 690     STUB;
 691     return 0;
 692 }
 693
 694 HDESK FASTCALL
 695 IntGetDesktopObjectHandle(PDESKTOP DesktopObject);
 696
 697 NTSTATUS
 698 APIENTRY
 699 NtUserSetInformationThread(IN HANDLE ThreadHandle,
 700                            IN USERTHREADINFOCLASS ThreadInformationClass,
 701                            IN PVOID ThreadInformation,
 702                            IN ULONG ThreadInformationLength)
 703 {
 704     NTSTATUS Status = STATUS_SUCCESS;
 705     PETHREAD Thread;
 706
 707     /* Allow only CSRSS to perform this operation */
 708     if (PsGetCurrentProcess() != gpepCSRSS)
 709         return STATUS_ACCESS_DENIED;
 710
 711     UserEnterExclusive();
 712
 713     /* Get the Thread */
 714     Status = ObReferenceObjectByHandle(ThreadHandle,
 715                                        THREAD_SET_INFORMATION,
 716                                        *PsThreadType,
 717                                        UserMode,
 718                                        (PVOID)&Thread,
 719                                        NULL);
 720     if (!NT_SUCCESS(Status)) goto Quit;
 721
 722     switch (ThreadInformationClass)
 723     {
 724         case UserThreadInitiateShutdown:
 725         {
 726             ULONG CapturedFlags = 0;
 727
 728             TRACE("Shutdown initiated\n");
 729
 730             if (ThreadInformationLength != sizeof(ULONG))
 731             {
 732                 Status = STATUS_INFO_LENGTH_MISMATCH;
 733                 break;
 734             }
 735
 736             /* Capture the caller value */
 737             Status = STATUS_SUCCESS;
 738             _SEH2_TRY
 739             {
 740                 ProbeForWrite(ThreadInformation, sizeof(CapturedFlags), sizeof(PVOID));
 741                 CapturedFlags = *(PULONG)ThreadInformation;
 742             }
 743             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 744             {
 745                 Status = _SEH2_GetExceptionCode();
 746                 _SEH2_YIELD(break);
 747             }
 748             _SEH2_END;
 749
 750             Status = UserInitiateShutdown(Thread, &CapturedFlags);
 751
 752             /* Return the modified value to the caller */
 753             _SEH2_TRY
 754             {
 755                 *(PULONG)ThreadInformation = CapturedFlags;
 756             }
 757             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 758             {
 759                 Status = _SEH2_GetExceptionCode();
 760             }
 761             _SEH2_END;
 762
 763             break;
 764         }
 765
 766         case UserThreadEndShutdown:
 767         {
 768             NTSTATUS ShutdownStatus;
 769
 770             TRACE("Shutdown ended\n");
 771
 772             if (ThreadInformationLength != sizeof(ShutdownStatus))
 773             {
 774                 Status = STATUS_INFO_LENGTH_MISMATCH;
 775                 break;
 776             }
 777
 778             /* Capture the caller value */
 779             Status = STATUS_SUCCESS;
 780             _SEH2_TRY
 781             {
 782                 ProbeForRead(ThreadInformation, sizeof(ShutdownStatus), sizeof(PVOID));
 783                 ShutdownStatus = *(NTSTATUS*)ThreadInformation;
 784             }
 785             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 786             {
 787                 Status = _SEH2_GetExceptionCode();
 788                 _SEH2_YIELD(break);
 789             }
 790             _SEH2_END;
 791
 792             Status = UserEndShutdown(Thread, ShutdownStatus);
 793             break;
 794         }
 795
 796         case UserThreadCsrApiPort:
 797         {
 798             HANDLE CsrPortHandle;
 799
 800
 801             TRACE("Set CSR API Port for Win32k\n");
 802             if (ThreadInformationLength != sizeof(CsrPortHandle))
 803             {
 804                 Status = STATUS_INFO_LENGTH_MISMATCH;
 805                 break;
 806             }
 807
 808             /* Capture the caller value */
 809             Status = STATUS_SUCCESS;
 810             _SEH2_TRY
 811             {
 812                 ProbeForRead(ThreadInformation, sizeof(CsrPortHandle), sizeof(PVOID));
 813                 CsrPortHandle = *(PHANDLE)ThreadInformation;
 814             }
 815             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 816             {
 817                 Status = _SEH2_GetExceptionCode();
 818                 _SEH2_YIELD(break);
 819             }
 820             _SEH2_END;
 821
 822             Status = InitCsrApiPort(CsrPortHandle);
 823             break;
 824         }
 825
 826         case UserThreadUseActiveDesktop:
 827         {
 828             HDESK hdesk;
 829
 830             if (Thread != PsGetCurrentThread())
 831             {
 832                 Status = STATUS_NOT_IMPLEMENTED;
 833                 break;
 834             }
 835
 836             hdesk = IntGetDesktopObjectHandle(gpdeskInputDesktop);
 837             IntSetThreadDesktop(hdesk, FALSE);
 838
 839             break;
 840         }
 841         case UserThreadRestoreDesktop:
 842         {
 843             if (Thread != PsGetCurrentThread())
 844             {
 845                 Status = STATUS_NOT_IMPLEMENTED;
 846                 break;
 847             }
 848
 849             IntSetThreadDesktop(NULL, FALSE);
 850             break;
 851         }
 852         default:
 853         {
 854             STUB;
 855             Status = STATUS_NOT_IMPLEMENTED;
 856             break;
 857         }
 858     }
 859
 860     ObDereferenceObject(Thread);
 861
 862 Quit:
 863     UserLeave();
 864     return Status;
 865 }
 866
 867 DWORD
 868 APIENTRY
 869 NtUserSetThreadLayoutHandles(
 870     DWORD dwUnknown1,
 871     DWORD dwUnknown2)
 872 {
 873     STUB;
 874     return 0;
 875 }
 876
 877 BOOL
 878 APIENTRY
 879 NtUserSoundSentry(VOID)
 880 {
 881     STUB;
 882     return 0;
 883 }
 884
 885 DWORD
 886 APIENTRY
 887 NtUserTestForInteractiveUser(
 888     DWORD dwUnknown1)
 889 {
 890     STUB;
 891     return 0;
 892 }
 893
 894 DWORD
 895 APIENTRY
 896 NtUserRemoteConnect(
 897     DWORD dwUnknown1,
 898     DWORD dwUnknown2,
 899     DWORD dwUnknown3)
 900 {
 901     STUB;
 902     return 0;
 903 }
 904
 905 DWORD
 906 APIENTRY
 907 NtUserRemoteRedrawRectangle(
 908     DWORD dwUnknown1,
 909     DWORD dwUnknown2,
 910     DWORD dwUnknown3,
 911     DWORD dwUnknown4)
 912 {
 913     STUB;
 914     return 0;
 915 }
 916
 917 DWORD
 918 APIENTRY
 919 NtUserRemoteRedrawScreen(VOID)
 920 {
 921     STUB;
 922     return 0;
 923 }
 924
 925 DWORD
 926 APIENTRY
 927 NtUserRemoteStopScreenUpdates(VOID)
 928 {
 929     STUB;
 930     return 0;
 931 }
 932
 933 DWORD
 934 APIENTRY
 935 NtUserCtxDisplayIOCtl(
 936     DWORD dwUnknown1,
 937     DWORD dwUnknown2,
 938     DWORD dwUnknown3)
 939 {
 940     STUB;
 941     return 0;
 942 }
 943
 944 /*
 945  * @unimplemented
 946  */
 947 BOOL APIENTRY
 948 NtUserLockWindowUpdate(HWND hWnd)
 949 {
 950     STUB;
 951     return FALSE;
 952 }
 953
 954 DWORD APIENTRY
 955 NtUserQuerySendMessage(DWORD Unknown0)
 956 {
 957     STUB;
 958
 959     return 0;
 960 }
 961
 962 BOOL APIENTRY NtUserAddClipboardFormatListener(
 963     HWND hwnd
 964 )
 965 {
 966     STUB;
 967     return FALSE;
 968 }
 969
 970 BOOL APIENTRY NtUserRemoveClipboardFormatListener(
 971     HWND hwnd
 972 )
 973 {
 974     STUB;
 975     return FALSE;
 976 }
 977
 978 BOOL APIENTRY NtUserGetUpdatedClipboardFormats(
 979     PUINT lpuiFormats,
 980     UINT cFormats,
 981     PUINT pcFormatsOut
 982 )
 983 {
 984     STUB;
 985     return FALSE;
 986 }
 987
 988 // Yes, I know, these do not belong here, just tell me where to put them
 989 BOOL
 990 APIENTRY
 991 NtGdiMakeObjectXferable(
 992     _In_ HANDLE hHandle,
 993     _In_ DWORD dwProcessId)
 994 {
 995     STUB;
 996     return 0;
 997 }
 998
 999 DWORD
1000 APIENTRY
1001 NtDxEngGetRedirectionBitmap(
1002     DWORD Unknown0)
1003 {
1004     STUB;
1005     return 0;
1006 }
1007
1008
1009 /* EOF */