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