ReactOS 0.4.16-dev-1172-g2041f3c
desktop.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Desktops
5 * FILE: subsystems/win32/win32k/ntuser/desktop.c
6 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 */
8
9/* INCLUDES ******************************************************************/
10
11#include <win32k.h>
13
14#include <reactos/buildno.h>
15
16static NTSTATUS
18
19static NTSTATUS
21
22static NTSTATUS
24
25static VOID
27
28/* GLOBALS *******************************************************************/
29
30/* These can be changed via registry settings.
31 * Default values (interactive desktop / non-interactive desktop):
32 * Windows 2003 x86: 3 MB / 512 KB (Disconnect: 64 KB, Winlogon: 128 KB)
33 * Windows 7 x86: 12 MB / 512 KB
34 * Windows 7 x64: 20 MB / 768 KB
35 * Windows 10 x64: 20 MB / 4 MB
36 * See:
37 * - https://dbmentors.blogspot.com/2011/09/desktop-heap-overview.html
38 * - https://www.ibm.com/support/pages/using-microsoft-desktop-heap-monitor-dheapmon-determine-desktop-heap-space-and-troubleshoot-filenet-p8-and-image-services-issues
39 * - https://www.betaarchive.com/wiki/index.php?title=Microsoft_KB_Archive/184802
40 * - https://kb.firedaemon.com/support/solutions/articles/4000086192-windows-service-quota-limits-and-desktop-heap-exhaustion
41 * - https://learn.microsoft.com/en-us/troubleshoot/windows-server/performance/desktop-heap-limitation-out-of-memory
42 */
43#ifdef _WIN64
44DWORD gdwDesktopSectionSize = 20 * 1024; // 20 MB (Windows 7 style)
45#else
46DWORD gdwDesktopSectionSize = 3 * 1024; // 3 MB (Windows 2003 style)
47#endif
50
51/* Currently active desktop */
57
58/* OBJECT CALLBACKS **********************************************************/
59
67 IN OUT PUNICODE_STRING CompleteName,
72{
76 PLIST_ENTRY NextEntry, ListHead;
77 PWINSTATION_OBJECT WinStaObject = (PWINSTATION_OBJECT)ParseObject;
78 UNICODE_STRING DesktopName;
79 PBOOLEAN pContext = (PBOOLEAN) Context;
80
81 if (pContext)
82 *pContext = FALSE;
83
84 /* Set the list pointers and loop the window station */
85 ListHead = &WinStaObject->DesktopListHead;
86 NextEntry = ListHead->Flink;
87 while (NextEntry != ListHead)
88 {
89 /* Get the current desktop */
90 Desktop = CONTAINING_RECORD(NextEntry, DESKTOP, ListEntry);
91
92 /* Get the desktop name */
93 ASSERT(Desktop->pDeskInfo != NULL);
94 RtlInitUnicodeString(&DesktopName, Desktop->pDeskInfo->szDesktopName);
95
96 /* Compare the name */
98 &DesktopName,
100 {
101 /* We found a match. Did this come from a create? */
102 if (Context)
103 {
104 /* Unless OPEN_IF was given, fail with an error */
105 if (!(Attributes & OBJ_OPENIF))
106 {
107 /* Name collision */
109 }
110 else
111 {
112 /* Otherwise, return with a warning only */
114 }
115 }
116 else
117 {
118 /* This was a real open, so this is OK */
120 }
121
122 /* Reference the desktop and return it */
124 *Object = Desktop;
125 return Status;
126 }
127
128 /* Go to the next desktop */
129 NextEntry = NextEntry->Flink;
130 }
131
132 /* If we got here but this isn't a create, just fail */
134
135 /* Create the desktop object */
141 NULL,
142 sizeof(DESKTOP),
143 0,
144 0,
145 (PVOID*)&Desktop);
146 if (!NT_SUCCESS(Status)) return Status;
147
148 /* Assign security to the desktop we have created */
150 if (!NT_SUCCESS(Status))
151 {
153 return Status;
154 }
155
156 /* Initialize the desktop */
158 if (!NT_SUCCESS(Status))
159 {
161 return Status;
162 }
163
164 /* Set the desktop object and return success */
165 *Object = Desktop;
166 *pContext = TRUE;
167 return STATUS_SUCCESS;
168}
169
171NTAPI
174{
176 PDESKTOP pdesk = (PDESKTOP)DeleteParameters->Object;
177
178 TRACE("Deleting desktop object 0x%p\n", pdesk);
179
180 if (pdesk->pDeskInfo &&
181 pdesk->pDeskInfo->spwnd)
182 {
183 ASSERT(pdesk->pDeskInfo->spwnd->spwndChild == NULL);
185 }
186
187 if (pdesk->spwndMessage)
189
190 /* Remove the desktop from the window station's list of associated desktops */
191 RemoveEntryList(&pdesk->ListEntry);
192
193 /* Free the heap */
194 IntFreeDesktopHeap(pdesk);
195
197
198 return STATUS_SUCCESS;
199}
200
202NTAPI
205{
208
209 if (pti == NULL)
210 {
211 /* This happens when we leak desktop handles */
212 return STATUS_SUCCESS;
213 }
214
215 /* Do not allow the current desktop or the initial desktop to be closed */
216 if (OkToCloseParameters->Handle == pti->ppi->hdeskStartup ||
217 OkToCloseParameters->Handle == pti->hdesk)
218 {
220 }
221
222 return STATUS_SUCCESS;
223}
224
226NTAPI
229{
230 NTSTATUS Ret;
232 PPROCESSINFO ppi = PsGetProcessWin32Process(OpenParameters->Process);
233 if (ppi == NULL)
234 return STATUS_SUCCESS;
235
237 Ret = IntMapDesktopView((PDESKTOP)OpenParameters->Object);
238 UserLeave();
239 return Ret;
240}
241
243NTAPI
246{
247 NTSTATUS Ret;
249 PPROCESSINFO ppi = PsGetProcessWin32Process(CloseParameters->Process);
250 if (ppi == NULL)
251 {
252 /* This happens when the process leaks desktop handles.
253 * At this point the PPROCESSINFO is already destroyed */
254 return STATUS_SUCCESS;
255 }
256
258 Ret = IntUnmapDesktopView((PDESKTOP)CloseParameters->Object);
259 UserLeave();
260 return Ret;
261}
262
263
264/* PRIVATE FUNCTIONS **********************************************************/
265
266CODE_SEG("INIT")
268NTAPI
270{
271 GENERIC_MAPPING IntDesktopMapping = { DESKTOP_READ,
275
276 /* Set Desktop Object Attributes */
278 ExDesktopObjectType->TypeInfo.GenericMapping = IntDesktopMapping;
280
281 /* Allocate memory for the event structure */
283 sizeof(KEVENT),
286 {
287 ERR("Failed to allocate event!\n");
288 return STATUS_NO_MEMORY;
289 }
290
291 /* Initialize the kernel event */
294 FALSE);
295
296 return STATUS_SUCCESS;
297}
298
299static NTSTATUS
302 IN BOOLEAN InSafeMode,
303 IN BOOLEAN AppendNtSystemRoot)
304{
306
307 RTL_OSVERSIONINFOEXW VerInfo;
308 UNICODE_STRING BuildLabString;
309 UNICODE_STRING CSDVersionString;
310 RTL_QUERY_REGISTRY_TABLE VersionConfigurationTable[] =
311 {
312 {
313 NULL,
315 L"BuildLab",
316 &BuildLabString,
317 REG_NONE, NULL, 0
318 },
319 {
320 NULL,
322 L"CSDVersion",
323 &CSDVersionString,
324 REG_NONE, NULL, 0
325 },
326
327 {0}
328 };
329
330 WCHAR BuildLabBuffer[256];
331 WCHAR VersionBuffer[256];
332 PWCHAR EndBuffer;
333
334 VerInfo.dwOSVersionInfoSize = sizeof(VerInfo);
335
336 /*
337 * This call is uniquely used to retrieve the current CSD numbers.
338 * All the rest (major, minor, ...) is either retrieved from the
339 * SharedUserData structure, or from the registry.
340 */
342
343 /*
344 * - Retrieve the BuildLab string from the registry (set by the kernel).
345 * - In kernel-mode, szCSDVersion is not initialized. Initialize it
346 * and query its value from the registry.
347 */
348 RtlZeroMemory(BuildLabBuffer, sizeof(BuildLabBuffer));
349 RtlInitEmptyUnicodeString(&BuildLabString,
350 BuildLabBuffer,
351 sizeof(BuildLabBuffer));
352 RtlZeroMemory(VerInfo.szCSDVersion, sizeof(VerInfo.szCSDVersion));
353 RtlInitEmptyUnicodeString(&CSDVersionString,
354 VerInfo.szCSDVersion,
355 sizeof(VerInfo.szCSDVersion));
357 L"",
358 VersionConfigurationTable,
359 NULL,
360 NULL);
361 if (!NT_SUCCESS(Status))
362 {
363 /* Indicate nothing is there */
364 BuildLabString.Length = 0;
365 CSDVersionString.Length = 0;
366 }
367 /* NULL-terminate the strings */
368 BuildLabString.Buffer[BuildLabString.Length / sizeof(WCHAR)] = UNICODE_NULL;
369 CSDVersionString.Buffer[CSDVersionString.Length / sizeof(WCHAR)] = UNICODE_NULL;
370
371 EndBuffer = VersionBuffer;
372 if ( /* VerInfo.wServicePackMajor != 0 && */ CSDVersionString.Length)
373 {
374 /* Print the version string */
375 Status = RtlStringCbPrintfExW(VersionBuffer,
376 sizeof(VersionBuffer),
377 &EndBuffer,
378 NULL,
379 0,
380 L": %wZ",
381 &CSDVersionString);
382 if (!NT_SUCCESS(Status))
383 {
384 /* No version, NULL-terminate the string */
385 *EndBuffer = UNICODE_NULL;
386 }
387 }
388 else
389 {
390 /* No version, NULL-terminate the string */
391 *EndBuffer = UNICODE_NULL;
392 }
393
394 if (InSafeMode)
395 {
396 /* String for Safe Mode */
397 Status = RtlStringCchPrintfW(pwszzVersion,
398 cchDest,
399 L"ReactOS Version %S %wZ (NT %u.%u Build %u%s)\n",
400 KERNEL_VERSION_STR,
401 &BuildLabString,
402 SharedUserData->NtMajorVersion,
403 SharedUserData->NtMinorVersion,
404 (VerInfo.dwBuildNumber & 0xFFFF),
405 VersionBuffer);
406
407 if (AppendNtSystemRoot && NT_SUCCESS(Status))
408 {
409 Status = RtlStringCbPrintfW(VersionBuffer,
410 sizeof(VersionBuffer),
411 L" - %s\n",
412 SharedUserData->NtSystemRoot);
413 if (NT_SUCCESS(Status))
414 {
415 /* Replace the last newline by a NULL, before concatenating */
416 EndBuffer = wcsrchr(pwszzVersion, L'\n');
417 if (EndBuffer) *EndBuffer = UNICODE_NULL;
418
419 /* The concatenated string has a terminating newline */
420 Status = RtlStringCchCatW(pwszzVersion,
421 cchDest,
422 VersionBuffer);
423 if (!NT_SUCCESS(Status))
424 {
425 /* Concatenation failed, put back the newline */
426 if (EndBuffer) *EndBuffer = L'\n';
427 }
428 }
429
430 /* Override any failures as the NtSystemRoot string is optional */
432 }
433 }
434 else
435 {
436 /* Multi-string for Normal Mode */
437 Status = RtlStringCchPrintfW(pwszzVersion,
438 cchDest,
439 L"ReactOS Version %S\n"
440 L"Build %wZ\n"
441 L"Reporting NT %u.%u (Build %u%s)\n",
442 KERNEL_VERSION_STR,
443 &BuildLabString,
444 SharedUserData->NtMajorVersion,
445 SharedUserData->NtMinorVersion,
446 (VerInfo.dwBuildNumber & 0xFFFF),
447 VersionBuffer);
448
449 if (AppendNtSystemRoot && NT_SUCCESS(Status))
450 {
451 Status = RtlStringCbPrintfW(VersionBuffer,
452 sizeof(VersionBuffer),
453 L"%s\n",
454 SharedUserData->NtSystemRoot);
455 if (NT_SUCCESS(Status))
456 {
457 Status = RtlStringCchCatW(pwszzVersion,
458 cchDest,
459 VersionBuffer);
460 }
461
462 /* Override any failures as the NtSystemRoot string is optional */
464 }
465 }
466
467 if (!NT_SUCCESS(Status))
468 {
469 /* Fall-back string */
470 Status = RtlStringCchPrintfW(pwszzVersion,
471 cchDest,
472 L"ReactOS Version %S %wZ\n",
473 KERNEL_VERSION_STR,
474 &BuildLabString);
475 if (!NT_SUCCESS(Status))
476 {
477 /* General failure, NULL-terminate the string */
478 pwszzVersion[0] = UNICODE_NULL;
479 }
480 }
481
482 /*
483 * Convert the string separators (newlines) into NULLs
484 * and NULL-terminate the multi-string.
485 */
486 while (*pwszzVersion)
487 {
488 EndBuffer = wcschr(pwszzVersion, L'\n');
489 if (!EndBuffer) break;
490 pwszzVersion = EndBuffer;
491
492 *pwszzVersion++ = UNICODE_NULL;
493 }
494 *pwszzVersion = UNICODE_NULL;
495
496 return Status;
497}
498
499
500/*
501 * IntResolveDesktop
502 *
503 * The IntResolveDesktop function attempts to retrieve valid handles to
504 * a desktop and a window station suitable for the specified process.
505 * The specified desktop path string is used only as a hint for the resolution.
506 *
507 * - If the process is already assigned to a window station and a desktop,
508 * handles to these objects are returned directly regardless of the specified
509 * desktop path string. This is what happens when this function is called for
510 * a process that has been already started and connected to the Win32 USER.
511 *
512 * - If the process is being connected to the Win32 USER, or is in a state
513 * where a window station is assigned to it but no desktop yet, the desktop
514 * path string is used as a hint for the resolution.
515 * A specified window station (if any, otherwise "WinSta0" is used as default)
516 * is tested for existence and accessibility. If the checks are OK a handle
517 * to it is returned. Otherwise we either fail (the window station does not
518 * exist) or, in case a default window station was used, we attempt to open
519 * or create a non-interactive Service-0xXXXX-YYYY$ window station. This is
520 * typically what happens when a non-interactive process is started while
521 * the WinSta0 window station was used as the default one.
522 * A specified desktop (if any, otherwise "Default" is used as default)
523 * is then tested for existence on the opened window station.
524 *
525 * - Rules for the choice of the default window station, when none is specified
526 * in the desktop path:
527 *
528 * 1. By default, a SYSTEM process connects to a non-interactive window
529 * station, either the Service-0x0-3e7$ (from the SYSTEM LUID) station,
530 * or one that has been inherited and that is non-interactive.
531 * Only when the interactive window station WinSta0 is specified that
532 * the process can connect to it (e.g. the case of interactive services).
533 *
534 * 2. An interactive process, i.e. a process whose LUID is the same as the
535 * one assigned to WinSta0 by Winlogon on user logon, connects by default
536 * to the WinSta0 window station, unless it has inherited from another
537 * interactive window station (which must be... none other than WinSta0).
538 *
539 * 3. A non-interactive (but not SYSTEM) process connects by default to
540 * a non-interactive Service-0xXXXX-YYYY$ window station (whose name
541 * is derived from the process' LUID), or to another non-interactive
542 * window station that has been inherited.
543 * Otherwise it may be able connect to the interactive WinSta0 only if
544 * it has explicit access rights to it.
545 *
546 * Parameters
547 * Process
548 * The user process object.
549 *
550 * DesktopPath
551 * The desktop path string used as a hint for desktop resolution.
552 *
553 * bInherit
554 * Whether or not the returned handles are inheritable.
555 *
556 * phWinSta
557 * Pointer to a window station handle.
558 *
559 * phDesktop
560 * Pointer to a desktop handle.
561 *
562 * Return Value
563 * Status code.
564 */
565
570 IN PUNICODE_STRING DesktopPath,
571 IN BOOL bInherit,
572 OUT HWINSTA* phWinSta,
573 OUT HDESK* phDesktop)
574{
576 HWINSTA hWinSta = NULL, hWinStaDup = NULL;
577 HDESK hDesktop = NULL, hDesktopDup = NULL;
578 PPROCESSINFO ppi;
580 LUID ProcessLuid;
581 USHORT StrSize;
582 SIZE_T MemSize;
583 PSECURITY_DESCRIPTOR ServiceSD;
586 UNICODE_STRING WinStaName, DesktopName;
587 const UNICODE_STRING WinSta0Name = RTL_CONSTANT_STRING(L"WinSta0");
588 PWINSTATION_OBJECT WinStaObject;
589 HWINSTA hTempWinSta = NULL;
590 BOOLEAN bUseDefaultWinSta = FALSE;
591 BOOLEAN bInteractive = FALSE;
592 BOOLEAN bAccessAllowed = FALSE;
593
595
596 ASSERT(phWinSta);
597 ASSERT(phDesktop);
598 ASSERT(DesktopPath);
599
600 *phWinSta = NULL;
601 *phDesktop = NULL;
602
604 /* ppi is typically NULL for console applications that connect to Win32 USER */
605 if (!ppi) TRACE("IntResolveDesktop: ppi is NULL!\n");
606
607 if (ppi && ppi->hwinsta != NULL && ppi->hdeskStartup != NULL)
608 {
609 /*
610 * If this process is the current one, just return the cached handles.
611 * Otherwise, open the window station and desktop objects.
612 */
614 {
615 hWinSta = ppi->hwinsta;
616 hDesktop = ppi->hdeskStartup;
617 }
618 else
619 {
621 0,
622 NULL,
625 UserMode,
626 (PHANDLE)&hWinSta);
627 if (!NT_SUCCESS(Status))
628 {
629 ERR("IntResolveDesktop: Could not reference window station 0x%p\n", ppi->prpwinsta);
631 return Status;
632 }
633
635 0,
636 NULL,
639 UserMode,
640 (PHANDLE)&hDesktop);
641 if (!NT_SUCCESS(Status))
642 {
643 ERR("IntResolveDesktop: Could not reference desktop 0x%p\n", ppi->rpdeskStartup);
644 ObCloseHandle(hWinSta, UserMode);
646 return Status;
647 }
648 }
649
650 *phWinSta = hWinSta;
651 *phDesktop = hDesktop;
652 return STATUS_SUCCESS;
653 }
654
655 /* We will by default use the default window station and desktop */
656 RtlInitEmptyUnicodeString(&WinStaName, NULL, 0);
657 RtlInitEmptyUnicodeString(&DesktopName, NULL, 0);
658
659 /*
660 * Parse the desktop path string which can be of the form "WinSta\Desktop"
661 * or just "Desktop". In the latter case we use the default window station
662 * on which the process is attached to (or if none, "WinSta0").
663 */
664 if (DesktopPath->Buffer != NULL && DesktopPath->Length > sizeof(WCHAR))
665 {
666 DesktopName = *DesktopPath;
667
668 /* Find the separator */
669 while (DesktopName.Length > 0 && *DesktopName.Buffer &&
670 *DesktopName.Buffer != OBJ_NAME_PATH_SEPARATOR)
671 {
672 DesktopName.Buffer++;
673 DesktopName.Length -= sizeof(WCHAR);
674 DesktopName.MaximumLength -= sizeof(WCHAR);
675 }
676 if (DesktopName.Length > 0)
677 {
678 RtlInitEmptyUnicodeString(&WinStaName, DesktopPath->Buffer,
679 DesktopPath->Length - DesktopName.Length);
680 // (USHORT)((ULONG_PTR)DesktopName.Buffer - (ULONG_PTR)DesktopPath->Buffer);
681 WinStaName.Length = WinStaName.MaximumLength;
682
683 /* Skip the separator */
684 DesktopName.Buffer++;
685 DesktopName.Length -= sizeof(WCHAR);
686 DesktopName.MaximumLength -= sizeof(WCHAR);
687 }
688 else
689 {
690 RtlInitEmptyUnicodeString(&WinStaName, NULL, 0);
691 DesktopName = *DesktopPath;
692 }
693 }
694
695 TRACE("IntResolveDesktop: WinStaName:'%wZ' ; DesktopName:'%wZ'\n", &WinStaName, &DesktopName);
696
697 /* Retrieve the process LUID */
698 Status = GetProcessLuid(NULL, Process, &ProcessLuid);
699 if (!NT_SUCCESS(Status))
700 {
701 ERR("IntResolveDesktop: Failed to retrieve the process LUID, Status 0x%08lx\n", Status);
703 return Status;
704 }
705
706 /*
707 * If this process is not the current one, obtain a temporary handle
708 * to it so that we can perform handles duplication later.
709 */
711 {
714 NULL,
715 0,
718 &hProcess);
719 if (!NT_SUCCESS(Status))
720 {
721 ERR("IntResolveDesktop: Failed to obtain a handle to process 0x%p, Status 0x%08lx\n", Process, Status);
723 return Status;
724 }
726 }
727
728 /*
729 * If no window station has been specified, search the process handle table
730 * for inherited window station handles, otherwise use a default one.
731 */
732 if (WinStaName.Buffer == NULL)
733 {
734 /*
735 * We want to find a suitable default window station.
736 * For applications that can be interactive, i.e. that have allowed
737 * access to the single interactive window station on the system,
738 * the default window station is 'WinSta0'.
739 * For applications that cannot be interactive, i.e. that do not have
740 * access to 'WinSta0' (e.g. non-interactive services), the default
741 * window station is 'Service-0xXXXX-YYYY$' (created if needed).
742 * Precedence will however be taken by any inherited window station
743 * that possesses the required interactivity property.
744 */
745 bUseDefaultWinSta = TRUE;
746
747 /*
748 * Use the default 'WinSta0' window station. Whether we should
749 * use 'Service-0xXXXX-YYYY$' instead will be determined later.
750 */
751 // RtlInitUnicodeString(&WinStaName, L"WinSta0");
752 WinStaName = WinSta0Name;
753
755 NULL,
757 NULL,
758 (PHANDLE)&hWinSta))
759 {
760 TRACE("IntResolveDesktop: Inherited window station is: 0x%p\n", hWinSta);
761 }
762 }
763
764 /*
765 * If no desktop has been specified, search the process handle table
766 * for inherited desktop handles, otherwise use the Default desktop.
767 * Note that the inherited desktop that we may use, may not belong
768 * to the window station we will connect to.
769 */
770 if (DesktopName.Buffer == NULL)
771 {
772 /* Use a default desktop name */
773 RtlInitUnicodeString(&DesktopName, L"Default");
774
776 NULL,
778 NULL,
779 (PHANDLE)&hDesktop))
780 {
781 TRACE("IntResolveDesktop: Inherited desktop is: 0x%p\n", hDesktop);
782 }
783 }
784
785
786 /*
787 * We are going to open either a window station or a desktop.
788 * Even if this operation is done from kernel-mode, we should
789 * "emulate" an opening from user-mode (i.e. using an ObjectAttributes
790 * allocated in user-mode, with AccessMode == UserMode) for the
791 * Object Manager to perform proper access validation to the
792 * window station or desktop.
793 */
794
795 /*
796 * Estimate the maximum size needed for the window station name
797 * and desktop name to be given to ObjectAttributes->ObjectName.
798 */
799 StrSize = 0;
800
801 /* Window station name */
802 MemSize = _scwprintf(L"Service-0x%x-%x$", MAXULONG, MAXULONG) * sizeof(WCHAR);
804 + max(WinStaName.Length, MemSize) + sizeof(UNICODE_NULL);
805 if (MemSize > MAXUSHORT)
806 {
807 ERR("IntResolveDesktop: Window station name length is too long.\n");
809 goto Quit;
810 }
811 StrSize = max(StrSize, (USHORT)MemSize);
812
813 /* Desktop name */
814 MemSize = max(DesktopName.Length + sizeof(UNICODE_NULL), sizeof(L"Default"));
815 StrSize = max(StrSize, (USHORT)MemSize);
816
817 /* Size for the OBJECT_ATTRIBUTES */
818 MemSize = ALIGN_UP(sizeof(OBJECT_ATTRIBUTES), sizeof(PVOID));
819
820 /* Add the string size */
821 MemSize += ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID));
822 MemSize += StrSize;
823
824 /* Allocate the memory in user-mode */
825 Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
827 0,
828 &MemSize,
831 if (!NT_SUCCESS(Status))
832 {
833 ERR("ZwAllocateVirtualMemory() failed, Status 0x%08lx\n", Status);
834 goto Quit;
835 }
836
838 ALIGN_UP(sizeof(OBJECT_ATTRIBUTES), sizeof(PVOID)));
839
840 RtlInitEmptyUnicodeString(ObjectName,
842 ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID))),
843 StrSize);
844
845
846 /* If we got an inherited window station handle, duplicate and use it */
847 if (hWinSta)
848 {
849 ASSERT(bUseDefaultWinSta);
850
851 /* Duplicate the handle if it belongs to another process than the current one */
853 {
855 Status = ZwDuplicateObject(hProcess,
856 hWinSta,
858 (PHANDLE)&hWinStaDup,
859 0,
860 0,
862 if (!NT_SUCCESS(Status))
863 {
864 ERR("IntResolveDesktop: Failed to duplicate the window station handle, Status 0x%08lx\n", Status);
865 /* We will use a default window station */
866 hWinSta = NULL;
867 }
868 else
869 {
870 hWinSta = hWinStaDup;
871 }
872 }
873 }
874
875 /*
876 * If we have an inherited window station, check whether
877 * it is interactive and remember that for later.
878 */
879 if (hWinSta)
880 {
881 ASSERT(bUseDefaultWinSta);
882
883 /* Reference the inherited window station */
885 0,
888 (PVOID*)&WinStaObject,
889 NULL);
890 if (!NT_SUCCESS(Status))
891 {
892 ERR("Failed to reference the inherited window station, Status 0x%08lx\n", Status);
893 /* We will use a default window station */
894 if (hWinStaDup)
895 {
896 ASSERT(hWinSta == hWinStaDup);
897 ObCloseHandle(hWinStaDup, UserMode);
898 hWinStaDup = NULL;
899 }
900 hWinSta = NULL;
901 }
902 else
903 {
904 ERR("Process LUID is: 0x%x-%x, inherited window station LUID is: 0x%x-%x\n",
905 ProcessLuid.HighPart, ProcessLuid.LowPart,
906 WinStaObject->luidUser.HighPart, WinStaObject->luidUser.LowPart);
907
908 /* Check whether this window station is interactive, and remember it for later */
909 bInteractive = !(WinStaObject->Flags & WSS_NOIO);
910
911 /* Dereference the window station */
912 ObDereferenceObject(WinStaObject);
913 }
914 }
915
916 /* Build a valid window station name */
918 ObjectName->MaximumLength,
919 L"%wZ\\%wZ",
921 &WinStaName);
922 if (!NT_SUCCESS(Status))
923 {
924 ERR("Impossible to build a valid window station name, Status 0x%08lx\n", Status);
925 goto Quit;
926 }
927 ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
928
929 TRACE("Parsed initial window station: '%wZ'\n", ObjectName);
930
931 /* Try to open the window station */
935 NULL,
936 NULL);
937 if (bInherit)
938 ObjectAttributes->Attributes |= OBJ_INHERIT;
939
942 UserMode,
943 NULL,
945 NULL,
946 (PHANDLE)&hTempWinSta);
947 if (!NT_SUCCESS(Status))
948 {
949 ERR("Failed to open the window station '%wZ', Status 0x%08lx\n", ObjectName, Status);
950 }
951 else
952 {
953 //
954 // FIXME TODO: Perform a window station access check!!
955 // If we fail AND bUseDefaultWinSta == FALSE we just quit.
956 //
957
958 /*
959 * Check whether we are opening the (single) interactive
960 * window station, and if so, perform an access check.
961 */
962 /* Check whether we are allowed to perform interactions */
963 if (RtlEqualUnicodeString(&WinStaName, &WinSta0Name, TRUE))
964 {
965 LUID SystemLuid = SYSTEM_LUID;
966
967 /* Interactive window station: check for user LUID */
968 WinStaObject = InputWindowStation;
969
971
972 // TODO: Check also that we compare wrt. window station WinSta0
973 // which is the only one that can be interactive on the system.
974 if (((!bUseDefaultWinSta || bInherit) && RtlEqualLuid(&ProcessLuid, &SystemLuid)) ||
975 RtlEqualLuid(&ProcessLuid, &WinStaObject->luidUser))
976 {
977 /* We are interactive on this window station */
978 bAccessAllowed = TRUE;
980 }
981 }
982 else
983 {
984 /* Non-interactive window station: we have access since we were able to open it */
985 bAccessAllowed = TRUE;
987 }
988 }
989
990 /* If we failed, bail out if we were not trying to open the default window station */
991 if (!NT_SUCCESS(Status) && !bUseDefaultWinSta) // if (!bAccessAllowed)
992 goto Quit;
993
994 if (/* bAccessAllowed && */ bInteractive || !bAccessAllowed)
995 {
996 /*
997 * Close WinSta0 if the inherited window station is interactive so that
998 * we can use it, or we do not have access to the interactive WinSta0.
999 */
1000 ObCloseHandle(hTempWinSta, UserMode);
1001 hTempWinSta = NULL;
1002 }
1003 if (bInteractive == bAccessAllowed)
1004 {
1005 /* Keep using the inherited window station */
1006 NOTHING;
1007 }
1008 else // if (bInteractive != bAccessAllowed)
1009 {
1010 /*
1011 * Close the inherited window station, we will either keep using
1012 * the interactive WinSta0, or use Service-0xXXXX-YYYY$.
1013 */
1014 if (hWinStaDup)
1015 {
1016 ASSERT(hWinSta == hWinStaDup);
1017 ObCloseHandle(hWinStaDup, UserMode);
1018 hWinStaDup = NULL;
1019 }
1020 hWinSta = hTempWinSta; // hTempWinSta is NULL in case bAccessAllowed == FALSE
1021 }
1022
1023 if (bUseDefaultWinSta)
1024 {
1025 if (hWinSta == NULL && !bInteractive)
1026 {
1027 /* Build a valid window station name from the LUID */
1029 ObjectName->MaximumLength,
1030 L"%wZ\\Service-0x%x-%x$",
1032 ProcessLuid.HighPart,
1033 ProcessLuid.LowPart);
1034 if (!NT_SUCCESS(Status))
1035 {
1036 ERR("Impossible to build a valid window station name, Status 0x%08lx\n", Status);
1037 goto Quit;
1038 }
1039 ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
1040
1041 /*
1042 * Set up a security descriptor for the new service's window station.
1043 * A service has an associated window station and desktop. The newly
1044 * created window station and desktop will get this security descriptor
1045 * if such objects weren't created before.
1046 */
1047 Status = IntCreateServiceSecurity(&ServiceSD);
1048 if (!NT_SUCCESS(Status))
1049 {
1050 ERR("Failed to create a security descriptor for service window station, Status 0x%08lx\n", Status);
1051 goto Quit;
1052 }
1053
1054 /*
1055 * Create or open the non-interactive window station.
1056 * NOTE: The non-interactive window station handle is never inheritable.
1057 */
1059 ObjectName,
1061 NULL,
1062 ServiceSD);
1063
1064 Status = IntCreateWindowStation(&hWinSta,
1066 UserMode,
1067 KernelMode,
1069 0, 0, 0, 0, 0);
1070
1071 IntFreeSecurityBuffer(ServiceSD);
1072
1073 if (!NT_SUCCESS(Status))
1074 {
1075 ASSERT(hWinSta == NULL);
1076 ERR("Failed to create or open the non-interactive window station '%wZ', Status 0x%08lx\n",
1078 goto Quit;
1079 }
1080
1081 //
1082 // FIXME: We might not need to always create or open the "Default"
1083 // desktop on the Service-0xXXXX-YYYY$ window station; we may need
1084 // to use another one....
1085 //
1086
1087 /* Create or open the Default desktop on the window station */
1089 ObjectName->MaximumLength,
1090 L"Default");
1091 if (!NT_SUCCESS(Status))
1092 {
1093 ERR("Impossible to build a valid desktop name, Status 0x%08lx\n", Status);
1094 goto Quit;
1095 }
1096 ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
1097
1098 /*
1099 * NOTE: The non-interactive desktop handle is never inheritable.
1100 * The security descriptor is inherited from the newly created
1101 * window station for the desktop.
1102 */
1104 ObjectName,
1106 hWinSta,
1107 NULL);
1108
1109 Status = IntCreateDesktop(&hDesktop,
1111 UserMode,
1112 NULL,
1113 NULL,
1114 0,
1116 if (!NT_SUCCESS(Status))
1117 {
1118 ASSERT(hDesktop == NULL);
1119 ERR("Failed to create or open the desktop '%wZ' on window station 0x%p, Status 0x%08lx\n",
1120 ObjectName, hWinSta, Status);
1121 }
1122
1123 goto Quit;
1124 }
1125/*
1126 if (hWinSta == NULL)
1127 {
1128 Status = STATUS_UNSUCCESSFUL;
1129 goto Quit;
1130 }
1131*/
1132 }
1133
1134 /*
1135 * If we got an inherited desktop handle, duplicate and use it,
1136 * otherwise open a new desktop.
1137 */
1138 if (hDesktop != NULL)
1139 {
1140 /* Duplicate the handle if it belongs to another process than the current one */
1142 {
1144 Status = ZwDuplicateObject(hProcess,
1145 hDesktop,
1147 (PHANDLE)&hDesktopDup,
1148 0,
1149 0,
1151 if (!NT_SUCCESS(Status))
1152 {
1153 ERR("IntResolveDesktop: Failed to duplicate the desktop handle, Status 0x%08lx\n", Status);
1154 /* We will use a default desktop */
1155 hDesktop = NULL;
1156 }
1157 else
1158 {
1159 hDesktop = hDesktopDup;
1160 }
1161 }
1162 }
1163
1164 if ((hWinSta != NULL) && (hDesktop == NULL))
1165 {
1167 ObjectName->MaximumLength,
1168 DesktopName.Buffer,
1169 DesktopName.Length);
1170 if (!NT_SUCCESS(Status))
1171 {
1172 ERR("Impossible to build a valid desktop name, Status 0x%08lx\n", Status);
1173 goto Quit;
1174 }
1175 ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
1176
1177 TRACE("Parsed initial desktop: '%wZ'\n", ObjectName);
1178
1179 /* Open the desktop object */
1181 ObjectName,
1183 hWinSta,
1184 NULL);
1185 if (bInherit)
1186 ObjectAttributes->Attributes |= OBJ_INHERIT;
1187
1190 UserMode,
1191 NULL,
1193 NULL,
1194 (PHANDLE)&hDesktop);
1195 if (!NT_SUCCESS(Status))
1196 {
1197 ERR("Failed to open the desktop '%wZ' on window station 0x%p, Status 0x%08lx\n",
1198 ObjectName, hWinSta, Status);
1199 goto Quit;
1200 }
1201 }
1202
1203Quit:
1204 /* Release the object attributes */
1205 if (ObjectAttributes)
1206 {
1207 MemSize = 0;
1208 ZwFreeVirtualMemory(ZwCurrentProcess(),
1210 &MemSize,
1211 MEM_RELEASE);
1212 }
1213
1214 /* Close the temporary process handle */
1215 if (hProcess) // if (Process != PsGetCurrentProcess())
1217
1218 if (NT_SUCCESS(Status))
1219 {
1220 *phWinSta = hWinSta;
1221 *phDesktop = hDesktop;
1222 return STATUS_SUCCESS;
1223 }
1224 else
1225 {
1226 ERR("IntResolveDesktop(%wZ) failed, Status 0x%08lx\n", DesktopPath, Status);
1227
1228 if (hDesktopDup)
1229 ObCloseHandle(hDesktopDup, UserMode);
1230 if (hWinStaDup)
1231 ObCloseHandle(hWinStaDup, UserMode);
1232
1233 if (hDesktop)
1234 ObCloseHandle(hDesktop, UserMode);
1235 if (hWinSta)
1236 ObCloseHandle(hWinSta, UserMode);
1237
1239 return Status;
1240 }
1241}
1242
1243/*
1244 * IntValidateDesktopHandle
1245 *
1246 * Validates the desktop handle.
1247 *
1248 * Remarks
1249 * If the function succeeds, the handle remains referenced. If the
1250 * fucntion fails, last error is set.
1251 */
1252
1255 HDESK Desktop,
1259{
1261
1265 AccessMode,
1266 (PVOID*)Object,
1267 NULL);
1268
1269 TRACE("IntValidateDesktopHandle: handle:0x%p obj:0x%p access:0x%x Status:0x%lx\n",
1271
1272 if (!NT_SUCCESS(Status))
1274
1275 return Status;
1276}
1277
1280{
1281 return gpdeskInputDesktop;
1282}
1283
1284/*
1285 * Returns or creates a handle to the desktop object
1286 */
1287HDESK FASTCALL
1289{
1291 HDESK hDesk;
1292
1293 ASSERT(DesktopObject);
1294
1296 DesktopObject,
1298 NULL,
1299 (PHANDLE)&hDesk))
1300 {
1301 Status = ObOpenObjectByPointer(DesktopObject,
1302 0,
1303 NULL,
1304 0,
1306 UserMode,
1307 (PHANDLE)&hDesk);
1308 if (!NT_SUCCESS(Status))
1309 {
1310 /* Unable to create a handle */
1311 ERR("Unable to create a desktop handle\n");
1312 return NULL;
1313 }
1314 }
1315 else
1316 {
1317 TRACE("Got handle: 0x%p\n", hDesk);
1318 }
1319
1320 return hDesk;
1321}
1322
1325{
1327 if (!pdo)
1328 {
1329 TRACE("No active desktop\n");
1330 return(NULL);
1331 }
1333}
1334
1337{
1340 if (!pdo)
1341 {
1342 TRACE("No active desktop\n");
1343 return;
1344 }
1345 if (NewQueue != NULL)
1346 {
1347 if (NewQueue->Desktop != NULL)
1348 {
1349 TRACE("Message Queue already attached to another desktop!\n");
1350 return;
1351 }
1352 IntReferenceMessageQueue(NewQueue);
1353 (void)InterlockedExchangePointer((PVOID*)&NewQueue->Desktop, pdo);
1354 }
1356 if (Old != NULL)
1357 {
1359 gpqForegroundPrev = Old;
1361 }
1362 // Only one Q can have active foreground even when there are more than one desktop.
1363 if (NewQueue)
1364 {
1366 }
1367 else
1368 {
1370 ERR("ptiLastInput is CLEARED!!\n");
1371 ptiLastInput = NULL; // ReactOS hacks... should check for process death.
1372 }
1373}
1374
1377{
1378 if (!pti) pti = PsGetCurrentThreadWin32Thread();
1379 if (pti->pDeskInfo) return pti->pDeskInfo->spwnd;
1380 return NULL;
1381}
1382
1384{
1385 if (pWnd->head.rpdesk &&
1386 pWnd->head.rpdesk->pDeskInfo)
1387 return pWnd->head.rpdesk->pDeskInfo->spwnd;
1388 return NULL;
1389}
1390
1392{
1394 if (!pdo)
1395 {
1396 TRACE("No active desktop\n");
1397 return NULL;
1398 }
1399 return pdo->DesktopWindow;
1400}
1401
1402// Win: _GetDesktopWindow
1404{
1406
1407 if (!pdo)
1408 {
1409 TRACE("No active desktop\n");
1410 return NULL;
1411 }
1412 // return pdo->pDeskInfo->spwnd;
1414}
1415
1417{
1419
1420 if (!pdo)
1421 {
1422 TRACE("No active desktop\n");
1423 return NULL;
1424 }
1425 return UserHMGetHandle(pdo->spwndMessage);
1426}
1427
1428// Win: _GetMessageWindow
1430{
1432
1433 if (!pdo)
1434 {
1435 TRACE("No active desktop\n");
1436 return NULL;
1437 }
1438 return pdo->spwndMessage;
1439}
1440
1442{
1444 PDESKTOP pdo = pti->rpdesk;
1445 if (NULL == pdo)
1446 {
1447 ERR("Thread doesn't have a desktop\n");
1448 return NULL;
1449 }
1450 return pdo->DesktopWindow;
1451}
1452
1453/* PUBLIC FUNCTIONS ***********************************************************/
1454
1457{
1458 PAINTSTRUCT Ps;
1459 ULONG Value;
1460 //ERR("DesktopWindowProc\n");
1461
1462 *lResult = 0;
1463
1464 switch (Msg)
1465 {
1466 case WM_NCCREATE:
1467 if (!Wnd->fnid)
1468 {
1469 Wnd->fnid = FNID_DESKTOP;
1470 }
1471 *lResult = (LRESULT)TRUE;
1472 return TRUE;
1473
1474 case WM_CREATE:
1476 // Save Process ID
1479 // Save Thread ID
1481 case WM_CLOSE:
1482 return TRUE;
1483
1484 case WM_DISPLAYCHANGE:
1486 return TRUE;
1487
1488 case WM_ERASEBKGND:
1490 *lResult = 1;
1491 return TRUE;
1492
1493 case WM_PAINT:
1494 {
1495 if (IntBeginPaint(Wnd, &Ps))
1496 {
1497 IntEndPaint(Wnd, &Ps);
1498 }
1499 return TRUE;
1500 }
1501 case WM_SYSCOLORCHANGE:
1503 return TRUE;
1504
1505 case WM_SETCURSOR:
1506 {
1507 PCURICON_OBJECT pcurOld, pcurNew;
1509 if (!pcurNew)
1510 {
1511 return TRUE;
1512 }
1513
1514 pcurNew->CURSORF_flags |= CURSORF_CURRENT;
1515 pcurOld = UserSetCursor(pcurNew, FALSE);
1516 if (pcurOld)
1517 {
1518 pcurOld->CURSORF_flags &= ~CURSORF_CURRENT;
1519 UserDereferenceObject(pcurOld);
1520 }
1521 return TRUE;
1522 }
1523
1525 {
1526 PWINDOWPOS pWindowPos = (PWINDOWPOS)lParam;
1527 if ((pWindowPos->flags & SWP_SHOWWINDOW) != 0)
1528 {
1530 IntSetThreadDesktop(hdesk, FALSE);
1531 }
1532 break;
1533 }
1534 default:
1535 TRACE("DWP calling IDWP Msg %d\n",Msg);
1536 //*lResult = IntDefWindowProc(Wnd, Msg, wParam, lParam, FALSE);
1537 }
1538 return TRUE; /* We are done. Do not do any callbacks to user mode */
1539}
1540
1543{
1544 *lResult = 0;
1545
1546 switch(Msg)
1547 {
1548 case WM_NCCREATE:
1549 pwnd->fnid |= FNID_MESSAGEWND;
1550 *lResult = (LRESULT)TRUE;
1551 break;
1552 case WM_DESTROY:
1553 pwnd->fnid |= FNID_DESTROY;
1554 break;
1555 default:
1556 ERR("UMWP calling IDWP\n");
1557 *lResult = IntDefWindowProc(pwnd, Msg, wParam, lParam, FALSE);
1558 }
1559
1560 return TRUE; /* We are done. Do not do any callbacks to user mode */
1561}
1562
1564{
1565 BOOL Ret;
1566 MSG Msg;
1567
1569
1571
1572 /* Register system classes. This thread does not belong to any desktop so the
1573 classes will be allocated from the shared heap */
1575
1577
1578 while (TRUE)
1579 {
1580 Ret = co_IntGetPeekMessage(&Msg, 0, 0, 0, PM_REMOVE, TRUE);
1581 if (Ret)
1582 {
1584 }
1585 }
1586
1587 UserLeave();
1588}
1589
1591UserGetDesktopDC(ULONG DcType, BOOL bAltDc, BOOL ValidatehWnd)
1592{
1593 PWND DesktopObject = 0;
1594 HDC DesktopHDC = 0;
1595
1596 /* This can be called from GDI/DX, so acquire the USER lock */
1598
1599 if (DcType == DCTYPE_DIRECT)
1600 {
1601 DesktopObject = UserGetDesktopWindow();
1602 DesktopHDC = (HDC)UserGetWindowDC(DesktopObject);
1603 }
1604 else
1605 {
1606 PMONITOR pMonitor = UserGetPrimaryMonitor();
1607 DesktopHDC = IntGdiCreateDisplayDC(pMonitor->hDev, DcType, bAltDc);
1608 }
1609
1610 UserLeave();
1611
1612 return DesktopHDC;
1613}
1614
1617{
1618 PWND Window = NULL;
1619 PREGION Rgn;
1620
1622 Rgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
1623
1625 Rgn,
1628
1629 REGION_Delete(Rgn);
1630}
1631
1632
1635{
1636 PWND pwnd = Desktop->pDeskInfo->spwnd;
1638 ASSERT(pwnd);
1639
1640 if (!bRedraw)
1642
1644
1645 if (bRedraw)
1647
1648 return STATUS_SUCCESS;
1649}
1650
1653{
1654 PWND DesktopWnd;
1655
1656 DesktopWnd = IntGetWindowObject(Desktop->DesktopWindow);
1657 if (! DesktopWnd)
1658 {
1660 }
1661 DesktopWnd->style &= ~WS_VISIBLE;
1662
1663 return STATUS_SUCCESS;
1664}
1665
1666static
1669{
1670 ULONG entries=0;
1671 PLIST_ENTRY ListEntry;
1672 PSHELL_HOOK_WINDOW Current;
1673 HWND* list;
1674
1675 /* FIXME: If we save nb elements in desktop, we don't have to loop to find nb entries */
1676 ListEntry = Desktop->ShellHookWindows.Flink;
1677 while (ListEntry != &Desktop->ShellHookWindows)
1678 {
1679 ListEntry = ListEntry->Flink;
1680 entries++;
1681 }
1682
1683 if (!entries) return NULL;
1684
1685 list = ExAllocatePoolWithTag(PagedPool, sizeof(HWND) * (entries + 1), USERTAG_WINDOWLIST); /* alloc one extra for nullterm */
1686 if (list)
1687 {
1688 HWND* cursor = list;
1689
1690 ListEntry = Desktop->ShellHookWindows.Flink;
1691 while (ListEntry != &Desktop->ShellHookWindows)
1692 {
1693 Current = CONTAINING_RECORD(ListEntry, SHELL_HOOK_WINDOW, ListEntry);
1694 ListEntry = ListEntry->Flink;
1695 *cursor++ = Current->hWnd;
1696 }
1697
1698 *cursor = NULL; /* Nullterm list */
1699 }
1700
1701 return list;
1702}
1703
1704/*
1705 * Send the Message to the windows registered for ShellHook
1706 * notifications. The lParam contents depend on the Message. See
1707 * MSDN for more details (RegisterShellHookWindow)
1708 */
1710{
1712 HWND* HwndList;
1713
1714 if (!gpsi->uiShellMsg)
1715 {
1716 gpsi->uiShellMsg = IntAddAtom(L"SHELLHOOK");
1717
1718 TRACE("MsgType = %x\n", gpsi->uiShellMsg);
1719 if (!gpsi->uiShellMsg)
1720 ERR("LastError: %x\n", EngGetLastError());
1721 }
1722
1723 if (!Desktop)
1724 {
1725 TRACE("IntShellHookNotify: No desktop!\n");
1726 return;
1727 }
1728
1729 // Allow other devices have a shot at foreground.
1730 if (Message == HSHELL_APPCOMMAND) ptiLastInput = NULL;
1731
1732 // FIXME: System Tray Support.
1733
1735 if (HwndList)
1736 {
1737 HWND* cursor = HwndList;
1738 LPARAM shellhookparam = (Message == HSHELL_LANGUAGE || Message == HSHELL_APPCOMMAND)
1739 ? lParam : (LPARAM)wParam;
1740
1741 for (; *cursor; cursor++)
1742 {
1743 TRACE("Sending notify\n");
1746 Message,
1747 shellhookparam);
1748/* co_IntPostOrSendMessage(*cursor,
1749 gpsi->uiShellMsg,
1750 Message,
1751 shellhookparam);*/
1752 }
1753
1755 }
1756
1757 if (ISITHOOKED(WH_SHELL))
1758 {
1760 }
1761}
1762
1763/*
1764 * Add the window to the ShellHookWindows list. The windows
1765 * on that list get notifications that are important to shell
1766 * type applications.
1767 *
1768 * TODO: Validate the window? I'm not sure if sending these messages to
1769 * an unsuspecting application that is not your own is a nice thing to do.
1770 */
1772{
1774 PDESKTOP Desktop = pti->rpdesk;
1776
1777 TRACE("IntRegisterShellHookWindow\n");
1778
1779 /* First deregister the window, so we can be sure it's never twice in the
1780 * list.
1781 */
1783
1785 sizeof(SHELL_HOOK_WINDOW),
1786 TAG_WINSTA);
1787
1788 if (!Entry)
1789 return FALSE;
1790
1791 Entry->hWnd = hWnd;
1792
1793 InsertTailList(&Desktop->ShellHookWindows, &Entry->ListEntry);
1794
1795 return TRUE;
1796}
1797
1798/*
1799 * Remove the window from the ShellHookWindows list. The windows
1800 * on that list get notifications that are important to shell
1801 * type applications.
1802 */
1804{
1806 PDESKTOP Desktop = pti->rpdesk;
1807 PLIST_ENTRY ListEntry;
1808 PSHELL_HOOK_WINDOW Current;
1809
1810 // FIXME: This probably shouldn't happen, but it does
1811 if (Desktop == NULL)
1812 {
1814 if (Desktop == NULL)
1815 return FALSE;
1816 }
1817
1818 ListEntry = Desktop->ShellHookWindows.Flink;
1819 while (ListEntry != &Desktop->ShellHookWindows)
1820 {
1821 Current = CONTAINING_RECORD(ListEntry, SHELL_HOOK_WINDOW, ListEntry);
1822 ListEntry = ListEntry->Flink;
1823 if (Current->hWnd == hWnd)
1824 {
1825 RemoveEntryList(&Current->ListEntry);
1826 ExFreePoolWithTag(Current, TAG_WINSTA);
1827 return TRUE;
1828 }
1829 }
1830
1831 return FALSE;
1832}
1833
1834static VOID
1836{
1837 /* FIXME: Disable until unmapping works in mm */
1838#if 0
1839 if (Desktop->pheapDesktop != NULL)
1840 {
1841 MmUnmapViewInSessionSpace(Desktop->pheapDesktop);
1842 Desktop->pheapDesktop = NULL;
1843 }
1844
1845 if (Desktop->hsectionDesktop != NULL)
1846 {
1847 ObDereferenceObject(Desktop->hsectionDesktop);
1848 Desktop->hsectionDesktop = NULL;
1849 }
1850#endif
1851}
1852
1855{
1856 static WCHAR s_wszSafeMode[] = L"Safe Mode"; // FIXME: Localize!
1857
1858 RECTL Rect;
1859 HBRUSH DesktopBrush, PreviousBrush;
1860 HWND hWndDesktop;
1861 BOOL doPatBlt = TRUE;
1862 PWND WndDesktop;
1863 BOOLEAN InSafeMode;
1864
1865 if (GdiGetClipBox(hDC, &Rect) == ERROR)
1866 return FALSE;
1867
1868 hWndDesktop = IntGetDesktopWindow(); // rpdesk->DesktopWindow;
1869
1870 WndDesktop = UserGetWindowObject(hWndDesktop); // rpdesk->pDeskInfo->spwnd;
1871 if (!WndDesktop)
1872 return FALSE;
1873
1874 /* Retrieve the current SafeMode state */
1875 InSafeMode = (UserGetSystemMetrics(SM_CLEANBOOT) != 0); // gpsi->aiSysMet[SM_CLEANBOOT];
1876
1877 if (!InSafeMode)
1878 {
1879 DesktopBrush = (HBRUSH)WndDesktop->pcls->hbrBackground;
1880
1881 /*
1882 * Paint desktop background
1883 */
1885 {
1886 SIZE sz;
1887 int x, y;
1888 int scaledWidth, scaledHeight;
1889 int wallpaperX, wallpaperY, wallpaperWidth, wallpaperHeight;
1890 HDC hWallpaperDC;
1891
1892 sz.cx = WndDesktop->rcWindow.right - WndDesktop->rcWindow.left;
1893 sz.cy = WndDesktop->rcWindow.bottom - WndDesktop->rcWindow.top;
1894
1895 if (gspv.WallpaperMode == wmFit ||
1897 {
1898 int scaleNum, scaleDen;
1899
1900 // Precision improvement over ((sz.cx / gspv.cxWallpaper) > (sz.cy / gspv.cyWallpaper))
1901 if ((sz.cx * gspv.cyWallpaper) > (sz.cy * gspv.cxWallpaper))
1902 {
1903 if (gspv.WallpaperMode == wmFit)
1904 {
1905 scaleNum = sz.cy;
1906 scaleDen = gspv.cyWallpaper;
1907 }
1908 else
1909 {
1910 scaleNum = sz.cx;
1911 scaleDen = gspv.cxWallpaper;
1912 }
1913 }
1914 else
1915 {
1916 if (gspv.WallpaperMode == wmFit)
1917 {
1918 scaleNum = sz.cx;
1919 scaleDen = gspv.cxWallpaper;
1920 }
1921 else
1922 {
1923 scaleNum = sz.cy;
1924 scaleDen = gspv.cyWallpaper;
1925 }
1926 }
1927
1928 scaledWidth = EngMulDiv(gspv.cxWallpaper, scaleNum, scaleDen);
1929 scaledHeight = EngMulDiv(gspv.cyWallpaper, scaleNum, scaleDen);
1930
1931 if (gspv.WallpaperMode == wmFill)
1932 {
1933 wallpaperX = (((scaledWidth - sz.cx) * gspv.cxWallpaper) / (2 * scaledWidth));
1934 wallpaperY = (((scaledHeight - sz.cy) * gspv.cyWallpaper) / (2 * scaledHeight));
1935
1936 wallpaperWidth = (sz.cx * gspv.cxWallpaper) / scaledWidth;
1937 wallpaperHeight = (sz.cy * gspv.cyWallpaper) / scaledHeight;
1938 }
1939 }
1940
1941 if (gspv.WallpaperMode == wmStretch ||
1944 {
1945 x = 0;
1946 y = 0;
1947 }
1948 else if (gspv.WallpaperMode == wmFit)
1949 {
1950 x = (sz.cx - scaledWidth) / 2;
1951 y = (sz.cy - scaledHeight) / 2;
1952 }
1953 else
1954 {
1955 /* Find the upper left corner, can be negative if the bitmap is bigger than the screen */
1956 x = (sz.cx / 2) - (gspv.cxWallpaper / 2);
1957 y = (sz.cy / 2) - (gspv.cyWallpaper / 2);
1958 }
1959
1960 hWallpaperDC = NtGdiCreateCompatibleDC(hDC);
1961 if (hWallpaperDC != NULL)
1962 {
1963 HBITMAP hOldBitmap;
1964
1965 /* Fill in the area that the bitmap is not going to cover */
1966 if (x > 0 || y > 0)
1967 {
1968 /* FIXME: Clip out the bitmap
1969 can be replaced with "NtGdiPatBlt(hDC, x, y, gspv.cxWallpaper, gspv.cyWallpaper, PATCOPY | DSTINVERT);"
1970 once we support DSTINVERT */
1971 PreviousBrush = NtGdiSelectBrush(hDC, DesktopBrush);
1972 NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right, Rect.bottom, PATCOPY);
1973 NtGdiSelectBrush(hDC, PreviousBrush);
1974 }
1975
1976 /* Do not fill the background after it is painted no matter the size of the picture */
1977 doPatBlt = FALSE;
1978
1979 hOldBitmap = NtGdiSelectBitmap(hWallpaperDC, gspv.hbmWallpaper);
1980
1982 {
1983 if (Rect.right && Rect.bottom)
1985 x,
1986 y,
1987 sz.cx,
1988 sz.cy,
1989 hWallpaperDC,
1990 0,
1991 0,
1994 SRCCOPY,
1995 0);
1996 }
1997 else if (gspv.WallpaperMode == wmTile)
1998 {
1999 /* Paint the bitmap across the screen then down */
2000 for (y = 0; y < Rect.bottom; y += gspv.cyWallpaper)
2001 {
2002 for (x = 0; x < Rect.right; x += gspv.cxWallpaper)
2003 {
2005 x,
2006 y,
2009 hWallpaperDC,
2010 0,
2011 0,
2012 SRCCOPY,
2013 0,
2014 0);
2015 }
2016 }
2017 }
2018 else if (gspv.WallpaperMode == wmFit)
2019 {
2020 if (Rect.right && Rect.bottom)
2021 {
2023 x,
2024 y,
2025 scaledWidth,
2026 scaledHeight,
2027 hWallpaperDC,
2028 0,
2029 0,
2032 SRCCOPY,
2033 0);
2034 }
2035 }
2036 else if (gspv.WallpaperMode == wmFill)
2037 {
2038 if (Rect.right && Rect.bottom)
2039 {
2041 x,
2042 y,
2043 sz.cx,
2044 sz.cy,
2045 hWallpaperDC,
2046 wallpaperX,
2047 wallpaperY,
2048 wallpaperWidth,
2049 wallpaperHeight,
2050 SRCCOPY,
2051 0);
2052 }
2053 }
2054 else
2055 {
2057 x,
2058 y,
2061 hWallpaperDC,
2062 0,
2063 0,
2064 SRCCOPY,
2065 0,
2066 0);
2067 }
2068 NtGdiSelectBitmap(hWallpaperDC, hOldBitmap);
2069 NtGdiDeleteObjectApp(hWallpaperDC);
2070 }
2071 }
2072 }
2073 else
2074 {
2075 /* Black desktop background in Safe Mode */
2076 DesktopBrush = StockObjects[BLACK_BRUSH];
2077 }
2078
2079 /* Background is set to none, clear the screen */
2080 if (doPatBlt)
2081 {
2082 PreviousBrush = NtGdiSelectBrush(hDC, DesktopBrush);
2083 NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right, Rect.bottom, PATCOPY);
2084 NtGdiSelectBrush(hDC, PreviousBrush);
2085 }
2086
2087 /*
2088 * Display the system version on the desktop background
2089 */
2090 if (InSafeMode || g_AlwaysDisplayVersion || g_PaintDesktopVersion)
2091 {
2093 static WCHAR wszzVersion[1024] = L"\0";
2094
2095 /* Only used in normal mode */
2096 // We expect at most 4 strings (3 for version, 1 for optional NtSystemRoot)
2097 static POLYTEXTW VerStrs[4] = {{0},{0},{0},{0}};
2098 INT i = 0;
2099 SIZE_T len;
2100
2101 HFONT hFont1 = NULL, hFont2 = NULL, hOldFont = NULL;
2102 COLORREF crText, color_old;
2103 UINT align_old;
2104 INT mode_old;
2105 PDC pdc;
2106
2107 if (!UserSystemParametersInfo(SPI_GETWORKAREA, 0, &Rect, 0))
2108 {
2109 Rect.left = Rect.top = 0;
2112 }
2113 else
2114 {
2115 RECTL_vOffsetRect(&Rect, -Rect.left, -Rect.top);
2116 }
2117
2118 /*
2119 * Set up the fonts (otherwise use default ones)
2120 */
2121
2122 /* Font for the principal version string */
2123 hFont1 = GreCreateFontIndirectW(&gspv.ncm.lfCaptionFont);
2124 /* Font for the secondary version strings */
2125 hFont2 = GreCreateFontIndirectW(&gspv.ncm.lfMenuFont);
2126
2127 if (hFont1)
2128 hOldFont = NtGdiSelectFont(hDC, hFont1);
2129
2130 if (gspv.hbmWallpaper == NULL)
2131 {
2132 /* Retrieve the brush fill colour */
2133 // TODO: The following code constitutes "GreGetBrushColor".
2134 PreviousBrush = NtGdiSelectBrush(hDC, DesktopBrush);
2135 pdc = DC_LockDc(hDC);
2136 if (pdc)
2137 {
2138 crText = pdc->eboFill.ulRGBColor;
2139 DC_UnlockDc(pdc);
2140 }
2141 else
2142 {
2143 crText = RGB(0, 0, 0);
2144 }
2145 NtGdiSelectBrush(hDC, PreviousBrush);
2146
2147 /* Adjust text colour according to the brush */
2148 if (GetRValue(crText) + GetGValue(crText) + GetBValue(crText) > 128 * 3)
2149 crText = RGB(0, 0, 0);
2150 else
2151 crText = RGB(255, 255, 255);
2152 }
2153 else
2154 {
2155 /* Always use white when the text is displayed on top of a wallpaper */
2156 crText = RGB(255, 255, 255);
2157 }
2158
2159 color_old = IntGdiSetTextColor(hDC, crText);
2160 align_old = IntGdiSetTextAlign(hDC, TA_RIGHT);
2161 mode_old = IntGdiSetBkMode(hDC, TRANSPARENT);
2162
2163 /* Display the system version information */
2164 if (!*wszzVersion)
2165 {
2166 Status = GetSystemVersionString(wszzVersion,
2167 ARRAYSIZE(wszzVersion),
2168 InSafeMode,
2170 if (!InSafeMode && NT_SUCCESS(Status) && *wszzVersion)
2171 {
2172 PWCHAR pstr = wszzVersion;
2173 for (i = 0; (i < ARRAYSIZE(VerStrs)) && *pstr; ++i)
2174 {
2175 VerStrs[i].n = lstrlenW(pstr);
2176 VerStrs[i].lpstr = pstr;
2177 pstr += (VerStrs[i].n + 1);
2178 }
2179 }
2180 }
2181 else
2182 {
2184 }
2185 if (NT_SUCCESS(Status) && *wszzVersion)
2186 {
2187 if (!InSafeMode)
2188 {
2189 SIZE Size = {0, 0};
2190 LONG TotalHeight = 0;
2191
2192 /* Normal Mode: multiple version information text separated by newlines */
2194
2195 /* Compute the heights of the strings */
2196 if (hFont1) NtGdiSelectFont(hDC, hFont1);
2197 for (i = 0; i < ARRAYSIZE(VerStrs); ++i)
2198 {
2199 if (!VerStrs[i].lpstr || !*VerStrs[i].lpstr || (VerStrs[i].n == 0))
2200 break;
2201
2202 GreGetTextExtentW(hDC, VerStrs[i].lpstr, VerStrs[i].n, &Size, 1);
2203 VerStrs[i].y = Size.cy; // Store the string height
2204 TotalHeight += Size.cy;
2205
2206 /* While the first string was using hFont1, all the others use hFont2 */
2207 if (hFont2) NtGdiSelectFont(hDC, hFont2);
2208 }
2209 /* The total height must not exceed the screen height */
2210 TotalHeight = min(TotalHeight, Rect.bottom);
2211
2212 /* Display the strings */
2213 if (hFont1) NtGdiSelectFont(hDC, hFont1);
2214 for (i = 0; i < ARRAYSIZE(VerStrs); ++i)
2215 {
2216 if (!VerStrs[i].lpstr || !*VerStrs[i].lpstr || (VerStrs[i].n == 0))
2217 break;
2218
2219 TotalHeight -= VerStrs[i].y;
2221 Rect.right - 5,
2222 Rect.bottom - TotalHeight - 5,
2223 0, NULL,
2224 VerStrs[i].lpstr,
2225 VerStrs[i].n,
2226 NULL, 0);
2227
2228 /* While the first string was using hFont1, all the others use hFont2 */
2229 if (hFont2) NtGdiSelectFont(hDC, hFont2);
2230 }
2231 }
2232 else
2233 {
2234 if (hFont1) NtGdiSelectFont(hDC, hFont1);
2235
2236 /* Safe Mode: single version information text in top center */
2237 len = wcslen(wszzVersion);
2238
2240 GreExtTextOutW(hDC, (Rect.right + Rect.left)/2, Rect.top + 3, 0, NULL, wszzVersion, len, NULL, 0);
2241 }
2242 }
2243
2244 if (InSafeMode)
2245 {
2246 if (hFont1) NtGdiSelectFont(hDC, hFont1);
2247
2248 /* Print Safe Mode text in corners */
2249 len = wcslen(s_wszSafeMode);
2250
2252 GreExtTextOutW(hDC, Rect.left, Rect.top + 3, 0, NULL, s_wszSafeMode, len, NULL, 0);
2254 GreExtTextOutW(hDC, Rect.right, Rect.top + 3, 0, NULL, s_wszSafeMode, len, NULL, 0);
2256 GreExtTextOutW(hDC, Rect.left, Rect.bottom - 5, 0, NULL, s_wszSafeMode, len, NULL, 0);
2258 GreExtTextOutW(hDC, Rect.right, Rect.bottom - 5, 0, NULL, s_wszSafeMode, len, NULL, 0);
2259 }
2260
2261 IntGdiSetBkMode(hDC, mode_old);
2262 IntGdiSetTextAlign(hDC, align_old);
2263 IntGdiSetTextColor(hDC, color_old);
2264
2265 if (hFont2)
2266 GreDeleteObject(hFont2);
2267
2268 if (hFont1)
2269 {
2270 NtGdiSelectFont(hDC, hOldFont);
2271 GreDeleteObject(hFont1);
2272 }
2273 }
2274
2275 return TRUE;
2276}
2277
2278static NTSTATUS
2280{
2281 static const UNICODE_STRING WinlogonDesktop = RTL_CONSTANT_STRING(L"Winlogon");
2282 PVOID DesktopHeapSystemBase = NULL;
2284 SIZE_T DesktopInfoSize;
2285 ULONG i;
2286
2287 TRACE("UserInitializeDesktop desktop 0x%p with name %wZ\n", pdesk, DesktopName);
2288
2289 RtlZeroMemory(pdesk, sizeof(DESKTOP));
2290
2291 /* Set desktop size, based on whether the WinSta is interactive or not */
2292 if (pwinsta == InputWindowStation)
2293 {
2294 /* Check if the Desktop is named "Winlogon" */
2295 if (RtlEqualUnicodeString(DesktopName, &WinlogonDesktop, TRUE))
2296 {
2298 }
2299 else
2300 {
2302 }
2303 }
2304 else
2305 {
2307 }
2308
2309 /* Link the desktop with the parent window station */
2310 ObReferenceObject(pwinsta);
2311 pdesk->rpwinstaParent = pwinsta;
2312 InsertTailList(&pwinsta->DesktopListHead, &pdesk->ListEntry);
2313
2314 /* Create the desktop heap */
2315 pdesk->hsectionDesktop = NULL;
2317 &DesktopHeapSystemBase,
2318 HeapSize);
2319 if (pdesk->pheapDesktop == NULL)
2320 {
2321 ERR("Failed to create desktop heap!\n");
2322 return STATUS_NO_MEMORY;
2323 }
2324
2325 /* Create DESKTOPINFO */
2326 DesktopInfoSize = sizeof(DESKTOPINFO) + DesktopName->Length + sizeof(WCHAR);
2327 pdesk->pDeskInfo = RtlAllocateHeap(pdesk->pheapDesktop,
2329 DesktopInfoSize);
2330 if (pdesk->pDeskInfo == NULL)
2331 {
2332 ERR("Failed to create the DESKTOP structure!\n");
2333 return STATUS_NO_MEMORY;
2334 }
2335
2336 /* Initialize the DESKTOPINFO */
2337 pdesk->pDeskInfo->pvDesktopBase = DesktopHeapSystemBase;
2338 pdesk->pDeskInfo->pvDesktopLimit = (PVOID)((ULONG_PTR)DesktopHeapSystemBase + HeapSize);
2340 DesktopName->Buffer,
2341 DesktopName->Length + sizeof(WCHAR));
2342 for (i = 0; i < NB_HOOKS; i++)
2343 {
2345 }
2346
2348 InitializeListHead(&pdesk->PtiList);
2349
2350 return STATUS_SUCCESS;
2351}
2352
2353/* SYSCALLS *******************************************************************/
2354
2355/*
2356 * NtUserCreateDesktop
2357 *
2358 * Creates a new desktop.
2359 *
2360 * Parameters
2361 * poaAttribs
2362 * Object Attributes.
2363 *
2364 * lpszDesktopDevice
2365 * Name of the device.
2366 *
2367 * pDeviceMode
2368 * Device Mode.
2369 *
2370 * dwFlags
2371 * Interaction flags.
2372 *
2373 * dwDesiredAccess
2374 * Requested type of access.
2375 *
2376 *
2377 * Return Value
2378 * If the function succeeds, the return value is a handle to the newly
2379 * created desktop. If the specified desktop already exists, the function
2380 * succeeds and returns a handle to the existing desktop. When you are
2381 * finished using the handle, call the CloseDesktop function to close it.
2382 * If the function fails, the return value is NULL.
2383 *
2384 * Status
2385 * @implemented
2386 */
2387
2391 OUT HDESK* phDesktop,
2394 IN PUNICODE_STRING lpszDesktopDevice OPTIONAL,
2395 IN LPDEVMODEW lpdmw OPTIONAL,
2397 IN ACCESS_MASK dwDesiredAccess)
2398{
2400 PDESKTOP pdesk = NULL;
2401 HDESK hDesk;
2403 UNICODE_STRING ClassName;
2404 LARGE_STRING WindowName;
2405 BOOL NoHooks = FALSE;
2406 PWND pWnd = NULL;
2407 CREATESTRUCTW Cs;
2408 PTHREADINFO ptiCurrent;
2409 PCLS pcls;
2410
2411 TRACE("Enter IntCreateDesktop\n");
2412
2414
2415 ASSERT(phDesktop);
2416 *phDesktop = NULL;
2417
2418 ptiCurrent = PsGetCurrentThreadWin32Thread();
2419 ASSERT(ptiCurrent);
2421
2422 /* Turn off hooks when calling any CreateWindowEx from inside win32k */
2423 NoHooks = (ptiCurrent->TIF_flags & TIF_DISABLEHOOKS);
2424 ptiCurrent->TIF_flags |= TIF_DISABLEHOOKS;
2425 ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;
2426
2427 /*
2428 * Try to open already existing desktop
2429 */
2432 AccessMode,
2433 NULL,
2434 dwDesiredAccess,
2435 (PVOID)&Context,
2436 (PHANDLE)&hDesk);
2437 if (!NT_SUCCESS(Status))
2438 {
2439 ERR("ObOpenObjectByName failed to open/create desktop\n");
2440 goto Quit;
2441 }
2442
2443 /* In case the object was not created (eg if it existed), return now */
2444 if (Context == FALSE)
2445 {
2446 TRACE("IntCreateDesktop opened desktop '%wZ'\n", ObjectAttributes->ObjectName);
2448 goto Quit;
2449 }
2450
2451 /* Reference the desktop */
2453 0,
2455 KernelMode,
2456 (PVOID*)&pdesk,
2457 NULL);
2458 if (!NT_SUCCESS(Status))
2459 {
2460 ERR("Failed to reference desktop object\n");
2461 goto Quit;
2462 }
2463
2464 /* Get the desktop window class. The thread desktop does not belong to any desktop
2465 * so the classes created there (including the desktop class) are allocated in the shared heap
2466 * It would cause problems if we used a class that belongs to the caller
2467 */
2468 ClassName.Buffer = WC_DESKTOP;
2469 ClassName.Length = 0;
2470 pcls = IntGetAndReferenceClass(&ClassName, 0, TRUE);
2471 if (pcls == NULL)
2472 {
2473 ASSERT(FALSE);
2475 goto Quit;
2476 }
2477
2478 RtlZeroMemory(&WindowName, sizeof(WindowName));
2479 RtlZeroMemory(&Cs, sizeof(Cs));
2485 Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
2486 Cs.lpszName = (LPCWSTR) &WindowName;
2487 Cs.lpszClass = (LPCWSTR) &ClassName;
2488
2489 /* Use IntCreateWindow instead of co_UserCreateWindowEx because the later expects a thread with a desktop */
2490 pWnd = IntCreateWindow(&Cs, &WindowName, pcls, NULL, NULL, NULL, pdesk, WINVER);
2491 if (pWnd == NULL)
2492 {
2493 ERR("Failed to create desktop window for the new desktop\n");
2495 goto Quit;
2496 }
2497
2499 pdesk->DesktopWindow = UserHMGetHandle(pWnd);
2500 pdesk->pDeskInfo->spwnd = pWnd;
2501 pWnd->fnid = FNID_DESKTOP;
2502
2503 ClassName.Buffer = MAKEINTATOM(gpsi->atomSysClass[ICLS_HWNDMESSAGE]);
2504 ClassName.Length = 0;
2505 pcls = IntGetAndReferenceClass(&ClassName, 0, TRUE);
2506 if (pcls == NULL)
2507 {
2508 ASSERT(FALSE);
2510 goto Quit;
2511 }
2512
2513 RtlZeroMemory(&WindowName, sizeof(WindowName));
2514 RtlZeroMemory(&Cs, sizeof(Cs));
2515 Cs.cx = Cs.cy = 100;
2517 Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
2518 Cs.lpszName = (LPCWSTR)&WindowName;
2519 Cs.lpszClass = (LPCWSTR)&ClassName;
2520 pWnd = IntCreateWindow(&Cs, &WindowName, pcls, NULL, NULL, NULL, pdesk, WINVER);
2521 if (pWnd == NULL)
2522 {
2523 ERR("Failed to create message window for the new desktop\n");
2525 goto Quit;
2526 }
2527
2528 pdesk->spwndMessage = pWnd;
2529 pWnd->fnid = FNID_MESSAGEWND;
2530
2531 /* Now...
2532 if !(WinStaObject->Flags & WSF_NOIO) is (not set) for desktop input output mode (see wiki)
2533 Create Tooltip. Saved in DesktopObject->spwndTooltip.
2534 Tooltip dwExStyle: WS_EX_TOOLWINDOW|WS_EX_TOPMOST
2535 hWndParent are spwndMessage. Use hModuleWin for server side winproc!
2536 The rest is same as message window.
2537 https://learn.microsoft.com/en-us/windows/win32/controls/tooltip-controls
2538 */
2540
2541Quit:
2542 if (pdesk != NULL)
2543 {
2544 ObDereferenceObject(pdesk);
2545 }
2546 if (!NT_SUCCESS(Status) && hDesk != NULL)
2547 {
2548 ObCloseHandle(hDesk, AccessMode);
2549 hDesk = NULL;
2550 }
2551 if (!NoHooks)
2552 {
2553 ptiCurrent->TIF_flags &= ~TIF_DISABLEHOOKS;
2554 ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;
2555 }
2556
2557 TRACE("Leave IntCreateDesktop, Status 0x%08lx\n", Status);
2558
2559 if (NT_SUCCESS(Status))
2560 *phDesktop = hDesk;
2561 else
2563 return Status;
2564}
2565
2566HDESK APIENTRY
2569 PUNICODE_STRING lpszDesktopDevice,
2570 LPDEVMODEW lpdmw,
2571 DWORD dwFlags,
2572 ACCESS_MASK dwDesiredAccess)
2573{
2575 HDESK hDesk;
2576 HDESK Ret = NULL;
2577
2578 TRACE("Enter NtUserCreateDesktop\n");
2580
2581 Status = IntCreateDesktop(&hDesk,
2583 UserMode,
2584 lpszDesktopDevice,
2585 lpdmw,
2586 dwFlags,
2587 dwDesiredAccess);
2588 if (!NT_SUCCESS(Status))
2589 {
2590 ERR("IntCreateDesktop failed, Status 0x%08lx\n", Status);
2591 // SetLastNtError(Status);
2592 goto Exit; // Return NULL
2593 }
2594
2595 Ret = hDesk;
2596
2597Exit:
2598 TRACE("Leave NtUserCreateDesktop, ret=0x%p\n", Ret);
2599 UserLeave();
2600 return Ret;
2601}
2602
2603/*
2604 * NtUserOpenDesktop
2605 *
2606 * Opens an existing desktop.
2607 *
2608 * Parameters
2609 * lpszDesktopName
2610 * Name of the existing desktop.
2611 *
2612 * dwFlags
2613 * Interaction flags.
2614 *
2615 * dwDesiredAccess
2616 * Requested type of access.
2617 *
2618 * Return Value
2619 * Handle to the desktop or zero on failure.
2620 *
2621 * Status
2622 * @implemented
2623 */
2624
2625HDESK APIENTRY
2628 DWORD dwFlags,
2629 ACCESS_MASK dwDesiredAccess)
2630{
2632 HDESK Desktop;
2633
2637 UserMode,
2638 NULL,
2639 dwDesiredAccess,
2640 NULL,
2641 (HANDLE*)&Desktop);
2642
2643 if (!NT_SUCCESS(Status))
2644 {
2645 ERR("Failed to open desktop\n");
2647 return NULL;
2648 }
2649
2650 TRACE("Opened desktop %S with handle 0x%p\n", ObjectAttributes->ObjectName->Buffer, Desktop);
2651
2652 return Desktop;
2653}
2654
2656 BOOL fInherit,
2657 ACCESS_MASK dwDesiredAccess)
2658{
2662 HDESK hdesk = NULL;
2663
2664 if (!gpdeskInputDesktop)
2665 {
2666 return NULL;
2667 }
2668
2669 if (pti->ppi->prpwinsta != InputWindowStation)
2670 {
2671 ERR("Tried to open input desktop from non interactive winsta!\n");
2673 return NULL;
2674 }
2675
2676 if (fInherit) HandleAttributes = OBJ_INHERIT;
2677
2678 /* Create a new handle to the object */
2682 NULL,
2683 dwDesiredAccess,
2685 UserMode,
2686 (PHANDLE)&hdesk);
2687
2688 if (!NT_SUCCESS(Status))
2689 {
2690 ERR("Failed to open input desktop object\n");
2692 }
2693
2694 return hdesk;
2695}
2696
2697/*
2698 * NtUserOpenInputDesktop
2699 *
2700 * Opens the input (interactive) desktop.
2701 *
2702 * Parameters
2703 * dwFlags
2704 * Interaction flags.
2705 *
2706 * fInherit
2707 * Inheritance option.
2708 *
2709 * dwDesiredAccess
2710 * Requested type of access.
2711 *
2712 * Return Value
2713 * Handle to the input desktop or zero on failure.
2714 *
2715 * Status
2716 * @implemented
2717 */
2718
2719HDESK APIENTRY
2721 DWORD dwFlags,
2722 BOOL fInherit,
2723 ACCESS_MASK dwDesiredAccess)
2724{
2725 HDESK hdesk;
2726
2728 TRACE("Enter NtUserOpenInputDesktop gpdeskInputDesktop 0x%p\n", gpdeskInputDesktop);
2729
2730 hdesk = UserOpenInputDesktop(dwFlags, fInherit, dwDesiredAccess);
2731
2732 TRACE("NtUserOpenInputDesktop returning 0x%p\n", hdesk);
2733 UserLeave();
2734 return hdesk;
2735}
2736
2737/*
2738 * NtUserCloseDesktop
2739 *
2740 * Closes a desktop handle.
2741 *
2742 * Parameters
2743 * hDesktop
2744 * Handle to the desktop.
2745 *
2746 * Return Value
2747 * Status
2748 *
2749 * Remarks
2750 * The desktop handle can be created with NtUserCreateDesktop or
2751 * NtUserOpenDesktop. This function will fail if any thread in the calling
2752 * process is using the specified desktop handle or if the handle refers
2753 * to the initial desktop of the calling process.
2754 *
2755 * Status
2756 * @implemented
2757 */
2758
2760NtUserCloseDesktop(HDESK hDesktop)
2761{
2762 PDESKTOP pdesk;
2764 BOOL Ret = FALSE;
2765
2766 TRACE("NtUserCloseDesktop(0x%p) called\n", hDesktop);
2768
2769 if (hDesktop == gptiCurrent->hdesk || hDesktop == gptiCurrent->ppi->hdeskStartup)
2770 {
2771 ERR("Attempted to close thread desktop\n");
2773 goto Exit; // Return FALSE
2774 }
2775
2776 Status = IntValidateDesktopHandle(hDesktop, UserMode, 0, &pdesk);
2777 if (!NT_SUCCESS(Status))
2778 {
2779 ERR("Validation of desktop handle 0x%p failed\n", hDesktop);
2780 goto Exit; // Return FALSE
2781 }
2782
2783 ObDereferenceObject(pdesk);
2784
2785 Status = ObCloseHandle(hDesktop, UserMode);
2786 if (!NT_SUCCESS(Status))
2787 {
2788 ERR("Failed to close desktop handle 0x%p\n", hDesktop);
2790 goto Exit; // Return FALSE
2791 }
2792
2793 Ret = TRUE;
2794
2795Exit:
2796 TRACE("Leave NtUserCloseDesktop, ret=%i\n", Ret);
2797 UserLeave();
2798 return Ret;
2799}
2800
2801/*
2802 * NtUserPaintDesktop
2803 *
2804 * The NtUserPaintDesktop function fills the clipping region in the
2805 * specified device context with the desktop pattern or wallpaper. The
2806 * function is provided primarily for shell desktops.
2807 *
2808 * Parameters
2809 * hDC
2810 * Handle to the device context.
2811 *
2812 * Status
2813 * @implemented
2814 */
2815
2818{
2819 BOOL Ret;
2820
2822 TRACE("Enter NtUserPaintDesktop\n");
2823
2824 Ret = IntPaintDesktop(hDC);
2825
2826 TRACE("Leave NtUserPaintDesktop, ret=%i\n", Ret);
2827 UserLeave();
2828 return Ret;
2829}
2830
2831/*
2832 * NtUserResolveDesktop
2833 *
2834 * The NtUserResolveDesktop function attempts to retrieve valid handles to
2835 * a desktop and a window station suitable for the specified process.
2836 * The specified desktop path string is used only as a hint for the resolution.
2837 *
2838 * See the description of IntResolveDesktop for more details.
2839 *
2840 * Parameters
2841 * ProcessHandle
2842 * Handle to a user process.
2843 *
2844 * DesktopPath
2845 * The desktop path string used as a hint for desktop resolution.
2846 *
2847 * bInherit
2848 * Whether or not the returned handles are inheritable.
2849 *
2850 * phWinSta
2851 * Pointer to a window station handle.
2852 *
2853 * Return Value
2854 * Handle to the desktop (direct return value) and
2855 * handle to the associated window station (by pointer).
2856 * NULL in case of failure.
2857 *
2858 * Remarks
2859 * Callable by CSRSS only.
2860 *
2861 * Status
2862 * @implemented
2863 */
2864
2865HDESK
2866NTAPI
2869 IN PUNICODE_STRING DesktopPath,
2870 IN BOOL bInherit,
2871 OUT HWINSTA* phWinSta)
2872{
2875 HWINSTA hWinSta = NULL;
2876 HDESK hDesktop = NULL;
2877 UNICODE_STRING CapturedDesktopPath;
2878
2879 /* Allow only the Console Server to perform this operation (via CSRSS) */
2881 return NULL;
2882
2883 /* Get the process object the user handle was referencing */
2887 UserMode,
2888 (PVOID*)&Process,
2889 NULL);
2890 if (!NT_SUCCESS(Status))
2891 return NULL;
2892
2894
2895 _SEH2_TRY
2896 {
2897 /* Probe the handle pointer */
2898 // ProbeForWriteHandle
2899 ProbeForWrite(phWinSta, sizeof(HWINSTA), sizeof(HWINSTA));
2900 }
2902 {
2904 _SEH2_YIELD(goto Quit);
2905 }
2906 _SEH2_END;
2907
2908 /* Capture the user desktop path string */
2909 Status = ProbeAndCaptureUnicodeString(&CapturedDesktopPath,
2910 UserMode,
2911 DesktopPath);
2912 if (!NT_SUCCESS(Status))
2913 goto Quit;
2914
2915 /* Call the internal function */
2917 &CapturedDesktopPath,
2918 bInherit,
2919 &hWinSta,
2920 &hDesktop);
2921 if (!NT_SUCCESS(Status))
2922 {
2923 ERR("IntResolveDesktop failed, Status 0x%08lx\n", Status);
2924 hWinSta = NULL;
2925 hDesktop = NULL;
2926 }
2927
2928 _SEH2_TRY
2929 {
2930 /* Return the window station handle */
2931 *phWinSta = hWinSta;
2932 }
2934 {
2936
2937 /* We failed, close the opened desktop and window station */
2938 if (hDesktop) ObCloseHandle(hDesktop, UserMode);
2939 hDesktop = NULL;
2940 if (hWinSta) ObCloseHandle(hWinSta, UserMode);
2941 }
2942 _SEH2_END;
2943
2944 /* Free the captured string */
2945 ReleaseCapturedUnicodeString(&CapturedDesktopPath, UserMode);
2946
2947Quit:
2948 UserLeave();
2949
2950 /* Dereference the process object */
2952
2953 /* Return the desktop handle */
2954 return hDesktop;
2955}
2956
2957/*
2958 * NtUserSwitchDesktop
2959 *
2960 * Sets the current input (interactive) desktop.
2961 *
2962 * Parameters
2963 * hDesktop
2964 * Handle to desktop.
2965 *
2966 * Return Value
2967 * Status
2968 *
2969 * Status
2970 * @unimplemented
2971 */
2972
2975{
2976 PDESKTOP pdesk;
2978 BOOL bRedrawDesktop;
2979 BOOL Ret = FALSE;
2980
2982 TRACE("Enter NtUserSwitchDesktop(0x%p)\n", hdesk);
2983
2984 Status = IntValidateDesktopHandle(hdesk, UserMode, 0, &pdesk);
2985 if (!NT_SUCCESS(Status))
2986 {
2987 ERR("Validation of desktop handle 0x%p failed\n", hdesk);
2988 goto Exit; // Return FALSE
2989 }
2990
2991 if (PsGetCurrentProcessSessionId() != pdesk->rpwinstaParent->dwSessionId)
2992 {
2993 ObDereferenceObject(pdesk);
2994 ERR("NtUserSwitchDesktop called for a desktop of a different session\n");
2995 goto Exit; // Return FALSE
2996 }
2997
2998 if (pdesk == gpdeskInputDesktop)
2999 {
3000 ObDereferenceObject(pdesk);
3001 WARN("NtUserSwitchDesktop called for active desktop\n");
3002 Ret = TRUE;
3003 goto Exit;
3004 }
3005
3006 /*
3007 * Don't allow applications switch the desktop if it's locked, unless the caller
3008 * is the logon application itself
3009 */
3010 if ((pdesk->rpwinstaParent->Flags & WSS_LOCKED) &&
3012 {
3013 ObDereferenceObject(pdesk);
3014 ERR("Switching desktop 0x%p denied because the window station is locked!\n", hdesk);
3015 goto Exit; // Return FALSE
3016 }
3017
3018 if (pdesk->rpwinstaParent != InputWindowStation)
3019 {
3020 ObDereferenceObject(pdesk);
3021 ERR("Switching desktop 0x%p denied because desktop doesn't belong to the interactive winsta!\n", hdesk);
3022 goto Exit; // Return FALSE
3023 }
3024
3025 /* FIXME: Fail if the process is associated with a secured
3026 desktop such as Winlogon or Screen-Saver */
3027 /* FIXME: Connect to input device */
3028
3029 TRACE("Switching from desktop 0x%p to 0x%p\n", gpdeskInputDesktop, pdesk);
3030
3031 bRedrawDesktop = FALSE;
3032
3033 /* The first time SwitchDesktop is called, gpdeskInputDesktop is NULL */
3034 if (gpdeskInputDesktop != NULL)
3035 {
3037 bRedrawDesktop = TRUE;
3038
3039 /* Hide the previous desktop window */
3041 }
3042
3043 /* Set the active desktop in the desktop's window station. */
3045
3046 /* Set the global state. */
3047 gpdeskInputDesktop = pdesk;
3048
3049 /* Show the new desktop window */
3051
3052 TRACE("SwitchDesktop gpdeskInputDesktop 0x%p\n", gpdeskInputDesktop);
3053 ObDereferenceObject(pdesk);
3054
3055 Ret = TRUE;
3056
3057Exit:
3058 TRACE("Leave NtUserSwitchDesktop, ret=%i\n", Ret);
3059 UserLeave();
3060 return Ret;
3061}
3062
3063/*
3064 * NtUserGetThreadDesktop
3065 *
3066 * Status
3067 * @implemented
3068 */
3069
3070HDESK APIENTRY
3072{
3073 HDESK hDesk;
3075 PTHREADINFO pti;
3077 PDESKTOP DesktopObject;
3079
3081 TRACE("Enter NtUserGetThreadDesktop\n");
3082
3083 if (!dwThreadId)
3084 {
3086 hDesk = NULL;
3087 goto Quit;
3088 }
3089
3090 /* Validate the Win32 thread and retrieve its information */
3092 if (pti)
3093 {
3094 /* Get the desktop handle of the thread */
3095 hDesk = pti->hdesk;
3096 Process = pti->ppi->peProcess;
3097 }
3098 else if (hConsoleDesktop)
3099 {
3100 /*
3101 * The thread may belong to a console, so attempt to use the provided
3102 * console desktop handle as a fallback. Otherwise this means that the
3103 * thread is either not Win32 or invalid.
3104 */
3105 hDesk = hConsoleDesktop;
3107 }
3108 else
3109 {
3111 hDesk = NULL;
3112 goto Quit;
3113 }
3114
3115 if (!hDesk)
3116 {
3117 ERR("Desktop information of thread 0x%x broken!?\n", dwThreadId);
3118 goto Quit;
3119 }
3120
3122 {
3123 /*
3124 * Just return the handle, since we queried the desktop handle
3125 * of a thread running in the same context.
3126 */
3127 goto Quit;
3128 }
3129
3130 /*
3131 * We could just use the cached rpdesk instead of looking up the handle,
3132 * but it may actually be safer to validate the desktop and get a temporary
3133 * reference to it so that it does not disappear under us (e.g. when the
3134 * desktop is being destroyed) during the operation.
3135 */
3136 /*
3137 * Switch into the context of the thread we are trying to get
3138 * the desktop from, so we can use the handle.
3139 */
3140 KeAttachProcess(&Process->Pcb);
3142 0,
3144 UserMode,
3145 (PVOID*)&DesktopObject,
3148
3149 if (NT_SUCCESS(Status))
3150 {
3151 /*
3152 * Lookup our handle table if we can find a handle to the desktop object.
3153 * If not, create one.
3154 * QUESTION: Do we really need to create a handle in case it doesn't exist??
3155 */
3156 hDesk = IntGetDesktopObjectHandle(DesktopObject);
3157
3158 /* All done, we got a valid handle to the desktop */
3159 ObDereferenceObject(DesktopObject);
3160 }
3161 else
3162 {
3163 /* The handle could not be found, there is nothing to get... */
3164 hDesk = NULL;
3165 }
3166
3167 if (!hDesk)
3168 {
3169 ERR("Could not retrieve or access desktop for thread 0x%x\n", dwThreadId);
3171 }
3172
3173Quit:
3174 TRACE("Leave NtUserGetThreadDesktop, hDesk = 0x%p\n", hDesk);
3175 UserLeave();
3176 return hDesk;
3177}
3178
3179static NTSTATUS
3181{
3182 PPROCESSINFO ppi;
3183 PW32HEAP_USER_MAPPING HeapMapping, *PrevLink;
3185
3186 TRACE("IntUnmapDesktopView called for desktop object %p\n", pdesk);
3187
3189
3190 /*
3191 * Unmap if we're the last thread using the desktop.
3192 * Start the search at the next mapping: skip the first entry
3193 * as it must be the global user heap mapping.
3194 */
3195 PrevLink = &ppi->HeapMappings.Next;
3196 HeapMapping = *PrevLink;
3197 while (HeapMapping != NULL)
3198 {
3199 if (HeapMapping->KernelMapping == (PVOID)pdesk->pheapDesktop)
3200 {
3201 if (--HeapMapping->Count == 0)
3202 {
3203 *PrevLink = HeapMapping->Next;
3204
3205 TRACE("ppi 0x%p unmapped heap of desktop 0x%p\n", ppi, pdesk);
3207 HeapMapping->UserMapping);
3208
3209 ObDereferenceObject(pdesk);
3210
3211 UserHeapFree(HeapMapping);
3212 break;
3213 }
3214 }
3215
3216 PrevLink = &HeapMapping->Next;
3217 HeapMapping = HeapMapping->Next;
3218 }
3219
3220 return Status;
3221}
3222
3223static NTSTATUS
3225{
3226 PPROCESSINFO ppi;
3227 PW32HEAP_USER_MAPPING HeapMapping, *PrevLink;
3228 PVOID UserBase = NULL;
3229 SIZE_T ViewSize = 0;
3232
3233 TRACE("IntMapDesktopView called for desktop object 0x%p\n", pdesk);
3234
3236
3237 /*
3238 * Find out if another thread already mapped the desktop heap.
3239 * Start the search at the next mapping: skip the first entry
3240 * as it must be the global user heap mapping.
3241 */
3242 PrevLink = &ppi->HeapMappings.Next;
3243 HeapMapping = *PrevLink;
3244 while (HeapMapping != NULL)
3245 {
3246 if (HeapMapping->KernelMapping == (PVOID)pdesk->pheapDesktop)
3247 {
3248 HeapMapping->Count++;
3249 return STATUS_SUCCESS;
3250 }
3251
3252 PrevLink = &HeapMapping->Next;
3253 HeapMapping = HeapMapping->Next;
3254 }
3255
3256 /* We're the first, map the heap */
3257 Offset.QuadPart = 0;
3258 Status = MmMapViewOfSection(pdesk->hsectionDesktop,
3260 &UserBase,
3261 0,
3262 0,
3263 &Offset,
3264 &ViewSize,
3265 ViewUnmap,
3268 if (!NT_SUCCESS(Status))
3269 {
3270 ERR("Failed to map desktop\n");
3271 return Status;
3272 }
3273
3274 TRACE("ppi 0x%p mapped heap of desktop 0x%p\n", ppi, pdesk);
3275
3276 /* Add the mapping */
3277 HeapMapping = UserHeapAlloc(sizeof(*HeapMapping));
3278 if (HeapMapping == NULL)
3279 {
3281 ERR("UserHeapAlloc() failed!\n");
3282 return STATUS_NO_MEMORY;
3283 }
3284
3285 HeapMapping->Next = NULL;
3286 HeapMapping->KernelMapping = (PVOID)pdesk->pheapDesktop;
3287 HeapMapping->UserMapping = UserBase;
3288 HeapMapping->Limit = ViewSize;
3289 HeapMapping->Count = 1;
3290 *PrevLink = HeapMapping;
3291
3292 ObReferenceObject(pdesk);
3293
3294 return STATUS_SUCCESS;
3295}
3296
3297BOOL
3299 IN BOOL FreeOnFailure)
3300{
3301 PDESKTOP pdesk = NULL, pdeskOld;
3302 PTHREADINFO pti;
3304 PCLIENTTHREADINFO pctiOld, pctiNew = NULL;
3305 PCLIENTINFO pci;
3306
3308
3309 TRACE("IntSetThreadDesktop hDesktop:0x%p, FOF:%i\n",hDesktop, FreeOnFailure);
3310
3312 pci = pti->pClientInfo;
3313
3314 /* If the caller gave us a desktop, ensure it is valid */
3315 if (hDesktop != NULL)
3316 {
3317 /* Validate the new desktop. */
3318 Status = IntValidateDesktopHandle(hDesktop, UserMode, 0, &pdesk);
3319 if (!NT_SUCCESS(Status))
3320 {
3321 ERR("Validation of desktop handle 0x%p failed\n", hDesktop);
3322 return FALSE;
3323 }
3324
3325 if (pti->rpdesk == pdesk)
3326 {
3327 /* Nothing to do */
3328 ObDereferenceObject(pdesk);
3329 return TRUE;
3330 }
3331 }
3332
3333 /* Make sure that we don't own any window in the current desktop */
3334 if (!IsListEmpty(&pti->WindowListHead))
3335 {
3336 if (pdesk)
3337 ObDereferenceObject(pdesk);
3338 ERR("Attempted to change thread desktop although the thread has windows!\n");
3340 return FALSE;
3341 }
3342
3343 /* Desktop is being re-set so clear out foreground. */
3344 if (pti->rpdesk != pdesk && pti->MessageQueue == gpqForeground)
3345 {
3346 // Like above, there shouldn't be any windows, hooks or anything active on this threads desktop!
3348 }
3349
3350 /* Before doing the switch, map the new desktop heap and allocate the new pcti */
3351 if (pdesk != NULL)
3352 {
3353 Status = IntMapDesktopView(pdesk);
3354 if (!NT_SUCCESS(Status))
3355 {
3356 ERR("Failed to map desktop heap!\n");
3357 ObDereferenceObject(pdesk);
3359 return FALSE;
3360 }
3361
3362 pctiNew = DesktopHeapAlloc(pdesk, sizeof(CLIENTTHREADINFO));
3363 if (pctiNew == NULL)
3364 {
3365 ERR("Failed to allocate new pcti\n");
3366 IntUnmapDesktopView(pdesk);
3367 ObDereferenceObject(pdesk);
3369 return FALSE;
3370 }
3371 }
3372
3373 /*
3374 * Processes, in particular Winlogon.exe, that manage window stations
3375 * (especially the interactive WinSta0 window station) and desktops,
3376 * may not be able to connect at startup to a window station and have
3377 * an associated desktop as well, if none exists on the system already.
3378 * Because creating a new window station does not affect the window station
3379 * associated to the process, and because neither by associating a window
3380 * station to the process nor creating a new desktop on it does associate
3381 * a startup desktop to that process, the process has to actually assigns
3382 * one of its threads to a desktop so that it gets automatically an assigned
3383 * startup desktop.
3384 *
3385 * This is what actually happens for Winlogon.exe, which is started without
3386 * any window station and desktop. By creating the first (and therefore
3387 * interactive) WinSta0 window station, then assigning WinSta0 to itself
3388 * and creating the Default desktop on it, and then assigning this desktop
3389 * to its main thread, Winlogon.exe basically does the similar steps that
3390 * would have been done automatically at its startup if there were already
3391 * an existing WinSta0 window station and Default desktop.
3392 *
3393 * Of course all this must not be done if we are a SYSTEM or CSRSS thread.
3394 */
3395 // if (pti->ppi->peProcess != gpepCSRSS)
3396 if (!(pti->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)) &&
3397 pti->ppi->rpdeskStartup == NULL && hDesktop != NULL)
3398 {
3399 ERR("The process 0x%p '%s' didn't have an assigned startup desktop before, assigning it now!\n",
3400 pti->ppi->peProcess, pti->ppi->peProcess->ImageFileName);
3401
3402 pti->ppi->hdeskStartup = hDesktop;
3403 pti->ppi->rpdeskStartup = pdesk;
3404 }
3405
3406 /* free all classes or move them to the shared heap */
3407 if (pti->rpdesk != NULL)
3408 {
3409 if (!IntCheckProcessDesktopClasses(pti->rpdesk, FreeOnFailure))
3410 {
3411 ERR("Failed to move process classes to shared heap!\n");
3412 if (pdesk)
3413 {
3414 DesktopHeapFree(pdesk, pctiNew);
3415 IntUnmapDesktopView(pdesk);
3416 ObDereferenceObject(pdesk);
3417 }
3418 return FALSE;
3419 }
3420 }
3421
3422 pdeskOld = pti->rpdesk;
3423 if (pti->pcti != &pti->cti)
3424 pctiOld = pti->pcti;
3425 else
3426 pctiOld = NULL;
3427
3428 /* do the switch */
3429 if (pdesk != NULL)
3430 {
3431 pti->rpdesk = pdesk;
3432 pti->hdesk = hDesktop;
3433 pti->pDeskInfo = pti->rpdesk->pDeskInfo;
3434 pti->pcti = pctiNew;
3435
3437 pci->pDeskInfo = (PVOID)((ULONG_PTR)pti->pDeskInfo - pci->ulClientDelta);
3438 pci->pClientThreadInfo = (PVOID)((ULONG_PTR)pti->pcti - pci->ulClientDelta);
3439
3440 /* initialize the new pcti */
3441 if (pctiOld != NULL)
3442 {
3443 RtlCopyMemory(pctiNew, pctiOld, sizeof(CLIENTTHREADINFO));
3444 }
3445 else
3446 {
3447 RtlZeroMemory(pctiNew, sizeof(CLIENTTHREADINFO));
3448 pci->fsHooks = pti->fsHooks;
3449 pci->dwTIFlags = pti->TIF_flags;
3450 }
3451 }
3452 else
3453 {
3454 pti->rpdesk = NULL;
3455 pti->hdesk = NULL;
3456 pti->pDeskInfo = NULL;
3457 pti->pcti = &pti->cti; // Always point inside so there will be no crash when posting or sending msg's!
3458 pci->ulClientDelta = 0;
3459 pci->pDeskInfo = NULL;
3460 pci->pClientThreadInfo = NULL;
3461 }
3462
3463 /* clean up the old desktop */
3464 if (pdeskOld != NULL)
3465 {
3466 RemoveEntryList(&pti->PtiLink);
3467 if (pctiOld) DesktopHeapFree(pdeskOld, pctiOld);
3468 IntUnmapDesktopView(pdeskOld);
3469 ObDereferenceObject(pdeskOld);
3470 }
3471
3472 if (pdesk)
3473 {
3474 InsertTailList(&pdesk->PtiList, &pti->PtiLink);
3475 }
3476
3477 TRACE("IntSetThreadDesktop: pti 0x%p ppi 0x%p switched from object 0x%p to 0x%p\n", pti, pti->ppi, pdeskOld, pdesk);
3478
3479 return TRUE;
3480}
3481
3482/*
3483 * NtUserSetThreadDesktop
3484 *
3485 * Status
3486 * @implemented
3487 */
3488
3491{
3492 BOOL ret = FALSE;
3493
3495
3496 // FIXME: IntSetThreadDesktop validates the desktop handle, it should happen
3497 // here too and set the NT error level. Q. Is it necessary to have the validation
3498 // in IntSetThreadDesktop? Is it needed there too?
3499 if (hDesktop || (!hDesktop && PsGetCurrentProcess() == gpepCSRSS))
3500 ret = IntSetThreadDesktop(hDesktop, FALSE);
3501
3502 UserLeave();
3503
3504 return ret;
3505}
3506
3507/* EOF */
static HDC hDC
Definition: 3dtext.c:33
NTSTATUS NTAPI MmUnmapViewInSessionSpace(IN PVOID MappedBase)
Definition: section.c:2724
NTSTATUS NTAPI MmUnmapViewOfSection(IN PEPROCESS Process, IN PVOID BaseAddress)
Definition: section.c:2752
#define CODE_SEG(...)
static _In_ LPCWSTR _In_ DWORD _In_ int _In_ int cchDest
unsigned char BOOLEAN
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
HWND hWnd
Definition: settings.c:17
LONG NTSTATUS
Definition: precomp.h:26
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
#define UlongToHandle(ul)
Definition: basetsd.h:97
#define HandleToULong(h)
Definition: basetsd.h:95
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:106
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:616
_Inout_ PFCB _Inout_ PUNICODE_STRING RemainingName
Definition: cdprocs.h:802
Definition: list.h:37
WPARAM wParam
Definition: combotst.c:138
struct @1681 Msg[]
LPARAM lParam
Definition: combotst.c:139
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
PEPROCESS gpepCSRSS
Definition: csr.c:15
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:238
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
@ DCTYPE_DIRECT
Definition: dc.h:41
UINT FASTCALL IntGdiSetTextAlign(HDC hDC, UINT Mode)
Definition: dcutil.c:145
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode)
Definition: dcutil.c:124
HDC FASTCALL IntGdiCreateDisplayDC(HDEV hDev, ULONG DcType, BOOL EmptyDC)
Definition: dclife.c:1063
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:220
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_BUSY
Definition: dderror.h:12
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
NTSTATUS NTAPI RtlGetVersion(IN OUT PRTL_OSVERSIONINFOW lpVersionInformation)
Definition: version.c:182
#define APIENTRY
Definition: api.h:79
#define wcschr
Definition: compat.h:17
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define PAGE_READONLY
Definition: compat.h:138
#define wcsrchr
Definition: compat.h:16
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
static const WCHAR Message[]
Definition: register.c:74
#define RGB(r, g, b)
Definition: precomp.h:71
#define GetBValue(quad)
Definition: precomp.h:75
#define GetGValue(quad)
Definition: precomp.h:74
#define GetRValue(quad)
Definition: precomp.h:73
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
UNICODE_STRING * PUNICODE_STRING
Definition: env_spec_w32.h:373
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define NonPagedPool
Definition: env_spec_w32.h:307
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define PagedPool
Definition: env_spec_w32.h:308
#define ERROR(name)
Definition: error_private.h:53
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
DWORD dwThreadId
Definition: fdebug.c:31
PsGetCurrentThreadId
Definition: CrNtStubs.h:8
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
PTHREADINFO ptiLastInput
Definition: focus.c:18
PUSER_MESSAGE_QUEUE gpqForegroundPrev
Definition: focus.c:14
BOOL APIENTRY GreExtTextOutW(_In_ HDC hDC, _In_ INT XStart, _In_ INT YStart, _In_ UINT fuOptions, _In_opt_ PRECTL lprc, _In_reads_opt_(Count) PCWCH String, _In_ INT Count, _In_opt_ const INT *Dx, _In_ DWORD dwCodePage)
Definition: freetype.c:7504
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Status
Definition: gdiplustypes.h:25
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLdouble n
Definition: glext.h:7729
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ISITHOOKED(HookId)
Definition: hook.h:6
const char cursor[]
Definition: icontest.c:13
PSERVERINFO gpsi
Definition: imm.c:18
_Check_return_ _CRTIMP int __cdecl _scwprintf(_In_z_ _Printf_format_string_ const wchar_t *_Format,...)
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:167
#define TIF_CSRSSTHREAD
Definition: ntuser.h:266
#define FNID_DESTROY
Definition: ntuser.h:898
#define FNID_DESKTOP
Definition: ntuser.h:862
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define CURSORF_CURRENT
Definition: ntuser.h:1207
struct _DESKTOPINFO DESKTOPINFO
#define FNID_MESSAGEWND
Definition: ntuser.h:864
#define TIF_SYSTEMTHREAD
Definition: ntuser.h:265
#define NB_HOOKS
Definition: ntuser.h:127
#define TIF_DISABLEHOOKS
Definition: ntuser.h:291
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define OBJ_OPENIF
Definition: winternl.h:229
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define OBJ_INHERIT
Definition: winternl.h:225
NTSYSAPI NTSTATUS WINAPI RtlQueryRegistryValues(ULONG, PCWSTR, PRTL_QUERY_REGISTRY_TABLE, PVOID, PVOID)
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
#define NOTHING
Definition: input_list.c:10
#define NtCurrentTeb
if(dx< 0)
Definition: linetemp.h:194
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:71
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define DESKTOP_ALL_ACCESS
Definition: precomp.h:22
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:88
static LPCSTR lpstr
Definition: font.c:51
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
ObjectType
Definition: metafile.c:81
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define min(a, b)
Definition: monoChain.cc:55
PCURICON_OBJECT FASTCALL UserSetCursor(PCURICON_OBJECT NewCursor, BOOL ForceChange)
Definition: msgqueue.c:93
#define IntReferenceMessageQueue(MsgQueue)
Definition: msgqueue.h:217
#define IntDereferenceMessageQueue(MsgQueue)
Definition: msgqueue.h:220
struct _USER_MESSAGE_QUEUE * PUSER_MESSAGE_QUEUE
unsigned int UINT
Definition: ndis.h:50
#define KernelMode
Definition: asm.h:38
#define UserMode
Definition: asm.h:39
_In_ HANDLE ProcessHandle
Definition: mmfuncs.h:403
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
#define SEC_NO_CHANGE
Definition: mmtypes.h:95
_In_ HANDLE _In_opt_ HANDLE _Out_opt_ PHANDLE _In_ ACCESS_MASK _In_ ULONG HandleAttributes
Definition: obfuncs.h:433
#define _In_
Definition: no_sal2.h:158
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define PAGE_READWRITE
Definition: nt_native.h:1304
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
#define FASTCALL
Definition: nt_native.h:50
#define RTL_REGISTRY_WINDOWS_NT
Definition: nt_native.h:164
#define RTL_QUERY_REGISTRY_DIRECT
Definition: nt_native.h:144
@ ViewUnmap
Definition: nt_native.h:1279
#define MEM_RELEASE
Definition: nt_native.h:1316
#define REG_NONE
Definition: nt_native.h:1492
#define MEM_COMMIT
Definition: nt_native.h:1313
#define HEAP_NO_SERIALIZE
Definition: nt_native.h:1692
#define MAXIMUM_ALLOWED
Definition: nt_native.h:83
#define UNICODE_NULL
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
@ SynchronizationEvent
__kernel_entry W32KAPI HDC APIENTRY NtGdiCreateCompatibleDC(_In_opt_ HDC hdc)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiStretchBlt(_In_ HDC hdcDst, _In_ INT xDst, _In_ INT yDst, _In_ INT cxDst, _In_ INT cyDst, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ INT cxSrc, _In_ INT cySrc, _In_ DWORD dwRop, _In_ DWORD dwBackColor)
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbm)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiPatBlt(_In_ HDC hdcDest, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_ DWORD dwRop)
Definition: bitblt.c:990
__kernel_entry W32KAPI BOOL APIENTRY NtGdiDeleteObjectApp(_In_ HANDLE hobj)
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
PVOID NTAPI PsGetProcessWin32Process(PEPROCESS Process)
Definition: process.c:1193
POBJECT_TYPE PsProcessType
Definition: process.c:20
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
HANDLE NTAPI PsGetCurrentProcessId(VOID)
Definition: process.c:1123
ULONG NTAPI PsGetCurrentProcessSessionId(VOID)
Definition: process.c:1133
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_OBJECT_NAME_EXISTS
Definition: ntstatus.h:114
#define STATUS_NAME_TOO_LONG
Definition: ntstatus.h:498
NTSTRSAFEAPI RtlStringCbCopyW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCWSTR pszSrc)
Definition: ntstrsafe.h:174
NTSTRSAFEAPI RtlStringCchCatW(_Inout_updates_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ NTSTRSAFE_PCWSTR pszSrc)
Definition: ntstrsafe.h:601
NTSTRSAFEVAPI RtlStringCbPrintfExW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _Outptr_opt_result_bytebuffer_(*pcbRemaining) NTSTRSAFE_PWSTR *ppszDestEnd, _Out_opt_ size_t *pcbRemaining, _In_ STRSAFE_DWORD dwFlags, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1335
NTSTRSAFEVAPI RtlStringCbPrintfW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1173
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
NTSTRSAFEAPI RtlStringCbCopyNW(_Out_writes_bytes_(cbDest) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_reads_bytes_(cbToCopy) STRSAFE_LPCWSTR pszSrc, _In_ size_t cbToCopy)
Definition: ntstrsafe.h:416
LRESULT FASTCALL IntDefWindowProc(PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)
Definition: defwnd.c:587
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1102
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1792
PWINSTATION_OBJECT InputWindowStation
Definition: winsta.c:21
UNICODE_STRING gustrWindowStationsDir
Definition: winsta.c:27
NTSTATUS FASTCALL IntCreateWindowStation(OUT HWINSTA *phWinSta, IN POBJECT_ATTRIBUTES ObjectAttributes, IN KPROCESSOR_MODE AccessMode, IN KPROCESSOR_MODE OwnerMode, IN ACCESS_MASK dwDesiredAccess, DWORD Unknown2, DWORD Unknown3, DWORD Unknown4, DWORD Unknown5, DWORD Unknown6)
Definition: winsta.c:458
HINSTANCE hModClient
Definition: ntuser.c:25
BOOL g_AlwaysDisplayVersion
Definition: ntuser.c:17
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:258
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
BOOL FASTCALL UserIsEnteredExclusive(VOID)
Definition: ntuser.c:231
#define L(x)
Definition: ntvdm.h:50
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
BOOLEAN NTAPI ObFindHandleForObject(IN PEPROCESS Process, IN PVOID Object, IN POBJECT_TYPE ObjectType, IN POBJECT_HANDLE_INFORMATION HandleInformation, OUT PHANDLE Handle)
Definition: obhandle.c:2856
NTSTATUS NTAPI ObOpenObjectByPointer(IN PVOID Object, IN ULONG HandleAttributes, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PHANDLE Handle)
Definition: obhandle.c:2742
NTSTATUS NTAPI ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN OUT PVOID ParseContext, OUT PHANDLE Handle)
Definition: obhandle.c:2532
NTSTATUS NTAPI ObCreateObject(IN KPROCESSOR_MODE ProbeMode OPTIONAL, IN POBJECT_TYPE Type, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN KPROCESSOR_MODE AccessMode, IN OUT PVOID ParseContext OPTIONAL, IN ULONG ObjectSize, IN ULONG PagedPoolCharge OPTIONAL, IN ULONG NonPagedPoolCharge OPTIONAL, OUT PVOID *Object)
Definition: oblife.c:1039
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
#define LRESULT
Definition: ole.h:14
#define LOWORD(l)
Definition: pedump.c:82
#define WS_POPUP
Definition: pedump.c:616
#define WS_VISIBLE
Definition: pedump.c:620
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
#define WS_CLIPCHILDREN
Definition: pedump.c:619
VOID NTAPI KeDetachProcess(VOID)
Definition: procobj.c:621
VOID NTAPI KeAttachProcess(IN PKPROCESS Process)
Definition: procobj.c:582
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
#define IntSysCreateRectpRgnIndirect(prc)
Definition: region.h:93
#define list
Definition: rosglue.h:35
static __inline NTSTATUS ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest, IN KPROCESSOR_MODE CurrentMode, IN const UNICODE_STRING *UnsafeSrc)
Definition: probe.h:142
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:239
#define SharedUserData
NTSTATUS NTAPI MmMapViewOfSection(IN PVOID SectionObject, IN PEPROCESS Process, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:4009
#define STATUS_SUCCESS
Definition: shellext.h:65
HANDLE gpidLogon
Definition: simplecall.c:15
static void Exit(void)
Definition: sock.c:1330
#define TRACE(s)
Definition: solgame.cpp:4
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
Definition: polytest.cpp:41
base of all file and directory entries
Definition: entries.h:83
Definition: window.c:28
ULONG_PTR ulClientDelta
Definition: ntuser.h:326
ULONG fsHooks
Definition: ntuser.h:328
PCLIENTTHREADINFO pClientThreadInfo
Definition: ntuser.h:332
DWORD dwTIFlags
Definition: ntuser.h:324
PDESKTOPINFO pDeskInfo
Definition: ntuser.h:325
Definition: ntuser.h:566
HBRUSH hbrBackground
Definition: ntuser.h:587
ULONG CURSORF_flags
Definition: cursoricon.h:16
WCHAR szDesktopName[1]
Definition: ntuser.h:158
LIST_ENTRY aphkStart[NB_HOOKS]
Definition: ntuser.h:139
struct _WND * spwnd
Definition: ntuser.h:137
PVOID pvDesktopLimit
Definition: ntuser.h:136
PVOID pvDesktopBase
Definition: ntuser.h:135
PVOID hsectionDesktop
Definition: desktop.h:22
struct _USER_MESSAGE_QUEUE * ActiveMessageQueue
Definition: desktop.h:38
LIST_ENTRY PtiList
Definition: desktop.h:25
LIST_ENTRY ListEntry
Definition: desktop.h:9
struct _WINSTATION_OBJECT * rpwinstaParent
Definition: desktop.h:11
LIST_ENTRY ShellHookWindows
Definition: desktop.h:43
PWIN32HEAP pheapDesktop
Definition: desktop.h:23
PWND spwndMessage
Definition: desktop.h:20
HWND DesktopWindow
Definition: desktop.h:40
PDESKTOPINFO pDeskInfo
Definition: desktop.h:8
DWORD dwSessionId
Definition: desktop.h:6
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LONG HighPart
DWORD LowPart
HDEV hDev
Definition: monitor.h:23
GENERIC_MAPPING GenericMapping
Definition: obtypes.h:358
ULONG DefaultNonPagedPoolCharge
Definition: obtypes.h:365
OBJECT_TYPE_INITIALIZER TypeInfo
Definition: obtypes.h:390
WCHAR szCSDVersion[128]
Definition: rtltypes.h:274
ULONG dwOSVersionInfoSize
Definition: rtltypes.h:269
ULONG dwBuildNumber
Definition: rtltypes.h:272
LPCWSTR lpstr
Definition: wingdi.h:2564
UINT n
Definition: wingdi.h:2563
HWINSTA hwinsta
Definition: win32.h:268
HDESK hdeskStartup
Definition: win32.h:264
W32HEAP_USER_MAPPING HeapMappings
Definition: win32.h:291
struct _DESKTOP * rpdeskStartup
Definition: win32.h:259
struct _WINSTATION_OBJECT * prpwinsta
Definition: win32.h:267
Definition: region.h:8
LIST_ENTRY ListEntry
Definition: desktop.h:67
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
WALLPAPER_MODE WallpaperMode
Definition: sysparams.h:144
NONCLIENTMETRICSW ncm
Definition: sysparams.h:51
ULONG cxWallpaper
Definition: sysparams.h:143
ULONG cyWallpaper
Definition: sysparams.h:143
HANDLE hbmWallpaper
Definition: sysparams.h:142
struct _DESKTOP * rpdesk
Definition: ntuser.h:194
PPROCESSINFO ppi
Definition: win32.h:88
struct _DESKTOPINFO * pDeskInfo
Definition: win32.h:93
ULONG fsHooks
Definition: win32.h:117
CLIENTTHREADINFO cti
Definition: win32.h:144
struct _CLIENTINFO * pClientInfo
Definition: win32.h:94
HDESK hdesk
Definition: win32.h:108
struct _CLIENTTHREADINFO * pcti
Definition: win32.h:91
FLONG TIF_flags
Definition: win32.h:95
struct _DESKTOP * rpdesk
Definition: win32.h:92
LIST_ENTRY WindowListHead
Definition: win32.h:155
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
LIST_ENTRY PtiLink
Definition: win32.h:126
USHORT MaximumLength
Definition: env_spec_w32.h:370
struct _DESKTOP * Desktop
Definition: msgqueue.h:50
struct _W32HEAP_USER_MAPPING * Next
Definition: win32.h:199
ULONG_PTR Limit
Definition: win32.h:202
UINT flags
Definition: winuser.h:3613
struct _DESKTOP * ActiveDesktop
Definition: winsta.h:42
LIST_ENTRY DesktopListHead
Definition: winsta.h:19
Definition: ntuser.h:694
PCLS pcls
Definition: ntuser.h:720
THRDESKHEAD head
Definition: ntuser.h:695
DWORD style
Definition: ntuser.h:706
DWORD fnid
Definition: ntuser.h:709
RECT rcWindow
Definition: ntuser.h:716
LPCWSTR lpszClass
Definition: winuser.h:2984
LPCWSTR lpszName
Definition: winuser.h:2983
HINSTANCE hInstance
Definition: winuser.h:2975
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1060
UINT uiShellMsg
Definition: ntuser.h:1063
#define max(a, b)
Definition: svc.c:63
@ wmFill
Definition: sysparams.h:45
@ wmTile
Definition: sysparams.h:42
@ wmStretch
Definition: sysparams.h:43
@ wmFit
Definition: sysparams.h:44
#define WINVER
Definition: targetver.h:11
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint16_t * PWSTR
Definition: typedefs.h:56
#define MAXULONG
Definition: typedefs.h:251
unsigned char * PBOOLEAN
Definition: typedefs.h:53
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define MAXUSHORT
Definition: typedefs.h:83
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define HIWORD(l)
Definition: typedefs.h:247
#define OUT
Definition: typedefs.h:40
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_OBJECT_NAME_COLLISION
Definition: udferr_usr.h:150
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
#define ALIGN_UP(size, type)
Definition: umtypes.h:91
#define WC_DESKTOP
Definition: undocuser.h:10
HDC FASTCALL IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
Definition: painting.c:1442
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:895
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1539
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:643
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
_In_ HFONT _Out_ PUINT Height
Definition: font.h:88
RTL_ATOM FASTCALL IntAddAtom(LPWSTR AtomName)
Definition: useratom.c:13
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:124
PWND FASTCALL IntGetWindowObject(HWND hWnd)
Definition: window.c:75
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2870
PWIN32HEAP UserCreateHeap(OUT PVOID *SectionObject, IN OUT PVOID *SystemBase, IN SIZE_T HeapSize)
Definition: usrheap.c:181
static __inline PVOID UserHeapAlloc(SIZE_T Bytes)
Definition: usrheap.h:34
static __inline BOOL UserHeapFree(PVOID lpMem)
Definition: usrheap.h:44
int ret
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2658
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
POBJECT_TYPE ExDesktopObjectType
Definition: win32k.c:22
POBJECT_TYPE ExWindowStationObjectType
Definition: win32k.c:21
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
HFONT FASTCALL GreCreateFontIndirectW(_In_ const LOGFONTW *lplf)
Definition: font.c:28
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
HGDIOBJ StockObjects[]
Definition: stockobj.c:100
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2449
BOOL FASTCALL GreGetTextExtentW(_In_ HDC hDC, _In_reads_(cwc) PCWCH lpwsz, _In_ INT cwc, _Out_ PSIZE psize, _In_ UINT flOpts)
Definition: text.c:77
BOOL IntCheckProcessDesktopClasses(IN PDESKTOP Desktop, IN BOOL FreeOnFailure)
Definition: class.c:1017
PCLS IntGetAndReferenceClass(PUNICODE_STRING ClassName, HINSTANCE hInstance, BOOL bDesktopThread)
Definition: class.c:1450
BOOL FASTCALL UserRegisterSystemClasses(VOID)
Definition: class.c:2337
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon)
Definition: cursoricon.c:200
static NTSTATUS IntMapDesktopView(IN PDESKTOP pdesk)
Definition: desktop.c:3224
HDESK APIENTRY NtUserOpenInputDesktop(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess)
Definition: desktop.c:2720
BOOL APIENTRY NtUserCloseDesktop(HDESK hDesktop)
Definition: desktop.c:2760
PDESKTOP FASTCALL IntGetActiveDesktop(VOID)
Definition: desktop.c:1279
DWORD gdwDesktopSectionSize
Definition: desktop.c:46
PTHREADINFO gptiDesktopThread
Definition: desktop.c:54
BOOL APIENTRY NtUserSetThreadDesktop(HDESK hDesktop)
Definition: desktop.c:3490
HCURSOR gDesktopCursor
Definition: desktop.c:55
HDESK APIENTRY NtUserOpenDesktop(POBJECT_ATTRIBUTES ObjectAttributes, DWORD dwFlags, ACCESS_MASK dwDesiredAccess)
Definition: desktop.c:2626
NTSTATUS FASTCALL IntCreateDesktop(OUT HDESK *phDesktop, IN POBJECT_ATTRIBUTES ObjectAttributes, IN KPROCESSOR_MODE AccessMode, IN PUNICODE_STRING lpszDesktopDevice OPTIONAL, IN LPDEVMODEW lpdmw OPTIONAL, IN DWORD dwFlags, IN ACCESS_MASK dwDesiredAccess)
Definition: desktop.c:2390
HWND FASTCALL IntGetCurrentThreadDesktopWindow(VOID)
Definition: desktop.c:1441
NTSTATUS NTAPI IntDesktopOkToClose(_In_ PVOID Parameters)
Definition: desktop.c:203
NTSTATUS NTAPI InitDesktopImpl(VOID)
Definition: desktop.c:269
VOID APIENTRY UserRedrawDesktop(VOID)
Definition: desktop.c:1616
PKEVENT gpDesktopThreadStartedEvent
Definition: desktop.c:56
HDC ScreenDeviceContext
Definition: desktop.c:53
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1403
BOOL IntDeRegisterShellHookWindow(HWND hWnd)
Definition: desktop.c:1803
HWND FASTCALL IntGetMessageWindow(VOID)
Definition: desktop.c:1416
NTSTATUS FASTCALL IntHideDesktop(PDESKTOP Desktop)
Definition: desktop.c:1652
VOID NTAPI DesktopThreadMain(VOID)
Definition: desktop.c:1563
HDESK UserOpenInputDesktop(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess)
Definition: desktop.c:2655
HDESK FASTCALL IntGetDesktopObjectHandle(PDESKTOP DesktopObject)
Definition: desktop.c:1288
HDESK APIENTRY NtUserGetThreadDesktop(DWORD dwThreadId, HDESK hConsoleDesktop)
Definition: desktop.c:3071
VOID FASTCALL IntSetFocusMessageQueue(PUSER_MESSAGE_QUEUE NewQueue)
Definition: desktop.c:1336
NTSTATUS FASTCALL co_IntShowDesktop(PDESKTOP Desktop, ULONG Width, ULONG Height, BOOL bRedraw)
Definition: desktop.c:1634
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1391
NTSTATUS NTAPI IntDesktopObjectClose(_In_ PVOID Parameters)
Definition: desktop.c:244
BOOL IntRegisterShellHookWindow(HWND hWnd)
Definition: desktop.c:1771
NTSTATUS FASTCALL IntValidateDesktopHandle(HDESK Desktop, KPROCESSOR_MODE AccessMode, ACCESS_MASK DesiredAccess, PDESKTOP *Object)
Definition: desktop.c:1254
DWORD gdwNOIOSectionSize
Definition: desktop.c:48
static VOID IntFreeDesktopHeap(IN PDESKTOP pdesk)
PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue(VOID)
Definition: desktop.c:1324
HDESK NTAPI NtUserResolveDesktop(IN HANDLE ProcessHandle, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta)
Definition: desktop.c:2867
NTSTATUS APIENTRY IntDesktopObjectParse(IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context OPTIONAL, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)
Definition: desktop.c:62
BOOL APIENTRY NtUserPaintDesktop(HDC hDC)
Definition: desktop.c:2817
BOOL FASTCALL DesktopWindowProc(PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
Definition: desktop.c:1456
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1709
BOOL APIENTRY NtUserSwitchDesktop(HDESK hdesk)
Definition: desktop.c:2974
NTSTATUS FASTCALL IntResolveDesktop(IN PEPROCESS Process, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta, OUT HDESK *phDesktop)
Definition: desktop.c:568
BOOL FASTCALL IntPaintDesktop(HDC hDC)
Definition: desktop.c:1854
PWND FASTCALL IntGetThreadDesktopWindow(PTHREADINFO pti)
Definition: desktop.c:1376
static NTSTATUS GetSystemVersionString(OUT PWSTR pwszzVersion, IN SIZE_T cchDest, IN BOOLEAN InSafeMode, IN BOOLEAN AppendNtSystemRoot)
Definition: desktop.c:300
BOOL FASTCALL UserMessageWindowProc(PWND pwnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
Definition: desktop.c:1542
NTSTATUS NTAPI IntDesktopObjectOpen(_In_ PVOID Parameters)
Definition: desktop.c:227
DWORD gdwWinlogonSectionSize
Definition: desktop.c:49
HDC FASTCALL UserGetDesktopDC(ULONG DcType, BOOL bAltDc, BOOL ValidatehWnd)
Definition: desktop.c:1591
NTSTATUS NTAPI IntDesktopObjectDelete(_In_ PVOID Parameters)
Definition: desktop.c:172
HDESK APIENTRY NtUserCreateDesktop(POBJECT_ATTRIBUTES ObjectAttributes, PUNICODE_STRING lpszDesktopDevice, LPDEVMODEW lpdmw, DWORD dwFlags, ACCESS_MASK dwDesiredAccess)
Definition: desktop.c:2567
PDESKTOP gpdeskInputDesktop
Definition: desktop.c:52
BOOL IntSetThreadDesktop(IN HDESK hDesktop, IN BOOL FreeOnFailure)
Definition: desktop.c:3298
static HWND *FASTCALL UserBuildShellHookHwndList(PDESKTOP Desktop)
Definition: desktop.c:1668
PWND FASTCALL UserGetMessageWindow(VOID)
Definition: desktop.c:1429
static NTSTATUS IntUnmapDesktopView(IN PDESKTOP pdesk)
Definition: desktop.c:3180
static NTSTATUS UserInitializeDesktop(PDESKTOP pdesk, PUNICODE_STRING DesktopName, PWINSTATION_OBJECT pwinsta)
Definition: desktop.c:2279
PWND FASTCALL co_GetDesktopWindow(PWND pWnd)
Definition: desktop.c:1383
struct _DESKTOP * PDESKTOP
struct _DESKTOP DESKTOP
static __inline ULONG_PTR DesktopHeapGetUserDelta(VOID)
Definition: desktop.h:272
#define DT_GWL_THREADID
Definition: desktop.h:56
static __inline PVOID DesktopHeapAlloc(IN PDESKTOP Desktop, IN SIZE_T Bytes)
Definition: desktop.h:204
static __inline BOOL DesktopHeapFree(IN PDESKTOP Desktop, IN PVOID lpMem)
Definition: desktop.h:215
#define DT_GWL_PROCESSID
Definition: desktop.h:55
LRESULT FASTCALL IntDispatchMessage(PMSG pMsg)
Definition: message.c:890
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1395
BOOL APIENTRY co_IntGetPeekMessage(PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg, BOOL bGMSG)
Definition: message.c:1226
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:214
NTSTATUS GetProcessLuid(IN PETHREAD Thread OPTIONAL, IN PEPROCESS Process OPTIONAL, OUT PLUID Luid)
Definition: misc.c:815
PTHREADINFO FASTCALL IntTID2PTI(HANDLE id)
Definition: misc.c:42
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
NTSTATUS NTAPI IntAssignDesktopSecurityOnParse(_In_ PWINSTATION_OBJECT WinSta, _In_ PDESKTOP Desktop, _In_ PACCESS_STATE AccessState)
Assigns a security descriptor to the desktop object during a desktop object parse procedure.
Definition: security.c:270
NTSTATUS NTAPI IntCreateServiceSecurity(_Out_ PSECURITY_DESCRIPTOR *ServiceSd)
Creates a security descriptor for the service.
Definition: security.c:327
VOID IntFreeSecurityBuffer(_In_ PVOID Buffer)
Frees an allocated security buffer from UM memory that is been previously allocated by IntAllocateSec...
Definition: security.c:133
#define DESKTOP_WRITE
Definition: security.h:19
#define DESKTOP_EXECUTE
Definition: security.h:27
#define WINSTA_ACCESS_ALL
Definition: security.h:57
#define DESKTOP_READ
Definition: security.h:15
BOOL g_PaintDesktopVersion
Definition: sysparams.c:19
SPIVALUES gspv
Definition: sysparams.c:17
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2116
#define TAG_WINSTA
Definition: tags.h:11
#define USERTAG_EVENT
Definition: tags.h:230
#define USERTAG_WINDOWLIST
Definition: tags.h:298
LONG FASTCALL co_UserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:4038
PWND FASTCALL IntCreateWindow(CREATESTRUCTW *Cs, PLARGE_STRING WindowName, PCLS Class, PWND ParentWindow, PWND OwnerWindow, PVOID acbiBuffer, PDESKTOP pdeskCreated, DWORD dwVer)
Definition: window.c:1808
#define WSS_LOCKED
Definition: winsta.h:7
struct _WINSTATION_OBJECT * PWINSTATION_OBJECT
#define WSS_NOIO
Definition: winsta.h:9
SIZE_T WINAPI HeapSize(HANDLE, DWORD, LPCVOID)
#define MAKEINTATOM(i)
Definition: winbase.h:1495
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
ENGAPI ULONG APIENTRY EngGetLastError(VOID)
Definition: error.c:9
ENGAPI INT APIENTRY EngMulDiv(_In_ INT a, _In_ INT b, _In_ INT c)
Definition: math.c:26
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
DWORD COLORREF
Definition: windef.h:300
HICON HCURSOR
Definition: windef.h:299
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define TA_RIGHT
Definition: wingdi.h:933
#define TA_LEFT
Definition: wingdi.h:932
#define TRANSPARENT
Definition: wingdi.h:950
#define SRCCOPY
Definition: wingdi.h:333
#define PATCOPY
Definition: wingdi.h:335
#define BLACK_BRUSH
Definition: wingdi.h:896
#define TA_TOP
Definition: wingdi.h:930
#define TA_BOTTOM
Definition: wingdi.h:929
#define TA_CENTER
Definition: wingdi.h:931
#define WM_PAINT
Definition: winuser.h:1639
#define WM_ERASEBKGND
Definition: winuser.h:1644
#define WM_CLOSE
Definition: winuser.h:1640
#define SWP_NOACTIVATE
Definition: winuser.h:1253
#define SWP_NOREDRAW
Definition: winuser.h:1257
#define SM_CYVIRTUALSCREEN
Definition: winuser.h:1050
#define SM_CYSCREEN
Definition: winuser.h:971
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1680
#define WM_CREATE
Definition: winuser.h:1627
#define WH_SHELL
Definition: winuser.h:40
#define RDW_UPDATENOW
Definition: winuser.h:1231
#define RDW_ERASE
Definition: winuser.h:1222
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1645
#define WM_NCCREATE
Definition: winuser.h:1702
#define SM_CXVIRTUALSCREEN
Definition: winuser.h:1049
#define RDW_ALLCHILDREN
Definition: winuser.h:1232
#define PM_REMOVE
Definition: winuser.h:1207
#define RDW_FRAME
Definition: winuser.h:1223
#define SWP_SHOWWINDOW
Definition: winuser.h:1259
#define WM_SETCURSOR
Definition: winuser.h:1655
#define SM_CLEANBOOT
Definition: winuser.h:1038
#define WM_DESTROY
Definition: winuser.h:1628
#define SM_CXSCREEN
Definition: winuser.h:970
struct _WINDOWPOS * PWINDOWPOS
#define SM_XVIRTUALSCREEN
Definition: winuser.h:1047
#define SWP_NOZORDER
Definition: winuser.h:1258
#define RDW_INVALIDATE
Definition: winuser.h:1225
#define SM_YVIRTUALSCREEN
Definition: winuser.h:1048
_In_ PVOID _Out_opt_ PULONG_PTR _Outptr_opt_ PCUNICODE_STRING * ObjectName
Definition: cmfuncs.h:64
#define IO_NO_INCREMENT
Definition: iotypes.h:598
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
_In_ PEPROCESS _In_ KPROCESSOR_MODE AccessMode
Definition: mmfuncs.h:396
_In_ ACCESS_MASK _In_opt_ POBJECT_TYPE _In_ KPROCESSOR_MODE _Out_ PVOID _Out_opt_ POBJECT_HANDLE_INFORMATION HandleInformation
Definition: obfuncs.h:44
#define ObDereferenceObject
Definition: obfuncs.h:203
#define ObReferenceObject
Definition: obfuncs.h:204
#define DUPLICATE_SAME_ACCESS
#define PsGetCurrentProcess
Definition: psfuncs.h:17
#define RtlEqualLuid(Luid1, Luid2)
Definition: rtlfuncs.h:304
_In_opt_ PVOID _In_opt_ PUNICODE_STRING _In_ PSECURITY_DESCRIPTOR _In_ PACCESS_STATE AccessState
Definition: sefuncs.h:417
#define SYSTEM_LUID
Definition: setypes.h:700
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define ZwCurrentProcess()