1400827bc6563441e6656c36aa4280a3a36c7e9e
[reactos.git] / win32ss / user / ntuser / winsta.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Window stations
5 * FILE: win32ss/user/ntuser/winsta.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * TODO: The process window station is created on
8 * the first USER32/GDI32 call not related
9 * to window station/desktop handling
10 */
11
12 #include <win32k.h>
13 DBG_DEFAULT_CHANNEL(UserWinsta);
14
15 /* GLOBALS *******************************************************************/
16
17 /*
18 * The currently active window station. This is the
19 * only one interactive window station on the system.
20 */
21 PWINSTATION_OBJECT InputWindowStation = NULL;
22
23 /* Winlogon SAS window */
24 HWND hwndSAS = NULL;
25
26 /* Full path to WindowStations directory */
27 UNICODE_STRING gustrWindowStationsDir;
28
29 /* INITIALIZATION FUNCTIONS ****************************************************/
30
31 INIT_FUNCTION
32 NTSTATUS
33 NTAPI
34 InitWindowStationImpl(VOID)
35 {
36 GENERIC_MAPPING IntWindowStationMapping = { WINSTA_READ,
37 WINSTA_WRITE,
38 WINSTA_EXECUTE,
39 WINSTA_ACCESS_ALL};
40
41 /* Set Winsta Object Attributes */
42 ExWindowStationObjectType->TypeInfo.DefaultNonPagedPoolCharge = sizeof(WINSTATION_OBJECT);
43 ExWindowStationObjectType->TypeInfo.GenericMapping = IntWindowStationMapping;
44 ExWindowStationObjectType->TypeInfo.ValidAccessMask = WINSTA_ACCESS_ALL;
45
46 return STATUS_SUCCESS;
47 }
48
49 NTSTATUS
50 NTAPI
51 UserCreateWinstaDirectory(VOID)
52 {
53 NTSTATUS Status;
54 PPEB Peb;
55 OBJECT_ATTRIBUTES ObjectAttributes;
56 HANDLE hWinstaDir;
57 WCHAR wstrWindowStationsDir[MAX_PATH];
58
59 /* Create the WindowStations directory and cache its path for later use */
60 Peb = NtCurrentPeb();
61 if(Peb->SessionId == 0)
62 {
63 if (!RtlCreateUnicodeString(&gustrWindowStationsDir, WINSTA_OBJ_DIR))
64 {
65 return STATUS_INSUFFICIENT_RESOURCES;
66 }
67 }
68 else
69 {
70 Status = RtlStringCbPrintfW(wstrWindowStationsDir,
71 sizeof(wstrWindowStationsDir),
72 L"%ws\\%lu%ws",
73 SESSION_DIR,
74 Peb->SessionId,
75 WINSTA_OBJ_DIR);
76 if (!NT_SUCCESS(Status))
77 return Status;
78
79 if (!RtlCreateUnicodeString(&gustrWindowStationsDir, wstrWindowStationsDir))
80 {
81 return STATUS_INSUFFICIENT_RESOURCES;
82 }
83 }
84
85 InitializeObjectAttributes(&ObjectAttributes,
86 &gustrWindowStationsDir,
87 OBJ_KERNEL_HANDLE,
88 NULL,
89 NULL);
90 Status = ZwCreateDirectoryObject(&hWinstaDir, DIRECTORY_CREATE_OBJECT, &ObjectAttributes);
91 if (!NT_SUCCESS(Status))
92 {
93 ERR("Could not create %wZ directory (Status 0x%X)\n", &gustrWindowStationsDir, Status);
94 return Status;
95 }
96
97 TRACE("Created directory %wZ for session %lu\n", &gustrWindowStationsDir, Peb->SessionId);
98
99 return Status;
100 }
101
102 /* OBJECT CALLBACKS ***********************************************************/
103
104 NTSTATUS
105 NTAPI
106 IntWinStaObjectDelete(
107 _In_ PVOID Parameters)
108 {
109 PWIN32_DELETEMETHOD_PARAMETERS DeleteParameters = Parameters;
110 PWINSTATION_OBJECT WinSta = (PWINSTATION_OBJECT)DeleteParameters->Object;
111
112 TRACE("Deleting window station 0x%p\n", WinSta);
113
114 if (WinSta == InputWindowStation)
115 {
116 ERR("WARNING: Deleting the interactive window station '%wZ'!\n",
117 &(OBJECT_HEADER_TO_NAME_INFO(OBJECT_TO_OBJECT_HEADER(InputWindowStation))->Name));
118
119 /* Only Winlogon can close and delete the interactive window station */
120 ASSERT(gpidLogon == PsGetCurrentProcessId());
121
122 InputWindowStation = NULL;
123 }
124
125 WinSta->Flags |= WSS_DYING;
126
127 UserEmptyClipboardData(WinSta);
128
129 RtlDestroyAtomTable(WinSta->AtomTable);
130
131 return STATUS_SUCCESS;
132 }
133
134 NTSTATUS
135 NTAPI
136 IntWinStaObjectParse(
137 _In_ PVOID Parameters)
138 {
139 PWIN32_PARSEMETHOD_PARAMETERS ParseParameters = Parameters;
140 PUNICODE_STRING RemainingName = ParseParameters->RemainingName;
141
142 /* Assume we don't find anything */
143 *ParseParameters->Object = NULL;
144
145 /* Check for an empty name */
146 if (!RemainingName->Length)
147 {
148 /* Make sure this is a window station, can't parse a desktop now */
149 if (ParseParameters->ObjectType != ExWindowStationObjectType)
150 {
151 /* Fail */
152 return STATUS_OBJECT_TYPE_MISMATCH;
153 }
154
155 /* Reference the window station and return */
156 ObReferenceObject(ParseParameters->ParseObject);
157 *ParseParameters->Object = ParseParameters->ParseObject;
158 return STATUS_SUCCESS;
159 }
160
161 /* Check for leading slash */
162 if (RemainingName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
163 {
164 /* Skip it */
165 RemainingName->Buffer++;
166 RemainingName->Length -= sizeof(WCHAR);
167 RemainingName->MaximumLength -= sizeof(WCHAR);
168 }
169
170 /* Check if there is still a slash */
171 if (wcschr(RemainingName->Buffer, OBJ_NAME_PATH_SEPARATOR))
172 {
173 /* In this case, fail */
174 return STATUS_OBJECT_PATH_INVALID;
175 }
176
177 /*
178 * Check if we are parsing a desktop.
179 */
180 if (ParseParameters->ObjectType == ExDesktopObjectType)
181 {
182 /* Then call the desktop parse routine */
183 return IntDesktopObjectParse(ParseParameters->ParseObject,
184 ParseParameters->ObjectType,
185 ParseParameters->AccessState,
186 ParseParameters->AccessMode,
187 ParseParameters->Attributes,
188 ParseParameters->CompleteName,
189 RemainingName,
190 ParseParameters->Context,
191 ParseParameters->SecurityQos,
192 ParseParameters->Object);
193 }
194
195 /* Should hopefully never get here */
196 return STATUS_OBJECT_TYPE_MISMATCH;
197 }
198
199 NTSTATUS
200 NTAPI
201 IntWinStaOkToClose(
202 _In_ PVOID Parameters)
203 {
204 PWIN32_OKAYTOCLOSEMETHOD_PARAMETERS OkToCloseParameters = Parameters;
205 PPROCESSINFO ppi;
206
207 ppi = PsGetCurrentProcessWin32Process();
208
209 if (ppi && (OkToCloseParameters->Handle == ppi->hwinsta))
210 {
211 return STATUS_ACCESS_DENIED;
212 }
213
214 return STATUS_SUCCESS;
215 }
216
217 /* PRIVATE FUNCTIONS **********************************************************/
218
219 /*
220 * IntValidateWindowStationHandle
221 *
222 * Validates the window station handle.
223 *
224 * Remarks
225 * If the function succeeds, the handle remains referenced. If the
226 * fucntion fails, last error is set.
227 */
228
229 NTSTATUS FASTCALL
230 IntValidateWindowStationHandle(
231 HWINSTA WindowStation,
232 KPROCESSOR_MODE AccessMode,
233 ACCESS_MASK DesiredAccess,
234 PWINSTATION_OBJECT *Object,
235 POBJECT_HANDLE_INFORMATION pObjectHandleInfo)
236 {
237 NTSTATUS Status;
238
239 if (WindowStation == NULL)
240 {
241 ERR("Invalid window station handle\n");
242 EngSetLastError(ERROR_INVALID_HANDLE);
243 return STATUS_INVALID_HANDLE;
244 }
245
246 Status = ObReferenceObjectByHandle(WindowStation,
247 DesiredAccess,
248 ExWindowStationObjectType,
249 AccessMode,
250 (PVOID*)Object,
251 pObjectHandleInfo);
252
253 if (!NT_SUCCESS(Status))
254 SetLastNtError(Status);
255
256 return Status;
257 }
258
259 BOOL FASTCALL
260 co_IntInitializeDesktopGraphics(VOID)
261 {
262 TEXTMETRICW tmw;
263 UNICODE_STRING DriverName = RTL_CONSTANT_STRING(L"DISPLAY");
264 PDESKTOP pdesk;
265
266 ScreenDeviceContext = IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE);
267 if (NULL == ScreenDeviceContext)
268 {
269 IntDestroyPrimarySurface();
270 return FALSE;
271 }
272 GreSetDCOwner(ScreenDeviceContext, GDI_OBJ_HMGR_PUBLIC);
273
274 if (! IntCreatePrimarySurface())
275 {
276 return FALSE;
277 }
278
279 hSystemBM = NtGdiCreateCompatibleDC(ScreenDeviceContext);
280
281 NtGdiSelectFont(hSystemBM, NtGdiGetStockObject(SYSTEM_FONT));
282 GreSetDCOwner(hSystemBM, GDI_OBJ_HMGR_PUBLIC);
283
284 /* Update the SERVERINFO */
285 gpsi->aiSysMet[SM_CXSCREEN] = gppdevPrimary->gdiinfo.ulHorzRes;
286 gpsi->aiSysMet[SM_CYSCREEN] = gppdevPrimary->gdiinfo.ulVertRes;
287 gpsi->Planes = NtGdiGetDeviceCaps(ScreenDeviceContext, PLANES);
288 gpsi->BitsPixel = NtGdiGetDeviceCaps(ScreenDeviceContext, BITSPIXEL);
289 gpsi->BitCount = gpsi->Planes * gpsi->BitsPixel;
290 gpsi->dmLogPixels = NtGdiGetDeviceCaps(ScreenDeviceContext, LOGPIXELSY);
291 if (NtGdiGetDeviceCaps(ScreenDeviceContext, RASTERCAPS) & RC_PALETTE)
292 {
293 gpsi->PUSIFlags |= PUSIF_PALETTEDISPLAY;
294 }
295 else
296 gpsi->PUSIFlags &= ~PUSIF_PALETTEDISPLAY;
297 // Font is realized and this dc was previously set to internal DC_ATTR.
298 gpsi->cxSysFontChar = IntGetCharDimensions(hSystemBM, &tmw, (DWORD*)&gpsi->cySysFontChar);
299 gpsi->tmSysFont = tmw;
300
301 /* Put the pointer in the center of the screen */
302 gpsi->ptCursor.x = gpsi->aiSysMet[SM_CXSCREEN] / 2;
303 gpsi->ptCursor.y = gpsi->aiSysMet[SM_CYSCREEN] / 2;
304
305 /* Attach monitor */
306 UserAttachMonitor((HDEV)gppdevPrimary);
307
308 /* Setup the cursor */
309 co_IntLoadDefaultCursors();
310
311 /* Setup the icons */
312 co_IntSetWndIcons();
313
314 /* Setup Menu */
315 MenuInit();
316
317 /* Show the desktop */
318 pdesk = IntGetActiveDesktop();
319 ASSERT(pdesk);
320 co_IntShowDesktop(pdesk, gpsi->aiSysMet[SM_CXSCREEN], gpsi->aiSysMet[SM_CYSCREEN], TRUE);
321
322 return TRUE;
323 }
324
325 VOID FASTCALL
326 IntEndDesktopGraphics(VOID)
327 {
328 if (NULL != ScreenDeviceContext)
329 { // No need to allocate a new dcattr.
330 GreSetDCOwner(ScreenDeviceContext, GDI_OBJ_HMGR_POWNED);
331 GreDeleteObject(ScreenDeviceContext);
332 ScreenDeviceContext = NULL;
333 }
334 IntHideDesktop(IntGetActiveDesktop());
335 IntDestroyPrimarySurface();
336 }
337
338 HDC FASTCALL
339 IntGetScreenDC(VOID)
340 {
341 return ScreenDeviceContext;
342 }
343
344 BOOL FASTCALL
345 CheckWinstaAttributeAccess(ACCESS_MASK DesiredAccess)
346 {
347 PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
348 if ( gpidLogon != PsGetCurrentProcessId() )
349 {
350 if (!(ppi->W32PF_flags & W32PF_IOWINSTA))
351 {
352 ERR("Requires Interactive Window Station\n");
353 EngSetLastError(ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION);
354 return FALSE;
355 }
356 if (!RtlAreAllAccessesGranted(ppi->amwinsta, DesiredAccess))
357 {
358 ERR("Access Denied\n");
359 EngSetLastError(ERROR_ACCESS_DENIED);
360 return FALSE;
361 }
362 }
363 return TRUE;
364 }
365
366
367 /* PUBLIC FUNCTIONS ***********************************************************/
368
369 /*
370 * NtUserCreateWindowStation
371 *
372 * Creates a new window station.
373 *
374 * Parameters
375 * lpszWindowStationName
376 * Pointer to a null-terminated string specifying the name of the
377 * window station to be created. Window station names are
378 * case-insensitive and cannot contain backslash characters (\).
379 * Only members of the Administrators group are allowed to specify a
380 * name.
381 *
382 * dwDesiredAccess
383 * Requested type of access
384 *
385 * lpSecurity
386 * Security descriptor
387 *
388 * Unknown3, Unknown4, Unknown5, Unknown6
389 * Unused
390 *
391 * Return Value
392 * If the function succeeds, the return value is a handle to the newly
393 * created window station. If the specified window station already
394 * exists, the function succeeds and returns a handle to the existing
395 * window station. If the function fails, the return value is NULL.
396 *
397 * Status
398 * @implemented
399 */
400
401 NTSTATUS
402 FASTCALL
403 IntCreateWindowStation(
404 OUT HWINSTA* phWinSta,
405 IN POBJECT_ATTRIBUTES ObjectAttributes,
406 IN KPROCESSOR_MODE AccessMode,
407 IN KPROCESSOR_MODE OwnerMode,
408 IN ACCESS_MASK dwDesiredAccess,
409 DWORD Unknown2,
410 DWORD Unknown3,
411 DWORD Unknown4,
412 DWORD Unknown5,
413 DWORD Unknown6)
414 {
415 NTSTATUS Status;
416 HWINSTA hWinSta;
417 PWINSTATION_OBJECT WindowStation;
418
419 TRACE("IntCreateWindowStation called\n");
420
421 ASSERT(phWinSta);
422 *phWinSta = NULL;
423
424 Status = ObOpenObjectByName(ObjectAttributes,
425 ExWindowStationObjectType,
426 AccessMode,
427 NULL,
428 dwDesiredAccess,
429 NULL,
430 (PVOID*)&hWinSta);
431 if (NT_SUCCESS(Status))
432 {
433 TRACE("IntCreateWindowStation opened window station '%wZ'\n",
434 ObjectAttributes->ObjectName);
435 *phWinSta = hWinSta;
436 return Status;
437 }
438
439 /*
440 * No existing window station found, try to create a new one.
441 */
442
443 /* Create the window station object */
444 Status = ObCreateObject(AccessMode,
445 ExWindowStationObjectType,
446 ObjectAttributes,
447 OwnerMode,
448 NULL,
449 sizeof(WINSTATION_OBJECT),
450 0,
451 0,
452 (PVOID*)&WindowStation);
453 if (!NT_SUCCESS(Status))
454 {
455 ERR("ObCreateObject failed for window station '%wZ', Status 0x%08lx\n",
456 ObjectAttributes->ObjectName, Status);
457 SetLastNtError(Status);
458 return Status;
459 }
460
461 /* Initialize the window station */
462 RtlZeroMemory(WindowStation, sizeof(WINSTATION_OBJECT));
463
464 InitializeListHead(&WindowStation->DesktopListHead);
465 WindowStation->dwSessionId = NtCurrentPeb()->SessionId;
466 Status = RtlCreateAtomTable(37, &WindowStation->AtomTable);
467 if (!NT_SUCCESS(Status))
468 {
469 ERR("RtlCreateAtomTable failed for window station '%wZ', Status 0x%08lx\n",
470 ObjectAttributes->ObjectName, Status);
471 ObDereferenceObject(WindowStation);
472 SetLastNtError(Status);
473 return Status;
474 }
475
476 Status = ObInsertObject(WindowStation,
477 NULL,
478 dwDesiredAccess,
479 0,
480 NULL,
481 (PVOID*)&hWinSta);
482 if (!NT_SUCCESS(Status))
483 {
484 ERR("ObInsertObject failed for window station, Status 0x%08lx\n", Status);
485 SetLastNtError(Status);
486 return Status;
487 }
488
489 // FIXME! TODO: Add this new window station to a linked list
490
491 if (InputWindowStation == NULL)
492 {
493 ERR("Initializing input window station\n");
494
495 /* Only Winlogon can create the interactive window station */
496 ASSERT(gpidLogon == PsGetCurrentProcessId());
497
498 InputWindowStation = WindowStation;
499 WindowStation->Flags &= ~WSS_NOIO;
500 InitCursorImpl();
501 }
502 else
503 {
504 WindowStation->Flags |= WSS_NOIO;
505 }
506
507 TRACE("IntCreateWindowStation created window station '%wZ' object 0x%p handle 0x%p\n",
508 ObjectAttributes->ObjectName, WindowStation, hWinSta);
509
510 *phWinSta = hWinSta;
511 return STATUS_SUCCESS;
512 }
513
514 static VOID
515 FreeUserModeWindowStationName(
516 IN OUT PUNICODE_STRING WindowStationName,
517 IN PUNICODE_STRING TebStaticUnicodeString,
518 IN OUT POBJECT_ATTRIBUTES UserModeObjectAttributes OPTIONAL,
519 IN POBJECT_ATTRIBUTES LocalObjectAttributes OPTIONAL)
520 {
521 SIZE_T MemSize = 0;
522
523 /* Try to restore the user's UserModeObjectAttributes */
524 if (UserModeObjectAttributes && LocalObjectAttributes)
525 {
526 _SEH2_TRY
527 {
528 ProbeForWrite(UserModeObjectAttributes, sizeof(OBJECT_ATTRIBUTES), sizeof(ULONG));
529 *UserModeObjectAttributes = *LocalObjectAttributes;
530 }
531 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
532 {
533 NOTHING;
534 }
535 _SEH2_END;
536 }
537
538 /* Free the user-mode memory */
539 if (WindowStationName && (WindowStationName != TebStaticUnicodeString))
540 {
541 ZwFreeVirtualMemory(ZwCurrentProcess(),
542 (PVOID*)&WindowStationName,
543 &MemSize,
544 MEM_RELEASE);
545 }
546 }
547
548 static NTSTATUS
549 BuildUserModeWindowStationName(
550 IN OUT POBJECT_ATTRIBUTES UserModeObjectAttributes,
551 IN OUT POBJECT_ATTRIBUTES LocalObjectAttributes,
552 OUT PUNICODE_STRING* WindowStationName,
553 OUT PUNICODE_STRING* TebStaticUnicodeString)
554 {
555 NTSTATUS Status;
556 SIZE_T MemSize;
557
558 LUID CallerLuid;
559 PTEB Teb;
560 USHORT StrSize;
561
562 *WindowStationName = NULL;
563 *TebStaticUnicodeString = NULL;
564
565 /* Retrieve the current process LUID */
566 Status = GetProcessLuid(NULL, NULL, &CallerLuid);
567 if (!NT_SUCCESS(Status))
568 {
569 ERR("Failed to retrieve the caller LUID, Status 0x%08lx\n", Status);
570 return Status;
571 }
572
573 /* Compute the needed string size */
574 MemSize = _scwprintf(L"%wZ\\Service-0x%x-%x$",
575 &gustrWindowStationsDir,
576 CallerLuid.HighPart,
577 CallerLuid.LowPart);
578 MemSize = MemSize * sizeof(WCHAR) + sizeof(UNICODE_NULL);
579 if (MemSize > MAXUSHORT)
580 {
581 ERR("Window station name length is too long.\n");
582 return STATUS_NAME_TOO_LONG;
583 }
584 StrSize = (USHORT)MemSize;
585
586 /*
587 * Check whether it's short enough so that we can use the static buffer
588 * in the TEB. Otherwise continue with virtual memory allocation.
589 */
590 Teb = NtCurrentTeb();
591 if (Teb && (StrSize <= sizeof(Teb->StaticUnicodeBuffer)))
592 {
593 /* We can use the TEB's static unicode string */
594 ASSERT(Teb->StaticUnicodeString.Buffer == Teb->StaticUnicodeBuffer);
595 ASSERT(Teb->StaticUnicodeString.MaximumLength == sizeof(Teb->StaticUnicodeBuffer));
596
597 /* Remember the TEB's static unicode string address for later */
598 *TebStaticUnicodeString = &Teb->StaticUnicodeString;
599
600 *WindowStationName = *TebStaticUnicodeString;
601 (*WindowStationName)->Length = 0;
602 }
603 else
604 {
605 /* The TEB's static unicode string is too small, allocate some user-mode virtual memory */
606 MemSize += ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID));
607
608 /* Allocate the memory in user-mode */
609 Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
610 (PVOID*)WindowStationName,
611 0,
612 &MemSize,
613 MEM_COMMIT,
614 PAGE_READWRITE);
615 if (!NT_SUCCESS(Status))
616 {
617 ERR("ZwAllocateVirtualMemory() failed, Status 0x%08lx\n", Status);
618 return Status;
619 }
620
621 RtlInitEmptyUnicodeString(*WindowStationName,
622 (PWCHAR)((ULONG_PTR)*WindowStationName +
623 ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID))),
624 StrSize);
625 }
626
627 /* Build a valid window station name from the LUID */
628 Status = RtlStringCbPrintfW((*WindowStationName)->Buffer,
629 (*WindowStationName)->MaximumLength,
630 L"%wZ\\Service-0x%x-%x$",
631 &gustrWindowStationsDir,
632 CallerLuid.HighPart,
633 CallerLuid.LowPart);
634 if (!NT_SUCCESS(Status))
635 {
636 ERR("Impossible to build a valid window station name, Status 0x%08lx\n", Status);
637 goto Quit;
638 }
639 (*WindowStationName)->Length = (USHORT)(wcslen((*WindowStationName)->Buffer) * sizeof(WCHAR));
640
641 /* Try to update the user's UserModeObjectAttributes */
642 _SEH2_TRY
643 {
644 ProbeForWrite(UserModeObjectAttributes, sizeof(OBJECT_ATTRIBUTES), sizeof(ULONG));
645 *LocalObjectAttributes = *UserModeObjectAttributes;
646
647 UserModeObjectAttributes->ObjectName = *WindowStationName;
648 UserModeObjectAttributes->RootDirectory = NULL;
649
650 Status = STATUS_SUCCESS;
651 }
652 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
653 {
654 Status = _SEH2_GetExceptionCode();
655 }
656 _SEH2_END;
657
658 Quit:
659 if (!NT_SUCCESS(Status))
660 {
661 /* Release the window station name */
662 FreeUserModeWindowStationName(*WindowStationName,
663 *TebStaticUnicodeString,
664 NULL, NULL);
665 }
666
667 return Status;
668 }
669
670 HWINSTA
671 APIENTRY
672 NtUserCreateWindowStation(
673 IN POBJECT_ATTRIBUTES ObjectAttributes,
674 IN ACCESS_MASK dwDesiredAccess,
675 DWORD Unknown2,
676 DWORD Unknown3,
677 DWORD Unknown4,
678 DWORD Unknown5,
679 DWORD Unknown6)
680 {
681 NTSTATUS Status = STATUS_SUCCESS;
682 HWINSTA hWinSta = NULL;
683 OBJECT_ATTRIBUTES LocalObjectAttributes;
684 PUNICODE_STRING WindowStationName = NULL;
685 PUNICODE_STRING TebStaticUnicodeString = NULL;
686 KPROCESSOR_MODE OwnerMode = UserMode;
687
688 TRACE("NtUserCreateWindowStation called\n");
689
690 /* Capture the object attributes and the window station name */
691 _SEH2_TRY
692 {
693 ProbeForRead(ObjectAttributes, sizeof(OBJECT_ATTRIBUTES), sizeof(ULONG));
694 LocalObjectAttributes = *ObjectAttributes;
695 if (LocalObjectAttributes.Length != sizeof(OBJECT_ATTRIBUTES))
696 {
697 ERR("Invalid ObjectAttributes length!\n");
698 Status = STATUS_INVALID_PARAMETER;
699 _SEH2_LEAVE;
700 }
701
702 /*
703 * Check whether the caller provided a window station name together
704 * with a RootDirectory handle.
705 *
706 * If the caller did not provide a window station name, build a new one
707 * based on the logon session identifier for the calling process.
708 * The new name is allocated in user-mode, as the rest of ObjectAttributes
709 * already is, so that the validation performed by the Object Manager
710 * can be done adequately.
711 */
712 if ((LocalObjectAttributes.ObjectName == NULL ||
713 LocalObjectAttributes.ObjectName->Buffer == NULL ||
714 LocalObjectAttributes.ObjectName->Length == 0 ||
715 LocalObjectAttributes.ObjectName->Buffer[0] == UNICODE_NULL)
716 /* &&
717 LocalObjectAttributes.RootDirectory == NULL */)
718 {
719 /* No, build the new window station name */
720 Status = BuildUserModeWindowStationName(ObjectAttributes,
721 &LocalObjectAttributes,
722 &WindowStationName,
723 &TebStaticUnicodeString);
724 if (!NT_SUCCESS(Status))
725 {
726 ERR("BuildUserModeWindowStationName() failed, Status 0x%08lx\n", Status);
727 _SEH2_LEAVE;
728 }
729 OwnerMode = KernelMode;
730 }
731 }
732 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
733 {
734 Status =_SEH2_GetExceptionCode();
735 ERR("ObjectAttributes capture failed, Status 0x%08lx\n", Status);
736 }
737 _SEH2_END;
738
739 if (!NT_SUCCESS(Status))
740 {
741 SetLastNtError(Status);
742 return NULL;
743 }
744
745 /* Create the window station */
746 Status = IntCreateWindowStation(&hWinSta,
747 ObjectAttributes,
748 UserMode,
749 OwnerMode,
750 dwDesiredAccess,
751 Unknown2,
752 Unknown3,
753 Unknown4,
754 Unknown5,
755 Unknown6);
756 if (NT_SUCCESS(Status))
757 {
758 TRACE("NtUserCreateWindowStation created window station '%wZ' with handle 0x%p\n",
759 ObjectAttributes->ObjectName, hWinSta);
760 }
761 else
762 {
763 ASSERT(hWinSta == NULL);
764 ERR("NtUserCreateWindowStation failed to create window station '%wZ', Status 0x%08lx\n",
765 ObjectAttributes->ObjectName, Status);
766 }
767
768 /* Try to restore the user's ObjectAttributes and release the window station name */
769 FreeUserModeWindowStationName(WindowStationName,
770 TebStaticUnicodeString,
771 (OwnerMode == KernelMode ? ObjectAttributes : NULL),
772 &LocalObjectAttributes);
773
774 if (!NT_SUCCESS(Status))
775 {
776 ASSERT(hWinSta == NULL);
777 SetLastNtError(Status);
778 }
779
780 return hWinSta;
781 }
782
783 /*
784 * NtUserOpenWindowStation
785 *
786 * Opens an existing window station.
787 *
788 * Parameters
789 * lpszWindowStationName
790 * Name of the existing window station.
791 *
792 * dwDesiredAccess
793 * Requested type of access.
794 *
795 * Return Value
796 * If the function succeeds, the return value is the handle to the
797 * specified window station. If the function fails, the return value
798 * is NULL.
799 *
800 * Remarks
801 * The returned handle can be closed with NtUserCloseWindowStation.
802 *
803 * Status
804 * @implemented
805 */
806
807 HWINSTA
808 APIENTRY
809 NtUserOpenWindowStation(
810 IN POBJECT_ATTRIBUTES ObjectAttributes,
811 IN ACCESS_MASK dwDesiredAccess)
812 {
813 NTSTATUS Status = STATUS_SUCCESS;
814 HWINSTA hWinSta = NULL;
815 OBJECT_ATTRIBUTES LocalObjectAttributes;
816 PUNICODE_STRING WindowStationName = NULL;
817 PUNICODE_STRING TebStaticUnicodeString = NULL;
818 KPROCESSOR_MODE OwnerMode = UserMode;
819
820 TRACE("NtUserOpenWindowStation called\n");
821
822 /* Capture the object attributes and the window station name */
823 _SEH2_TRY
824 {
825 ProbeForRead(ObjectAttributes, sizeof(OBJECT_ATTRIBUTES), sizeof(ULONG));
826 LocalObjectAttributes = *ObjectAttributes;
827 if (LocalObjectAttributes.Length != sizeof(OBJECT_ATTRIBUTES))
828 {
829 ERR("Invalid ObjectAttributes length!\n");
830 Status = STATUS_INVALID_PARAMETER;
831 _SEH2_LEAVE;
832 }
833
834 /*
835 * Check whether the caller did not provide a window station name,
836 * or provided the special "Service-0x00000000-00000000$" name.
837 *
838 * NOTE: On Windows, the special "Service-0x00000000-00000000$" string
839 * is used instead of an empty name (observed when API-monitoring
840 * OpenWindowStation() called with an empty window station name).
841 */
842 if ((LocalObjectAttributes.ObjectName == NULL ||
843 LocalObjectAttributes.ObjectName->Buffer == NULL ||
844 LocalObjectAttributes.ObjectName->Length == 0 ||
845 LocalObjectAttributes.ObjectName->Buffer[0] == UNICODE_NULL)
846 /* &&
847 LocalObjectAttributes.RootDirectory == NULL */)
848 {
849 /* No, remember that for later */
850 LocalObjectAttributes.ObjectName = NULL;
851 }
852 if (LocalObjectAttributes.ObjectName &&
853 LocalObjectAttributes.ObjectName->Length ==
854 sizeof(L"Service-0x00000000-00000000$") - sizeof(UNICODE_NULL) &&
855 _wcsnicmp(LocalObjectAttributes.ObjectName->Buffer,
856 L"Service-0x00000000-00000000$",
857 LocalObjectAttributes.ObjectName->Length / sizeof(WCHAR)) == 0)
858 {
859 /* No, remember that for later */
860 LocalObjectAttributes.ObjectName = NULL;
861 }
862
863 /*
864 * If the caller did not provide a window station name, build a new one
865 * based on the logon session identifier for the calling process.
866 * The new name is allocated in user-mode, as the rest of ObjectAttributes
867 * already is, so that the validation performed by the Object Manager
868 * can be done adequately.
869 */
870 if (!LocalObjectAttributes.ObjectName)
871 {
872 /* No, build the new window station name */
873 Status = BuildUserModeWindowStationName(ObjectAttributes,
874 &LocalObjectAttributes,
875 &WindowStationName,
876 &TebStaticUnicodeString);
877 if (!NT_SUCCESS(Status))
878 {
879 ERR("BuildUserModeWindowStationName() failed, Status 0x%08lx\n", Status);
880 _SEH2_LEAVE;
881 }
882 OwnerMode = KernelMode;
883 }
884 }
885 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
886 {
887 Status =_SEH2_GetExceptionCode();
888 ERR("ObjectAttributes capture failed, Status 0x%08lx\n", Status);
889 }
890 _SEH2_END;
891
892 if (!NT_SUCCESS(Status))
893 {
894 SetLastNtError(Status);
895 return NULL;
896 }
897
898 /* Open the window station */
899 Status = ObOpenObjectByName(ObjectAttributes,
900 ExWindowStationObjectType,
901 UserMode,
902 NULL,
903 dwDesiredAccess,
904 NULL,
905 (PVOID*)&hWinSta);
906 if (NT_SUCCESS(Status))
907 {
908 TRACE("NtUserOpenWindowStation opened window station '%wZ' with handle 0x%p\n",
909 ObjectAttributes->ObjectName, hWinSta);
910 }
911 else
912 {
913 ASSERT(hWinSta == NULL);
914 ERR("NtUserOpenWindowStation failed to open window station '%wZ', Status 0x%08lx\n",
915 ObjectAttributes->ObjectName, Status);
916 }
917
918 /* Try to restore the user's ObjectAttributes and release the window station name */
919 FreeUserModeWindowStationName(WindowStationName,
920 TebStaticUnicodeString,
921 (OwnerMode == KernelMode ? ObjectAttributes : NULL),
922 &LocalObjectAttributes);
923
924 if (!NT_SUCCESS(Status))
925 {
926 ASSERT(hWinSta == NULL);
927 SetLastNtError(Status);
928 }
929
930 return hWinSta;
931 }
932
933 /*
934 * NtUserCloseWindowStation
935 *
936 * Closes a window station handle.
937 *
938 * Parameters
939 * hWinSta
940 * Handle to the window station.
941 *
942 * Return Value
943 * Status
944 *
945 * Remarks
946 * The window station handle can be created with NtUserCreateWindowStation
947 * or NtUserOpenWindowStation. Attempts to close a handle to the window
948 * station assigned to the calling process will fail.
949 *
950 * Status
951 * @implemented
952 */
953
954 BOOL
955 APIENTRY
956 NtUserCloseWindowStation(
957 HWINSTA hWinSta)
958 {
959 PWINSTATION_OBJECT Object;
960 NTSTATUS Status;
961
962 TRACE("NtUserCloseWindowStation called (%p)\n", hWinSta);
963
964 if (hWinSta == UserGetProcessWindowStation())
965 {
966 ERR("Attempted to close process window station\n");
967 return FALSE;
968 }
969
970 Status = IntValidateWindowStationHandle(hWinSta,
971 UserMode,
972 0,
973 &Object,
974 0);
975
976 if (!NT_SUCCESS(Status))
977 {
978 ERR("Validation of window station handle (%p) failed\n", hWinSta);
979 return FALSE;
980 }
981
982 ObDereferenceObject(Object);
983
984 TRACE("Closing window station handle (%p)\n", hWinSta);
985
986 Status = ObCloseHandle(hWinSta, UserMode);
987 if (!NT_SUCCESS(Status))
988 {
989 SetLastNtError(Status);
990 return FALSE;
991 }
992
993 return TRUE;
994 }
995
996 /*
997 * NtUserGetObjectInformation
998 *
999 * The NtUserGetObjectInformation function retrieves information about a
1000 * window station or desktop object.
1001 *
1002 * Parameters
1003 * hObj
1004 * Handle to the window station or desktop object for which to
1005 * return information. This can be a handle of type HDESK or HWINSTA
1006 * (for example, a handle returned by NtUserCreateWindowStation,
1007 * NtUserOpenWindowStation, NtUserCreateDesktop, or NtUserOpenDesktop).
1008 *
1009 * nIndex
1010 * Specifies the object information to be retrieved.
1011 *
1012 * pvInfo
1013 * Pointer to a buffer to receive the object information.
1014 *
1015 * nLength
1016 * Specifies the size, in bytes, of the buffer pointed to by the
1017 * pvInfo parameter.
1018 *
1019 * lpnLengthNeeded
1020 * Pointer to a variable receiving the number of bytes required to
1021 * store the requested information. If this variable's value is
1022 * greater than the value of the nLength parameter when the function
1023 * returns, the function returns FALSE, and none of the information
1024 * is copied to the pvInfo buffer. If the value of the variable pointed
1025 * to by lpnLengthNeeded is less than or equal to the value of nLength,
1026 * the entire information block is copied.
1027 *
1028 * Return Value
1029 * If the function succeeds, the return value is nonzero. If the function
1030 * fails, the return value is zero.
1031 *
1032 * Status
1033 * @unimplemented
1034 */
1035
1036 BOOL APIENTRY
1037 NtUserGetObjectInformation(
1038 HANDLE hObject,
1039 DWORD nIndex,
1040 PVOID pvInformation,
1041 DWORD nLength,
1042 PDWORD nLengthNeeded)
1043 {
1044 NTSTATUS Status;
1045 PWINSTATION_OBJECT WinStaObject = NULL;
1046 PDESKTOP DesktopObject = NULL;
1047 POBJECT_HEADER ObjectHeader;
1048 POBJECT_HEADER_NAME_INFO NameInfo;
1049 OBJECT_HANDLE_INFORMATION HandleInfo;
1050 USEROBJECTFLAGS ObjectFlags;
1051 PUNICODE_STRING pStrNameU = NULL;
1052 PVOID pvData = NULL;
1053 SIZE_T nDataSize = 0;
1054
1055 _SEH2_TRY
1056 {
1057 if (nLengthNeeded)
1058 ProbeForWrite(nLengthNeeded, sizeof(*nLengthNeeded), 1);
1059 ProbeForWrite(pvInformation, nLength, 1);
1060 }
1061 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1062 {
1063 SetLastNtError(_SEH2_GetExceptionCode());
1064 return FALSE;
1065 }
1066 _SEH2_END;
1067
1068 /* Try window station */
1069 TRACE("Trying to open window station 0x%p\n", hObject);
1070 Status = ObReferenceObjectByHandle(hObject,
1071 0,
1072 ExWindowStationObjectType,
1073 UserMode,
1074 (PVOID*)&WinStaObject,
1075 &HandleInfo);
1076
1077 if (Status == STATUS_OBJECT_TYPE_MISMATCH)
1078 {
1079 /* Try desktop */
1080 TRACE("Trying to open desktop %p\n", hObject);
1081 WinStaObject = NULL;
1082 Status = IntValidateDesktopHandle(hObject,
1083 UserMode,
1084 0,
1085 &DesktopObject);
1086 }
1087
1088 if (!NT_SUCCESS(Status))
1089 {
1090 ERR("Failed: 0x%x\n", Status);
1091 goto Exit;
1092 }
1093
1094 TRACE("WinSta or Desktop opened!\n");
1095
1096 /* Get data */
1097 switch (nIndex)
1098 {
1099 case UOI_FLAGS:
1100 {
1101 ObjectFlags.fReserved = FALSE;
1102 ObjectFlags.fInherit = !!(HandleInfo.HandleAttributes & OBJ_INHERIT);
1103
1104 ObjectFlags.dwFlags = 0;
1105 if (WinStaObject != NULL)
1106 {
1107 if (!(WinStaObject->Flags & WSS_NOIO))
1108 ObjectFlags.dwFlags |= WSF_VISIBLE;
1109 }
1110 else if (DesktopObject != NULL)
1111 {
1112 FIXME("Setting DF_ALLOWOTHERACCOUNTHOOK is unimplemented.\n");
1113 }
1114 else
1115 {
1116 ERR("No associated WinStaObject nor DesktopObject!\n");
1117 }
1118
1119 pvData = &ObjectFlags;
1120 nDataSize = sizeof(ObjectFlags);
1121 Status = STATUS_SUCCESS;
1122 break;
1123 }
1124
1125 case UOI_NAME:
1126 {
1127 if (WinStaObject != NULL)
1128 {
1129 ObjectHeader = OBJECT_TO_OBJECT_HEADER(WinStaObject);
1130 NameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
1131
1132 if (NameInfo && (NameInfo->Name.Length > 0))
1133 {
1134 /* Named window station */
1135 pStrNameU = &NameInfo->Name;
1136 nDataSize = pStrNameU->Length + sizeof(UNICODE_NULL);
1137 }
1138 else
1139 {
1140 /* Unnamed window station (should never happen!) */
1141 ASSERT(FALSE);
1142 pStrNameU = NULL;
1143 nDataSize = sizeof(UNICODE_NULL);
1144 }
1145 Status = STATUS_SUCCESS;
1146 }
1147 else if (DesktopObject != NULL)
1148 {
1149 pvData = DesktopObject->pDeskInfo->szDesktopName;
1150 nDataSize = (wcslen(DesktopObject->pDeskInfo->szDesktopName) + 1) * sizeof(WCHAR);
1151 Status = STATUS_SUCCESS;
1152 }
1153 else
1154 {
1155 Status = STATUS_INVALID_PARAMETER;
1156 }
1157 break;
1158 }
1159
1160 case UOI_TYPE:
1161 {
1162 if (WinStaObject != NULL)
1163 {
1164 ObjectHeader = OBJECT_TO_OBJECT_HEADER(WinStaObject);
1165 pStrNameU = &ObjectHeader->Type->Name;
1166 nDataSize = pStrNameU->Length + sizeof(UNICODE_NULL);
1167 Status = STATUS_SUCCESS;
1168 }
1169 else if (DesktopObject != NULL)
1170 {
1171 ObjectHeader = OBJECT_TO_OBJECT_HEADER(DesktopObject);
1172 pStrNameU = &ObjectHeader->Type->Name;
1173 nDataSize = pStrNameU->Length + sizeof(UNICODE_NULL);
1174 Status = STATUS_SUCCESS;
1175 }
1176 else
1177 {
1178 Status = STATUS_INVALID_PARAMETER;
1179 }
1180 break;
1181 }
1182
1183 case UOI_USER_SID:
1184 Status = STATUS_NOT_IMPLEMENTED;
1185 ERR("UOI_USER_SID unimplemented!\n");
1186 break;
1187
1188 default:
1189 Status = STATUS_INVALID_PARAMETER;
1190 break;
1191 }
1192
1193 Exit:
1194 if ((Status == STATUS_SUCCESS) && (nLength < nDataSize))
1195 Status = STATUS_BUFFER_TOO_SMALL;
1196
1197 _SEH2_TRY
1198 {
1199 if (nLengthNeeded)
1200 *nLengthNeeded = nDataSize;
1201
1202 /* Try to copy data to caller */
1203 if (Status == STATUS_SUCCESS && (nDataSize > 0))
1204 {
1205 TRACE("Trying to copy data to caller (len = %lu, len needed = %lu)\n", nLength, nDataSize);
1206 if (pvData)
1207 {
1208 /* Copy the data */
1209 RtlCopyMemory(pvInformation, pvData, nDataSize);
1210 }
1211 else if (pStrNameU)
1212 {
1213 /* Copy and NULL-terminate the string */
1214 RtlCopyMemory(pvInformation, pStrNameU->Buffer, pStrNameU->Length);
1215 ((PWCHAR)pvInformation)[pStrNameU->Length / sizeof(WCHAR)] = UNICODE_NULL;
1216 }
1217 else
1218 {
1219 /* Zero the memory */
1220 RtlZeroMemory(pvInformation, nDataSize);
1221 }
1222 }
1223 }
1224 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1225 {
1226 Status = _SEH2_GetExceptionCode();
1227 }
1228 _SEH2_END;
1229
1230 /* Release objects */
1231 if (DesktopObject != NULL)
1232 ObDereferenceObject(DesktopObject);
1233 if (WinStaObject != NULL)
1234 ObDereferenceObject(WinStaObject);
1235
1236 if (!NT_SUCCESS(Status))
1237 {
1238 SetLastNtError(Status);
1239 return FALSE;
1240 }
1241
1242 return TRUE;
1243 }
1244
1245 /*
1246 * NtUserSetObjectInformation
1247 *
1248 * The NtUserSetObjectInformation function sets information about a
1249 * window station or desktop object.
1250 *
1251 * Parameters
1252 * hObj
1253 * Handle to the window station or desktop object for which to set
1254 * object information. This value can be a handle of type HDESK or
1255 * HWINSTA.
1256 *
1257 * nIndex
1258 * Specifies the object information to be set.
1259 *
1260 * pvInfo
1261 * Pointer to a buffer containing the object information.
1262 *
1263 * nLength
1264 * Specifies the size, in bytes, of the information contained in the
1265 * buffer pointed to by pvInfo.
1266 *
1267 * Return Value
1268 * If the function succeeds, the return value is nonzero. If the function
1269 * fails the return value is zero.
1270 *
1271 * Status
1272 * @unimplemented
1273 */
1274
1275 BOOL
1276 APIENTRY
1277 NtUserSetObjectInformation(
1278 HANDLE hObject,
1279 DWORD nIndex,
1280 PVOID pvInformation,
1281 DWORD nLength)
1282 {
1283 /* FIXME: ZwQueryObject */
1284 /* FIXME: ZwSetInformationObject */
1285 SetLastNtError(STATUS_UNSUCCESSFUL);
1286 return FALSE;
1287 }
1288
1289
1290 HWINSTA FASTCALL
1291 UserGetProcessWindowStation(VOID)
1292 {
1293 PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
1294
1295 return ppi->hwinsta;
1296 }
1297
1298
1299 /*
1300 * NtUserGetProcessWindowStation
1301 *
1302 * Returns a handle to the current process window station.
1303 *
1304 * Return Value
1305 * If the function succeeds, the return value is handle to the window
1306 * station assigned to the current process. If the function fails, the
1307 * return value is NULL.
1308 *
1309 * Status
1310 * @implemented
1311 */
1312
1313 HWINSTA APIENTRY
1314 NtUserGetProcessWindowStation(VOID)
1315 {
1316 return UserGetProcessWindowStation();
1317 }
1318
1319 BOOL FASTCALL
1320 UserSetProcessWindowStation(HWINSTA hWindowStation)
1321 {
1322 PPROCESSINFO ppi;
1323 NTSTATUS Status;
1324 HWINSTA hwinstaOld;
1325 OBJECT_HANDLE_INFORMATION ObjectHandleInfo;
1326 PWINSTATION_OBJECT NewWinSta = NULL, OldWinSta;
1327
1328 ppi = PsGetCurrentProcessWin32Process();
1329
1330 /* Reference the new window station */
1331 if (hWindowStation != NULL)
1332 {
1333 Status = IntValidateWindowStationHandle(hWindowStation,
1334 UserMode,
1335 0,
1336 &NewWinSta,
1337 &ObjectHandleInfo);
1338 if (!NT_SUCCESS(Status))
1339 {
1340 TRACE("Validation of window station handle (%p) failed\n",
1341 hWindowStation);
1342 SetLastNtError(Status);
1343 return FALSE;
1344 }
1345 }
1346
1347 OldWinSta = ppi->prpwinsta;
1348 hwinstaOld = PsGetProcessWin32WindowStation(ppi->peProcess);
1349
1350 /* Dereference the previous window station */
1351 if (OldWinSta != NULL)
1352 {
1353 ObDereferenceObject(OldWinSta);
1354 }
1355
1356 /* Check if we have a stale handle (it should happen for console apps) */
1357 if (hwinstaOld != ppi->hwinsta)
1358 {
1359 ObCloseHandle(hwinstaOld, UserMode);
1360 }
1361
1362 /*
1363 * FIXME: Don't allow changing the window station if there are threads that are attached to desktops and own GUI objects.
1364 */
1365
1366 PsSetProcessWindowStation(ppi->peProcess, hWindowStation);
1367
1368 ppi->prpwinsta = NewWinSta;
1369 ppi->hwinsta = hWindowStation;
1370 ppi->amwinsta = hWindowStation != NULL ? ObjectHandleInfo.GrantedAccess : 0;
1371 TRACE("WS : Granted Access 0x%08lx\n",ppi->amwinsta);
1372
1373 if (RtlAreAllAccessesGranted(ppi->amwinsta, WINSTA_READSCREEN))
1374 {
1375 ppi->W32PF_flags |= W32PF_READSCREENACCESSGRANTED;
1376 }
1377 else
1378 {
1379 ppi->W32PF_flags &= ~W32PF_READSCREENACCESSGRANTED;
1380 }
1381
1382 if (NewWinSta && !(NewWinSta->Flags & WSS_NOIO))
1383 {
1384 ppi->W32PF_flags |= W32PF_IOWINSTA;
1385 }
1386 else // Might be closed if the handle is null.
1387 {
1388 ppi->W32PF_flags &= ~W32PF_IOWINSTA;
1389 }
1390 return TRUE;
1391 }
1392
1393 /*
1394 * NtUserSetProcessWindowStation
1395 *
1396 * Assigns a window station to the current process.
1397 *
1398 * Parameters
1399 * hWinSta
1400 * Handle to the window station.
1401 *
1402 * Return Value
1403 * Status
1404 *
1405 * Status
1406 * @implemented
1407 */
1408
1409 BOOL APIENTRY
1410 NtUserSetProcessWindowStation(HWINSTA hWindowStation)
1411 {
1412 BOOL ret;
1413
1414 UserEnterExclusive();
1415
1416 ret = UserSetProcessWindowStation(hWindowStation);
1417
1418 UserLeave();
1419
1420 return ret;
1421 }
1422
1423 /*
1424 * NtUserLockWindowStation
1425 *
1426 * Locks switching desktops. Only the logon application is allowed to call this function.
1427 *
1428 * Status
1429 * @implemented
1430 */
1431
1432 BOOL APIENTRY
1433 NtUserLockWindowStation(HWINSTA hWindowStation)
1434 {
1435 PWINSTATION_OBJECT Object;
1436 NTSTATUS Status;
1437
1438 TRACE("About to set process window station with handle (%p)\n",
1439 hWindowStation);
1440
1441 if (gpidLogon != PsGetCurrentProcessId())
1442 {
1443 ERR("Unauthorized process attempted to lock the window station!\n");
1444 EngSetLastError(ERROR_ACCESS_DENIED);
1445 return FALSE;
1446 }
1447
1448 Status = IntValidateWindowStationHandle(hWindowStation,
1449 UserMode,
1450 0,
1451 &Object,
1452 0);
1453 if (!NT_SUCCESS(Status))
1454 {
1455 TRACE("Validation of window station handle (%p) failed\n",
1456 hWindowStation);
1457 SetLastNtError(Status);
1458 return FALSE;
1459 }
1460
1461 Object->Flags |= WSS_LOCKED;
1462
1463 ObDereferenceObject(Object);
1464 return TRUE;
1465 }
1466
1467 /*
1468 * NtUserUnlockWindowStation
1469 *
1470 * Unlocks switching desktops. Only the logon application is allowed to call this function.
1471 *
1472 * Status
1473 * @implemented
1474 */
1475
1476 BOOL APIENTRY
1477 NtUserUnlockWindowStation(HWINSTA hWindowStation)
1478 {
1479 PWINSTATION_OBJECT Object;
1480 NTSTATUS Status;
1481 BOOL Ret;
1482
1483 TRACE("About to set process window station with handle (%p)\n",
1484 hWindowStation);
1485
1486 if (gpidLogon != PsGetCurrentProcessId())
1487 {
1488 ERR("Unauthorized process attempted to unlock the window station!\n");
1489 EngSetLastError(ERROR_ACCESS_DENIED);
1490 return FALSE;
1491 }
1492
1493 Status = IntValidateWindowStationHandle(hWindowStation,
1494 UserMode,
1495 0,
1496 &Object,
1497 0);
1498 if (!NT_SUCCESS(Status))
1499 {
1500 TRACE("Validation of window station handle (%p) failed\n",
1501 hWindowStation);
1502 SetLastNtError(Status);
1503 return FALSE;
1504 }
1505
1506 Ret = (Object->Flags & WSS_LOCKED) == WSS_LOCKED;
1507 Object->Flags &= ~WSS_LOCKED;
1508
1509 ObDereferenceObject(Object);
1510 return Ret;
1511 }
1512
1513 static NTSTATUS FASTCALL
1514 BuildWindowStationNameList(
1515 ULONG dwSize,
1516 PVOID lpBuffer,
1517 PULONG pRequiredSize)
1518 {
1519 OBJECT_ATTRIBUTES ObjectAttributes;
1520 NTSTATUS Status;
1521 HANDLE DirectoryHandle;
1522 char InitialBuffer[256], *Buffer;
1523 ULONG Context, ReturnLength, BufferSize;
1524 DWORD EntryCount;
1525 POBJECT_DIRECTORY_INFORMATION DirEntry;
1526 WCHAR NullWchar;
1527
1528 //
1529 // FIXME: Fully wrong! Since, by calling NtUserCreateWindowStation
1530 // with judicious parameters one can create window stations elsewhere
1531 // than in Windows\WindowStations directory, Win32k definitely MUST
1532 // maintain a list of window stations it has created, and not rely
1533 // on the enumeration of Windows\WindowStations !!!
1534 //
1535
1536 /*
1537 * Try to open the directory.
1538 */
1539 InitializeObjectAttributes(&ObjectAttributes,
1540 &gustrWindowStationsDir,
1541 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1542 NULL,
1543 NULL);
1544
1545 Status = ZwOpenDirectoryObject(&DirectoryHandle,
1546 DIRECTORY_QUERY,
1547 &ObjectAttributes);
1548
1549 if (!NT_SUCCESS(Status))
1550 {
1551 return Status;
1552 }
1553
1554 /* First try to query the directory using a fixed-size buffer */
1555 Context = 0;
1556 Buffer = NULL;
1557 Status = ZwQueryDirectoryObject(DirectoryHandle,
1558 InitialBuffer,
1559 sizeof(InitialBuffer),
1560 FALSE,
1561 TRUE,
1562 &Context,
1563 &ReturnLength);
1564 if (NT_SUCCESS(Status))
1565 {
1566 if (STATUS_NO_MORE_ENTRIES == ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE,
1567 FALSE, &Context, NULL))
1568 {
1569 /* Our fixed-size buffer is large enough */
1570 Buffer = InitialBuffer;
1571 }
1572 }
1573
1574 if (NULL == Buffer)
1575 {
1576 /* Need a larger buffer, check how large exactly */
1577 Status = ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE, TRUE, &Context,
1578 &ReturnLength);
1579 if (!NT_SUCCESS(Status))
1580 {
1581 ERR("ZwQueryDirectoryObject failed\n");
1582 ZwClose(DirectoryHandle);
1583 return Status;
1584 }
1585
1586 BufferSize = ReturnLength;
1587 Buffer = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_WINSTA);
1588 if (NULL == Buffer)
1589 {
1590 ZwClose(DirectoryHandle);
1591 return STATUS_NO_MEMORY;
1592 }
1593
1594 /* We should have a sufficiently large buffer now */
1595 Context = 0;
1596 Status = ZwQueryDirectoryObject(DirectoryHandle, Buffer, BufferSize,
1597 FALSE, TRUE, &Context, &ReturnLength);
1598 if (! NT_SUCCESS(Status) ||
1599 STATUS_NO_MORE_ENTRIES != ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE,
1600 FALSE, &Context, NULL))
1601 {
1602 /* Something went wrong, maybe someone added a directory entry? Just give up. */
1603 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1604 ZwClose(DirectoryHandle);
1605 return NT_SUCCESS(Status) ? STATUS_INTERNAL_ERROR : Status;
1606 }
1607 }
1608
1609 ZwClose(DirectoryHandle);
1610
1611 /*
1612 * Count the required size of buffer.
1613 */
1614 ReturnLength = sizeof(DWORD);
1615 EntryCount = 0;
1616 for (DirEntry = (POBJECT_DIRECTORY_INFORMATION) Buffer;
1617 0 != DirEntry->Name.Length;
1618 DirEntry++)
1619 {
1620 ReturnLength += DirEntry->Name.Length + sizeof(WCHAR);
1621 EntryCount++;
1622 }
1623 TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
1624 if (NULL != pRequiredSize)
1625 {
1626 Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
1627 if (! NT_SUCCESS(Status))
1628 {
1629 if (Buffer != InitialBuffer)
1630 {
1631 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1632 }
1633 return STATUS_BUFFER_TOO_SMALL;
1634 }
1635 }
1636
1637 /*
1638 * Check if the supplied buffer is large enough.
1639 */
1640 if (dwSize < ReturnLength)
1641 {
1642 if (Buffer != InitialBuffer)
1643 {
1644 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1645 }
1646 return STATUS_BUFFER_TOO_SMALL;
1647 }
1648
1649 /*
1650 * Generate the resulting buffer contents.
1651 */
1652 Status = MmCopyToCaller(lpBuffer, &EntryCount, sizeof(DWORD));
1653 if (! NT_SUCCESS(Status))
1654 {
1655 if (Buffer != InitialBuffer)
1656 {
1657 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1658 }
1659 return Status;
1660 }
1661 lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(DWORD));
1662
1663 NullWchar = L'\0';
1664 for (DirEntry = (POBJECT_DIRECTORY_INFORMATION) Buffer;
1665 0 != DirEntry->Name.Length;
1666 DirEntry++)
1667 {
1668 Status = MmCopyToCaller(lpBuffer, DirEntry->Name.Buffer, DirEntry->Name.Length);
1669 if (! NT_SUCCESS(Status))
1670 {
1671 if (Buffer != InitialBuffer)
1672 {
1673 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1674 }
1675 return Status;
1676 }
1677 lpBuffer = (PVOID) ((PCHAR) lpBuffer + DirEntry->Name.Length);
1678 Status = MmCopyToCaller(lpBuffer, &NullWchar, sizeof(WCHAR));
1679 if (! NT_SUCCESS(Status))
1680 {
1681 if (Buffer != InitialBuffer)
1682 {
1683 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1684 }
1685 return Status;
1686 }
1687 lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(WCHAR));
1688 }
1689
1690 /*
1691 * Clean up
1692 */
1693 if (Buffer != InitialBuffer)
1694 {
1695 ExFreePoolWithTag(Buffer, TAG_WINSTA);
1696 }
1697
1698 return STATUS_SUCCESS;
1699 }
1700
1701 static NTSTATUS FASTCALL
1702 BuildDesktopNameList(
1703 HWINSTA hWindowStation,
1704 ULONG dwSize,
1705 PVOID lpBuffer,
1706 PULONG pRequiredSize)
1707 {
1708 NTSTATUS Status;
1709 PWINSTATION_OBJECT WindowStation;
1710 PLIST_ENTRY DesktopEntry;
1711 PDESKTOP DesktopObject;
1712 DWORD EntryCount;
1713 ULONG ReturnLength;
1714 WCHAR NullWchar;
1715 UNICODE_STRING DesktopName;
1716
1717 Status = IntValidateWindowStationHandle(hWindowStation,
1718 UserMode,
1719 0,
1720 &WindowStation,
1721 0);
1722 if (! NT_SUCCESS(Status))
1723 {
1724 return Status;
1725 }
1726
1727 /*
1728 * Count the required size of buffer.
1729 */
1730 ReturnLength = sizeof(DWORD);
1731 EntryCount = 0;
1732 for (DesktopEntry = WindowStation->DesktopListHead.Flink;
1733 DesktopEntry != &WindowStation->DesktopListHead;
1734 DesktopEntry = DesktopEntry->Flink)
1735 {
1736 DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
1737 RtlInitUnicodeString(&DesktopName, DesktopObject->pDeskInfo->szDesktopName);
1738 ReturnLength += DesktopName.Length + sizeof(WCHAR);
1739 EntryCount++;
1740 }
1741 TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
1742 if (NULL != pRequiredSize)
1743 {
1744 Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
1745 if (! NT_SUCCESS(Status))
1746 {
1747 ObDereferenceObject(WindowStation);
1748 return STATUS_BUFFER_TOO_SMALL;
1749 }
1750 }
1751
1752 /*
1753 * Check if the supplied buffer is large enough.
1754 */
1755 if (dwSize < ReturnLength)
1756 {
1757 ObDereferenceObject(WindowStation);
1758 return STATUS_BUFFER_TOO_SMALL;
1759 }
1760
1761 /*
1762 * Generate the resulting buffer contents.
1763 */
1764 Status = MmCopyToCaller(lpBuffer, &EntryCount, sizeof(DWORD));
1765 if (! NT_SUCCESS(Status))
1766 {
1767 ObDereferenceObject(WindowStation);
1768 return Status;
1769 }
1770 lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(DWORD));
1771
1772 NullWchar = L'\0';
1773 for (DesktopEntry = WindowStation->DesktopListHead.Flink;
1774 DesktopEntry != &WindowStation->DesktopListHead;
1775 DesktopEntry = DesktopEntry->Flink)
1776 {
1777 DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
1778 RtlInitUnicodeString(&DesktopName, DesktopObject->pDeskInfo->szDesktopName);
1779 Status = MmCopyToCaller(lpBuffer, DesktopName.Buffer, DesktopName.Length);
1780 if (! NT_SUCCESS(Status))
1781 {
1782 ObDereferenceObject(WindowStation);
1783 return Status;
1784 }
1785 lpBuffer = (PVOID) ((PCHAR)lpBuffer + DesktopName.Length);
1786 Status = MmCopyToCaller(lpBuffer, &NullWchar, sizeof(WCHAR));
1787 if (! NT_SUCCESS(Status))
1788 {
1789 ObDereferenceObject(WindowStation);
1790 return Status;
1791 }
1792 lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(WCHAR));
1793 }
1794
1795 /*
1796 * Clean up and return
1797 */
1798 ObDereferenceObject(WindowStation);
1799 return STATUS_SUCCESS;
1800 }
1801
1802 /*
1803 * NtUserBuildNameList
1804 *
1805 * Function used for enumeration of desktops or window stations.
1806 *
1807 * Parameters
1808 * hWinSta
1809 * For enumeration of window stations this parameter must be set to
1810 * zero. Otherwise it's handle for window station.
1811 *
1812 * dwSize
1813 * Size of buffer passed by caller.
1814 *
1815 * lpBuffer
1816 * Buffer passed by caller. If the function succeeds, the buffer is
1817 * filled with window station/desktop count (in first DWORD) and
1818 * NULL-terminated window station/desktop names.
1819 *
1820 * pRequiredSize
1821 * If the function succeeds, this is the number of bytes copied.
1822 * Otherwise it's size of buffer needed for function to succeed.
1823 *
1824 * Status
1825 * @implemented
1826 */
1827
1828 NTSTATUS APIENTRY
1829 NtUserBuildNameList(
1830 HWINSTA hWindowStation,
1831 ULONG dwSize,
1832 PVOID lpBuffer,
1833 PULONG pRequiredSize)
1834 {
1835 /* The WindowStation name list and desktop name list are build in completely
1836 different ways. Call the appropriate function */
1837 return NULL == hWindowStation ? BuildWindowStationNameList(dwSize, lpBuffer, pRequiredSize) :
1838 BuildDesktopNameList(hWindowStation, dwSize, lpBuffer, pRequiredSize);
1839 }
1840
1841 /*
1842 * @implemented
1843 */
1844 BOOL APIENTRY
1845 NtUserSetLogonNotifyWindow(HWND hWnd)
1846 {
1847 if (gpidLogon != PsGetCurrentProcessId())
1848 {
1849 return FALSE;
1850 }
1851
1852 if (!IntIsWindow(hWnd))
1853 {
1854 return FALSE;
1855 }
1856
1857 hwndSAS = hWnd;
1858
1859 return TRUE;
1860 }
1861
1862 BOOL
1863 APIENTRY
1864 NtUserLockWorkStation(VOID)
1865 {
1866 BOOL ret;
1867 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
1868
1869 UserEnterExclusive();
1870
1871 if (pti->rpdesk == IntGetActiveDesktop())
1872 {
1873 ret = UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_LOCK_WORKSTATION, 0);
1874 }
1875 else
1876 {
1877 ret = FALSE;
1878 }
1879
1880 UserLeave();
1881
1882 return ret;
1883 }
1884
1885 BOOL
1886 NTAPI
1887 NtUserSetWindowStationUser(
1888 IN HWINSTA hWindowStation,
1889 IN PLUID pluid,
1890 IN PSID psid OPTIONAL,
1891 IN DWORD size)
1892 {
1893 BOOL Ret = FALSE;
1894 NTSTATUS Status;
1895 PWINSTATION_OBJECT WindowStation = NULL;
1896 LUID luidUser;
1897
1898 UserEnterExclusive();
1899
1900 if (gpidLogon != PsGetCurrentProcessId())
1901 {
1902 EngSetLastError(ERROR_ACCESS_DENIED);
1903 goto Leave;
1904 }
1905
1906 /* Validate the window station */
1907 Status = IntValidateWindowStationHandle(hWindowStation,
1908 UserMode,
1909 0,
1910 &WindowStation,
1911 NULL);
1912 if (!NT_SUCCESS(Status))
1913 {
1914 goto Leave;
1915 }
1916
1917 /* Capture the user LUID */
1918 _SEH2_TRY
1919 {
1920 ProbeForRead(pluid, sizeof(LUID), 1);
1921 luidUser = *pluid;
1922 }
1923 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1924 {
1925 Status = _SEH2_GetExceptionCode();
1926 _SEH2_YIELD(goto Leave);
1927 }
1928 _SEH2_END;
1929
1930 /* Reset the window station user LUID */
1931 RtlZeroMemory(&WindowStation->luidUser, sizeof(LUID));
1932
1933 /* Reset the window station user SID */
1934 if (WindowStation->psidUser)
1935 {
1936 ExFreePoolWithTag(WindowStation->psidUser, USERTAG_SECURITY);
1937 WindowStation->psidUser = NULL;
1938 }
1939
1940 /* Copy the new user SID if one has been provided */
1941 if (psid)
1942 {
1943 WindowStation->psidUser = ExAllocatePoolWithTag(PagedPool, size, USERTAG_SECURITY);
1944 if (WindowStation->psidUser == NULL)
1945 {
1946 EngSetLastError(ERROR_OUTOFMEMORY);
1947 goto Leave;
1948 }
1949
1950 Status = STATUS_SUCCESS;
1951 _SEH2_TRY
1952 {
1953 ProbeForRead(psid, size, 1);
1954 RtlCopyMemory(WindowStation->psidUser, psid, size);
1955 }
1956 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1957 {
1958 Status = _SEH2_GetExceptionCode();
1959 }
1960 _SEH2_END;
1961
1962 if (!NT_SUCCESS(Status))
1963 {
1964 ExFreePoolWithTag(WindowStation->psidUser, USERTAG_SECURITY);
1965 WindowStation->psidUser = NULL;
1966 goto Leave;
1967 }
1968 }
1969
1970 /* Copy the new user LUID */
1971 WindowStation->luidUser = luidUser;
1972
1973 Ret = TRUE;
1974
1975 Leave:
1976 if (WindowStation)
1977 ObDereferenceObject(WindowStation);
1978
1979 UserLeave();
1980 return Ret;
1981 }
1982
1983 /* EOF */