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