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