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