desktop.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DESKTOP
struct	_SHELL_HOOK_WINDOW

Macros
#define	DF_TME_HOVER   0x00000400
#define	DF_TME_LEAVE   0x00000800
#define	DF_HOTTRACK   0x00004000
#define	DF_DESTROYED   0x00008000
#define	DF_DESKWNDDESTROYED   0x00010000
#define	DF_DYING   0x00020000
#define	DT_GWL_PROCESSID   0
#define	DT_GWL_THREADID   4
#define	IntIsActiveDesktop(Desktop)    ((Desktop)->rpwinstaParent->ActiveDesktop == (Desktop))
#define	UserIsDesktopWindow(pWnd)    ((pWnd) && ((pWnd)->fnid == FNID_DESKTOP))
#define	UserIsMessageWindow(pWnd)    ((pWnd) && ((pWnd)->fnid == FNID_MESSAGEWND))

Typedefs
typedef struct _DESKTOP	DESKTOP
typedef struct _DESKTOP *	PDESKTOP
typedef struct _SHELL_HOOK_WINDOW	SHELL_HOOK_WINDOW
typedef struct _SHELL_HOOK_WINDOW *	PSHELL_HOOK_WINDOW

Functions
NTSTATUS NTAPI	InitDesktopImpl (VOID)
NTSTATUS APIENTRY	IntDesktopObjectParse (IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context OPTIONAL, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)
NTSTATUS NTAPI	IntDesktopObjectDelete (_In_ PVOID Parameters)
NTSTATUS NTAPI	IntDesktopOkToClose (_In_ PVOID Parameters)
NTSTATUS NTAPI	IntDesktopObjectOpen (_In_ PVOID Parameters)
NTSTATUS NTAPI	IntDesktopObjectClose (_In_ PVOID Parameters)
HDC FASTCALL	IntGetScreenDC (VOID)
HWND FASTCALL	IntGetDesktopWindow (VOID)
PWND FASTCALL	UserGetDesktopWindow (VOID)
HWND FASTCALL	IntGetCurrentThreadDesktopWindow (VOID)
PUSER_MESSAGE_QUEUE FASTCALL	IntGetFocusMessageQueue (VOID)
VOID FASTCALL	IntSetFocusMessageQueue (PUSER_MESSAGE_QUEUE NewQueue)
PDESKTOP FASTCALL	IntGetActiveDesktop (VOID)
NTSTATUS FASTCALL	co_IntShowDesktop (PDESKTOP Desktop, ULONG Width, ULONG Height, BOOL Redraw)
NTSTATUS FASTCALL	IntHideDesktop (PDESKTOP Desktop)
BOOL	IntSetThreadDesktop (IN HDESK hDesktop, IN BOOL FreeOnFailure)
NTSTATUS FASTCALL	IntResolveDesktop (IN PEPROCESS Process, IN PUNICODE_STRING DesktopPath, IN BOOL bInherit, OUT HWINSTA *phWinSta, OUT HDESK *phDesktop)
NTSTATUS FASTCALL	IntValidateDesktopHandle (HDESK Desktop, KPROCESSOR_MODE AccessMode, ACCESS_MASK DesiredAccess, PDESKTOP *Object)
NTSTATUS FASTCALL	IntCreateDesktop (OUT HDESK *phDesktop, IN POBJECT_ATTRIBUTES ObjectAttributes, IN KPROCESSOR_MODE AccessMode, IN PUNICODE_STRING lpszDesktopDevice OPTIONAL, IN LPDEVMODEW lpdmw OPTIONAL, IN DWORD dwFlags, IN ACCESS_MASK dwDesiredAccess)
VOID APIENTRY	UserRedrawDesktop (VOID)
BOOL	IntRegisterShellHookWindow (HWND hWnd)
BOOL	IntDeRegisterShellHookWindow (HWND hWnd)
VOID	co_IntShellHookNotify (WPARAM Message, WPARAM wParam, LPARAM lParam)
HDC FASTCALL	UserGetDesktopDC (ULONG, BOOL, BOOL)
HWND FASTCALL	IntGetMessageWindow (VOID)
PWND FASTCALL	UserGetMessageWindow (VOID)
static __inline PVOID	DesktopHeapAlloc (IN PDESKTOP Desktop, IN SIZE_T Bytes)
static __inline BOOL	DesktopHeapFree (IN PDESKTOP Desktop, IN PVOID lpMem)
static __inline PVOID	DesktopHeapReAlloc (IN PDESKTOP Desktop, IN PVOID lpMem, IN SIZE_T Bytes)
static __inline ULONG_PTR	DesktopHeapGetUserDelta (VOID)
static __inline PVOID	DesktopHeapAddressToUser (PVOID lpMem)
PWND FASTCALL	IntGetThreadDesktopWindow (PTHREADINFO)
PWND FASTCALL	co_GetDesktopWindow (PWND)
BOOL FASTCALL	IntPaintDesktop (HDC)
BOOL FASTCALL	DesktopWindowProc (PWND, UINT, WPARAM, LPARAM, LRESULT *)
BOOL FASTCALL	UserMessageWindowProc (PWND pwnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
VOID NTAPI	DesktopThreadMain (VOID)
HDESK	UserOpenInputDesktop (DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess)

Variables
PDESKTOP	gpdeskInputDesktop
	Currently active desktop.
PCLS	DesktopWindowClass
HDC	ScreenDeviceContext
PTHREADINFO	gptiForeground
PTHREADINFO	gptiDesktopThread
PKEVENT	gpDesktopThreadStartedEvent
PKEVENT	gpDesktopSwitchEvent
	WinSta0_DesktopSwitch legacy (NT 3.5+) event.
HANDLE	ghDesktopSwitchEvent
	WinSta0_DesktopSwitch handle in the CSRSS process.

Macro Definition Documentation

DF_DESKWNDDESTROYED

#define DF_DESKWNDDESTROYED   0x00010000

Definition at line 51 of file desktop.h.

DF_DESTROYED

#define DF_DESTROYED   0x00008000

Definition at line 50 of file desktop.h.

DF_DYING

#define DF_DYING   0x00020000

Definition at line 52 of file desktop.h.

DF_HOTTRACK

#define DF_HOTTRACK   0x00004000

Definition at line 49 of file desktop.h.

DF_TME_HOVER

#define DF_TME_HOVER   0x00000400

Definition at line 47 of file desktop.h.

DF_TME_LEAVE

#define DF_TME_LEAVE   0x00000800

Definition at line 48 of file desktop.h.

DT_GWL_PROCESSID

#define DT_GWL_PROCESSID   0

Definition at line 55 of file desktop.h.

DT_GWL_THREADID

#define DT_GWL_THREADID   4

Definition at line 56 of file desktop.h.

IntIsActiveDesktop

#define IntIsActiveDesktop

(

Desktop

)

((Desktop)->rpwinstaParent->ActiveDesktop == (Desktop))

Definition at line 174 of file desktop.h.

UserIsDesktopWindow

#define UserIsDesktopWindow

(

pWnd

)

((pWnd) && ((pWnd)->fnid == FNID_DESKTOP))

Definition at line 196 of file desktop.h.

UserIsMessageWindow

#define UserIsMessageWindow

(

pWnd

)

((pWnd) && ((pWnd)->fnid == FNID_MESSAGEWND))

Definition at line 199 of file desktop.h.

Typedef Documentation

DESKTOP

typedef struct _DESKTOP DESKTOP

PDESKTOP

typedef struct _DESKTOP * PDESKTOP

PSHELL_HOOK_WINDOW

typedef struct _SHELL_HOOK_WINDOW * PSHELL_HOOK_WINDOW

SHELL_HOOK_WINDOW

typedef struct _SHELL_HOOK_WINDOW SHELL_HOOK_WINDOW

Function Documentation

co_GetDesktopWindow()

PWND FASTCALL co_GetDesktopWindow

(

PWND

pWnd

)

Definition at line 1394 of file desktop.c.

{
    if (pWnd->head.rpdesk &&
        pWnd->head.rpdesk->pDeskInfo)
        return pWnd->head.rpdesk->pDeskInfo->spwnd;
    return NULL;
}

Referenced by co_IntSendActivateMessages(), co_IntSetParent(), co_UserCreateWindowEx(), IntDefWindowProc(), IntIsTopLevelWindow(), and IntWinListOwnedPopups().

co_IntShellHookNotify()

VOID co_IntShellHookNotify	(	WPARAM	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1712 of file desktop.c.

{
    PDESKTOP Desktop = IntGetActiveDesktop();
    HWND* HwndList;
 
    if (!gpsi->uiShellMsg)
    {
        gpsi->uiShellMsg = IntAddAtom(L"SHELLHOOK");
 
        TRACE("MsgType = %x\n", gpsi->uiShellMsg);
        if (!gpsi->uiShellMsg)
            ERR("LastError: %x\n", EngGetLastError());
    }
 
    if (!Desktop)
    {
        TRACE("IntShellHookNotify: No desktop!\n");
        return;
    }
 
    // Allow other devices have a shot at foreground.
    if (Message == HSHELL_APPCOMMAND) ptiLastInput = NULL;
 
    // FIXME: System Tray Support.
 
    HwndList = UserBuildShellHookHwndList(Desktop);
    if (HwndList)
    {
        HWND* cursor = HwndList;
        LPARAM shellhookparam = (Message == HSHELL_LANGUAGE || Message == HSHELL_APPCOMMAND)
                                ? lParam : (LPARAM)wParam;
 
        for (; *cursor; cursor++)
        {
            TRACE("Sending notify\n");
            UserPostMessage(*cursor,
                            gpsi->uiShellMsg,
                            Message,
                            shellhookparam);
/*            co_IntPostOrSendMessage(*cursor,
                                    gpsi->uiShellMsg,
                                    Message,
                                    shellhookparam);*/
        }
 
        ExFreePoolWithTag(HwndList, USERTAG_WINDOWLIST);
    }
 
    if (ISITHOOKED(WH_SHELL))
    {
        co_HOOK_CallHooks(WH_SHELL, Message, wParam, lParam);
    }
}

Referenced by co_IntLoadKeyboardLayoutEx(), co_IntUnloadKeyboardLayoutEx(), co_UserActivateKeyboardLayout(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserProcessHotKeys(), co_WinPosSetWindowPos(), DefSetText(), IntCheckFullscreen(), IntDefWindowProc(), NtUserCallHwndLock(), NtUserDefSetText(), and UpdateShellHook().

co_IntShowDesktop()

NTSTATUS FASTCALL co_IntShowDesktop	(	PDESKTOP	Desktop,
		ULONG	Width,
		ULONG	Height,
		BOOL	Redraw
	)

Definition at line 1637 of file desktop.c.

{
    PWND pwnd = Desktop->pDeskInfo->spwnd;
    UINT flags = SWP_NOACTIVATE|SWP_NOZORDER|SWP_SHOWWINDOW;
    ASSERT(pwnd);
 
    if (!bRedraw)
        flags |= SWP_NOREDRAW;
 
    co_WinPosSetWindowPos(pwnd, NULL, 0, 0, Width, Height, flags);
 
    if (bRedraw)
        co_UserRedrawWindow( pwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN | RDW_INVALIDATE );
 
    return STATUS_SUCCESS;
}

Referenced by co_IntInitializeDesktopGraphics(), and NtUserSwitchDesktop().

DesktopHeapAddressToUser()

static __inline PVOID DesktopHeapAddressToUser ( PVOID  lpMem )

static

Definition at line 310 of file desktop.h.

{
    PW32HEAP_USER_MAPPING Mapping;
    PPROCESSINFO W32Process;
 
    W32Process = PsGetCurrentProcessWin32Process();
 
    /*
     * Start the search at the next mapping: skip the first entry
     * as it must be the global user heap mapping.
     */
    Mapping = W32Process->HeapMappings.Next;
    while (Mapping != NULL)
    {
        if ((ULONG_PTR)lpMem >= (ULONG_PTR)Mapping->KernelMapping &&
            (ULONG_PTR)lpMem < (ULONG_PTR)Mapping->KernelMapping + Mapping->Limit)
        {
            return (PVOID)(((ULONG_PTR)lpMem - (ULONG_PTR)Mapping->KernelMapping) +
                           (ULONG_PTR)Mapping->UserMapping);
        }
 
        Mapping = Mapping->Next;
    }
 
    return NULL;
}

Referenced by IntSetTebWndCallback(), NtUserCallOneParam(), and UserFreeWindowInfo().

DesktopHeapAlloc()

static __inline PVOID DesktopHeapAlloc ( IN PDESKTOP  Desktop, IN SIZE_T  Bytes  )

static

Definition at line 206 of file desktop.h.

{
    /* Desktop heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
    return RtlAllocateHeap(Desktop->pheapDesktop,
                           HEAP_NO_SERIALIZE,
                           Bytes);
}

Referenced by AllocInputContextObject(), co_IntCreateScrollBars(), DefSetText(), IntCloneMenuItems(), IntCreateClass(), IntCreateWindow(), IntGetClassForDesktop(), IntSetMenuItemInfo(), IntSetThreadDesktop(), MENU_InsertItem(), NtUserDefSetText(), and PopupMenuWndProc().

DesktopHeapFree()

static __inline BOOL DesktopHeapFree ( IN PDESKTOP  Desktop, IN PVOID  lpMem  )

static

Definition at line 217 of file desktop.h.

{
    /* Desktop heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
    return RtlFreeHeap(Desktop->pheapDesktop,
                       HEAP_NO_SERIALIZE,
                       lpMem);
}

Referenced by DefSetText(), FreeDeskProcObject(), FreeDeskThreadObject(), IntCloneMenuItems(), IntCreateClass(), IntDestroyClass(), IntDestroyMenu(), IntDestroyScrollBars(), IntRemoveMenuItem(), IntSetThreadDesktop(), MENU_InsertItem(), NtUserDefSetText(), PopupMenuWndProc(), UserFreeInputContext(), and UserFreeWindowInfo().

DesktopHeapGetUserDelta()

static __inline ULONG_PTR DesktopHeapGetUserDelta ( VOID  )

static

Definition at line 274 of file desktop.h.

{
    PW32HEAP_USER_MAPPING Mapping;
    PTHREADINFO pti;
    PPROCESSINFO W32Process;
    PWIN32HEAP pheapDesktop;
    ULONG_PTR Delta = 0;
 
    pti = PsGetCurrentThreadWin32Thread();
    if (!pti->rpdesk)
        return 0;
 
    pheapDesktop = pti->rpdesk->pheapDesktop;
 
    W32Process = PsGetCurrentProcessWin32Process();
 
    /*
     * Start the search at the next mapping: skip the first entry
     * as it must be the global user heap mapping.
     */
    Mapping = W32Process->HeapMappings.Next;
    while (Mapping != NULL)
    {
        if (Mapping->KernelMapping == (PVOID)pheapDesktop)
        {
            Delta = (ULONG_PTR)Mapping->KernelMapping - (ULONG_PTR)Mapping->UserMapping;
            break;
        }
 
        Mapping = Mapping->Next;
    }
 
    return Delta;
}

Referenced by IntSetThreadDesktop(), and UserDbgAssertThreadInfo().

DesktopHeapReAlloc()

static __inline PVOID DesktopHeapReAlloc ( IN PDESKTOP  Desktop, IN PVOID  lpMem, IN SIZE_T  Bytes  )

static

Definition at line 228 of file desktop.h.

{
#if 0
    /* NOTE: ntoskrnl doesn't export RtlReAllocateHeap... */
    return RtlReAllocateHeap(Desktop->pheapDesktop,
                             HEAP_NO_SERIALIZE,
                             lpMem,
                             Bytes);
#else
    SIZE_T PrevSize;
    PVOID pNew;
 
    /* Desktop heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
 
    PrevSize = RtlSizeHeap(Desktop->pheapDesktop,
                           HEAP_NO_SERIALIZE,
                           lpMem);
 
    if (PrevSize == Bytes)
        return lpMem;
 
    pNew = RtlAllocateHeap(Desktop->pheapDesktop,
                           HEAP_NO_SERIALIZE,
                           Bytes);
    if (pNew != NULL)
    {
        if (PrevSize < Bytes)
            Bytes = PrevSize;
 
        RtlCopyMemory(pNew,
                      lpMem,
                      Bytes);
 
        RtlFreeHeap(Desktop->pheapDesktop,
                    HEAP_NO_SERIALIZE,
                    lpMem);
    }
 
    return pNew;
#endif
}

Referenced by IntRemoveMenuItem().

DesktopThreadMain()

VOID NTAPI DesktopThreadMain

(

VOID

)

Definition at line 1566 of file desktop.c.

{
    BOOL Ret;
    MSG Msg;
 
    gptiDesktopThread = PsGetCurrentThreadWin32Thread();
 
    UserEnterExclusive();
 
    /* Register system classes. This thread does not belong to any desktop so the
       classes will be allocated from the shared heap */
    UserRegisterSystemClasses();
 
    KeSetEvent(gpDesktopThreadStartedEvent, IO_NO_INCREMENT, FALSE);
 
    while (TRUE)
    {
        Ret = co_IntGetPeekMessage(&Msg, 0, 0, 0, PM_REMOVE, TRUE);
        if (Ret)
        {
            IntDispatchMessage(&Msg);
        }
    }
 
    UserLeave();
}

Referenced by UserSystemThreadProc().

DesktopWindowProc()

BOOL FASTCALL DesktopWindowProc	(	PWND	Wnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	lResult
	)

Definition at line 1462 of file desktop.c.

{
    *lResult = 0;
 
    switch (Msg)
    {
        case WM_NCCREATE:
            if (!Wnd->fnid)
                Wnd->fnid = FNID_DESKTOP;
            *lResult = (LRESULT)TRUE;
            return TRUE;
 
        case WM_CREATE:
        {
            /* Save process and thread IDs */
            ULONG Value;
            Value = HandleToULong(PsGetCurrentProcessId());
            co_UserSetWindowLong(UserHMGetHandle(Wnd), DT_GWL_PROCESSID, Value, FALSE);
            Value = HandleToULong(PsGetCurrentThreadId());
            co_UserSetWindowLong(UserHMGetHandle(Wnd), DT_GWL_THREADID, Value, FALSE);
            __fallthrough;
        }
        case WM_CLOSE:
            return TRUE;
 
        case WM_DISPLAYCHANGE:
            co_WinPosSetWindowPos(Wnd, 0, 0, 0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER | SWP_NOACTIVATE);
            return TRUE;
 
        case WM_ERASEBKGND:
            IntPaintDesktop((HDC)wParam);
            *lResult = (LRESULT)TRUE;
            return TRUE;
 
        case WM_PAINT:
        {
            PAINTSTRUCT Ps;
            if (IntBeginPaint(Wnd, &Ps))
                IntEndPaint(Wnd, &Ps);
            return TRUE;
        }
 
        case WM_SYSCOLORCHANGE:
            co_UserRedrawWindow(Wnd, NULL, NULL, RDW_INVALIDATE|RDW_ERASE|RDW_ALLCHILDREN);
            return TRUE;
 
        case WM_SETCURSOR:
        {
            PCURICON_OBJECT pcurOld, pcurNew;
            pcurNew = UserGetCurIconObject(gDesktopCursor);
            if (!pcurNew)
                return TRUE;
 
            pcurNew->CURSORF_flags |= CURSORF_CURRENT;
            pcurOld = UserSetCursor(pcurNew, FALSE);
            if (pcurOld)
            {
                pcurOld->CURSORF_flags &= ~CURSORF_CURRENT;
                UserDereferenceObject(pcurOld);
            }
            return TRUE;
        }
 
        case WM_WINDOWPOSCHANGING:
        {
            PWINDOWPOS pWindowPos = (PWINDOWPOS)lParam;
            if ((pWindowPos->flags & SWP_SHOWWINDOW) != 0)
            {
                HDESK hdesk = UserOpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
                IntSetThreadDesktop(hdesk, FALSE);
            }
            break;
        }
 
        default:
            TRACE("DWP calling IDWP Msg %d\n",Msg);
            *lResult = IntDefWindowProc(Wnd, Msg, wParam, lParam, FALSE);
    }
 
    return TRUE; /* We are done. Do not do any callbacks to user mode */
}

Referenced by co_IntSendMessageTimeoutSingle(), co_IntSendMessageWithCallBack(), IntDispatchMessage(), and NtUserMessageCall().

InitDesktopImpl()

NTSTATUS NTAPI InitDesktopImpl

(

VOID

)

Definition at line 276 of file desktop.c.

{
    GENERIC_MAPPING IntDesktopMapping = { DESKTOP_READ,
                                          DESKTOP_WRITE,
                                          DESKTOP_EXECUTE,
                                          DESKTOP_ALL_ACCESS};
 
    /* Set Desktop Object Attributes */
    ExDesktopObjectType->TypeInfo.DefaultNonPagedPoolCharge = sizeof(DESKTOP);
    ExDesktopObjectType->TypeInfo.GenericMapping = IntDesktopMapping;
    ExDesktopObjectType->TypeInfo.ValidAccessMask = DESKTOP_ALL_ACCESS;
 
    /* Allocate memory for the event structure */
    gpDesktopThreadStartedEvent = ExAllocatePoolWithTag(NonPagedPool,
                                                        sizeof(KEVENT),
                                                        USERTAG_EVENT);
    if (!gpDesktopThreadStartedEvent)
    {
        ERR("Failed to allocate event!\n");
        return STATUS_NO_MEMORY;
    }
 
    /* Initialize the kernel event */
    KeInitializeEvent(gpDesktopThreadStartedEvent,
                      SynchronizationEvent,
                      FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

IntCreateDesktop()

NTSTATUS FASTCALL IntCreateDesktop	(	OUT HDESK *	phDesktop,
		IN POBJECT_ATTRIBUTES	ObjectAttributes,
		IN KPROCESSOR_MODE	AccessMode,
		IN PUNICODE_STRING lpszDesktopDevice	OPTIONAL,
		IN LPDEVMODEW lpdmw	OPTIONAL,
		IN DWORD	dwFlags,
		IN ACCESS_MASK	dwDesiredAccess
	)

Definition at line 2481 of file desktop.c.

{
    NTSTATUS Status;
    PDESKTOP pdesk = NULL;
    HDESK hDesk;
    BOOLEAN Context = FALSE;
    UNICODE_STRING ClassName;
    LARGE_STRING WindowName;
    BOOL NoHooks = FALSE;
    PWND pWnd = NULL;
    CREATESTRUCTW Cs;
    PTHREADINFO ptiCurrent;
    PCLS pcls;
 
    TRACE("Enter IntCreateDesktop\n");
 
    ASSERT(UserIsEnteredExclusive());
 
    ASSERT(phDesktop);
    *phDesktop = NULL;
 
    ptiCurrent = PsGetCurrentThreadWin32Thread();
    ASSERT(ptiCurrent);
    ASSERT(gptiDesktopThread);
 
    /* Turn off hooks when calling any CreateWindowEx from inside win32k */
    NoHooks = (ptiCurrent->TIF_flags & TIF_DISABLEHOOKS);
    ptiCurrent->TIF_flags |= TIF_DISABLEHOOKS;
    ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;
 
    /*
     * Try to open already existing desktop
     */
    Status = ObOpenObjectByName(ObjectAttributes,
                                ExDesktopObjectType,
                                AccessMode,
                                NULL,
                                dwDesiredAccess,
                                (PVOID)&Context,
                                (PHANDLE)&hDesk);
    if (!NT_SUCCESS(Status))
    {
        ERR("ObOpenObjectByName failed to open/create desktop\n");
        goto Quit;
    }
 
    /* In case the object was not created (eg if it existed), return now */
    if (Context == FALSE)
    {
        TRACE("IntCreateDesktop opened desktop '%wZ'\n", ObjectAttributes->ObjectName);
        Status = STATUS_SUCCESS;
        goto Quit;
    }
 
    /* Reference the desktop */
    Status = ObReferenceObjectByHandle(hDesk,
                                       0,
                                       ExDesktopObjectType,
                                       KernelMode,
                                       (PVOID*)&pdesk,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to reference desktop object\n");
        goto Quit;
    }
 
    /* Get the desktop window class. The thread desktop does not belong to any desktop
     * so the classes created there (including the desktop class) are allocated in the shared heap
     * It would cause problems if we used a class that belongs to the caller
     */
    ClassName.Buffer = WC_DESKTOP;
    ClassName.Length = 0;
    pcls = IntGetAndReferenceClass(&ClassName, 0, TRUE);
    if (pcls == NULL)
    {
        ASSERT(FALSE);
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    RtlZeroMemory(&WindowName, sizeof(WindowName));
    RtlZeroMemory(&Cs, sizeof(Cs));
    Cs.x = UserGetSystemMetrics(SM_XVIRTUALSCREEN),
    Cs.y = UserGetSystemMetrics(SM_YVIRTUALSCREEN),
    Cs.cx = UserGetSystemMetrics(SM_CXVIRTUALSCREEN),
    Cs.cy = UserGetSystemMetrics(SM_CYVIRTUALSCREEN),
    Cs.style = WS_POPUP|WS_CLIPCHILDREN;
    Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
    Cs.lpszName = (LPCWSTR) &WindowName;
    Cs.lpszClass = (LPCWSTR) &ClassName;
 
    /* Use IntCreateWindow instead of co_UserCreateWindowEx because the later expects a thread with a desktop */
    pWnd = IntCreateWindow(&Cs, &WindowName, pcls, NULL, NULL, NULL, pdesk, WINVER);
    if (pWnd == NULL)
    {
        ERR("Failed to create desktop window for the new desktop\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
    pWnd->fnid = FNID_DESKTOP;
 
    /* Assign the desktop window to the desktop */
    pdesk->DesktopWindow = UserHMGetHandle(pWnd);
    pdesk->pDeskInfo->spwnd = pWnd;
 
    ClassName.Buffer = MAKEINTATOM(gpsi->atomSysClass[ICLS_HWNDMESSAGE]);
    ClassName.Length = 0;
    pcls = IntGetAndReferenceClass(&ClassName, 0, TRUE);
    if (pcls == NULL)
    {
        ASSERT(FALSE);
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    RtlZeroMemory(&WindowName, sizeof(WindowName));
    RtlZeroMemory(&Cs, sizeof(Cs));
    Cs.cx = Cs.cy = 100;
    Cs.style = WS_POPUP|WS_CLIPCHILDREN;
    Cs.hInstance = hModClient; // hModuleWin; // Server side winproc!
    Cs.lpszName = (LPCWSTR)&WindowName;
    Cs.lpszClass = (LPCWSTR)&ClassName;
    pWnd = IntCreateWindow(&Cs, &WindowName, pcls, NULL, NULL, NULL, pdesk, WINVER);
    if (pWnd == NULL)
    {
        ERR("Failed to create message window for the new desktop\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quit;
    }
    pWnd->fnid = FNID_MESSAGEWND;
 
    /* Assign the message window to the desktop */
    pdesk->spwndMessage = pWnd;
 
    /* Now...
       if !(WinStaObject->Flags & WSF_NOIO) is (not set) for desktop input output mode (see wiki)
       Create Tooltip. Saved in DesktopObject->spwndTooltip.
       Tooltip dwExStyle: WS_EX_TOOLWINDOW|WS_EX_TOPMOST
       hWndParent are spwndMessage. Use hModuleWin for server side winproc!
       The rest is same as message window.
       https://learn.microsoft.com/en-us/windows/win32/controls/tooltip-controls
    */
    Status = STATUS_SUCCESS;
 
Quit:
    if (pdesk != NULL)
    {
        ObDereferenceObject(pdesk);
    }
    if (!NT_SUCCESS(Status) && hDesk != NULL)
    {
        ObCloseHandle(hDesk, AccessMode);
        hDesk = NULL;
    }
    if (!NoHooks)
    {
        ptiCurrent->TIF_flags &= ~TIF_DISABLEHOOKS;
        ptiCurrent->pClientInfo->dwTIFlags = ptiCurrent->TIF_flags;
    }
 
    TRACE("Leave IntCreateDesktop, Status 0x%08lx\n", Status);
 
    if (NT_SUCCESS(Status))
        *phDesktop = hDesk;
    else
        SetLastNtError(Status);
    return Status;
}

Referenced by IntResolveDesktop(), and NtUserCreateDesktop().

IntDeRegisterShellHookWindow()

BOOL IntDeRegisterShellHookWindow

(

HWND

hWnd

)

Definition at line 1806 of file desktop.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    PDESKTOP Desktop = pti->rpdesk;
    PLIST_ENTRY ListEntry;
    PSHELL_HOOK_WINDOW Current;
 
    // FIXME: This probably shouldn't happen, but it does
    if (Desktop == NULL)
    {
        Desktop = IntGetActiveDesktop();
        if (Desktop == NULL)
            return FALSE;
    }
 
    ListEntry = Desktop->ShellHookWindows.Flink;
    while (ListEntry != &Desktop->ShellHookWindows)
    {
        Current = CONTAINING_RECORD(ListEntry, SHELL_HOOK_WINDOW, ListEntry);
        ListEntry = ListEntry->Flink;
        if (Current->hWnd == hWnd)
        {
            RemoveEntryList(&Current->ListEntry);
            ExFreePoolWithTag(Current, TAG_WINSTA);
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by co_UserFreeWindow(), IntRegisterShellHookWindow(), and NtUserCallHwnd().

IntDesktopObjectClose()

NTSTATUS NTAPI IntDesktopObjectClose

(

_In_ PVOID

Parameters

)

Definition at line 251 of file desktop.c.

{
    NTSTATUS Ret;
    PWIN32_CLOSEMETHOD_PARAMETERS CloseParameters = Parameters;
    PPROCESSINFO ppi = PsGetProcessWin32Process(CloseParameters->Process);
    if (ppi == NULL)
    {
        /* This happens when the process leaks desktop handles.
         * At this point the PPROCESSINFO is already destroyed */
        return STATUS_SUCCESS;
    }
 
    UserEnterExclusive();
    Ret = IntUnmapDesktopView((PDESKTOP)CloseParameters->Object);
    UserLeave();
    return Ret;
}

Referenced by DriverEntry().

IntDesktopObjectDelete()

NTSTATUS NTAPI IntDesktopObjectDelete

(

_In_ PVOID

Parameters

)

Definition at line 179 of file desktop.c.

{
    PWIN32_DELETEMETHOD_PARAMETERS DeleteParameters = Parameters;
    PDESKTOP pdesk = (PDESKTOP)DeleteParameters->Object;
 
    TRACE("Deleting desktop object 0x%p\n", pdesk);
 
    if (pdesk->pDeskInfo &&
        pdesk->pDeskInfo->spwnd)
    {
        ASSERT(pdesk->pDeskInfo->spwnd->spwndChild == NULL);
        co_UserDestroyWindow(pdesk->pDeskInfo->spwnd);
    }
 
    if (pdesk->spwndMessage)
        co_UserDestroyWindow(pdesk->spwndMessage);
 
    /* Remove the desktop from the window station's list of associated desktops */
    RemoveEntryList(&pdesk->ListEntry);
 
    /* Free the heap */
    IntFreeDesktopHeap(pdesk);
 
    ObDereferenceObject(pdesk->rpwinstaParent);
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

IntDesktopObjectOpen()

NTSTATUS NTAPI IntDesktopObjectOpen

(

_In_ PVOID

Parameters

)

Definition at line 234 of file desktop.c.

{
    NTSTATUS Ret;
    PWIN32_OPENMETHOD_PARAMETERS OpenParameters = Parameters;
    PPROCESSINFO ppi = PsGetProcessWin32Process(OpenParameters->Process);
    if (ppi == NULL)
        return STATUS_SUCCESS;
 
    UserEnterExclusive();
    Ret = IntMapDesktopView((PDESKTOP)OpenParameters->Object);
    UserLeave();
    return Ret;
}

Referenced by DriverEntry().

IntDesktopObjectParse()

NTSTATUS APIENTRY IntDesktopObjectParse	(	IN PVOID	ParseObject,
		IN PVOID	ObjectType,
		IN OUT PACCESS_STATE	AccessState,
		IN KPROCESSOR_MODE	AccessMode,
		IN ULONG	Attributes,
		IN OUT PUNICODE_STRING	CompleteName,
		IN OUT PUNICODE_STRING	RemainingName,
		IN OUT PVOID Context	OPTIONAL,
		IN PSECURITY_QUALITY_OF_SERVICE SecurityQos	OPTIONAL,
		OUT PVOID *	Object
	)

Definition at line 63 of file desktop.c.

{
    NTSTATUS Status;
    PDESKTOP Desktop;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PLIST_ENTRY NextEntry, ListHead;
    PWINSTATION_OBJECT WinStaObject = (PWINSTATION_OBJECT)ParseObject;
    UNICODE_STRING DesktopName;
    PBOOLEAN pContext = (PBOOLEAN) Context;
 
    if (pContext)
        *pContext = FALSE;
 
    /* Set the list pointers and loop the window station */
    ListHead = &WinStaObject->DesktopListHead;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the current desktop */
        Desktop = CONTAINING_RECORD(NextEntry, DESKTOP, ListEntry);
 
        /* Get the desktop name */
        ASSERT(Desktop->pDeskInfo != NULL);
        RtlInitUnicodeString(&DesktopName, Desktop->pDeskInfo->szDesktopName);
 
        /* Compare the name */
        if (RtlEqualUnicodeString(RemainingName,
                                  &DesktopName,
                                  (Attributes & OBJ_CASE_INSENSITIVE) != 0))
        {
            /* We found a match. Did this come from a create? */
            if (Context)
            {
                /* Unless OPEN_IF was given, fail with an error */
                if (!(Attributes & OBJ_OPENIF))
                {
                    /* Name collision */
                    return STATUS_OBJECT_NAME_COLLISION;
                }
                else
                {
                    /* Otherwise, return with a warning only */
                    Status = STATUS_OBJECT_NAME_EXISTS;
                }
            }
            else
            {
                /* This was a real open, so this is OK */
                Status = STATUS_SUCCESS;
            }
 
            /* Reference the desktop and return it */
            ObReferenceObject(Desktop);
            *Object = Desktop;
            return Status;
        }
 
        /* Go to the next desktop */
        NextEntry = NextEntry->Flink;
    }
 
    /* If we got here but this isn't a create, just fail */
    if (!Context) return STATUS_OBJECT_NAME_NOT_FOUND;
 
    /* Create the desktop object */
    InitializeObjectAttributes(&ObjectAttributes, RemainingName, 0, NULL, NULL);
    Status = ObCreateObject(KernelMode,
                            ExDesktopObjectType,
                            &ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(DESKTOP),
                            0,
                            0,
                            (PVOID*)&Desktop);
    if (!NT_SUCCESS(Status))
        return Status;
    RtlZeroMemory(Desktop, sizeof(DESKTOP));
 
    /* Assign the session ID to the desktop */
    Desktop->dwSessionId = PsGetCurrentProcessSessionId(); // gSessionId
    ASSERT(Desktop->dwSessionId == WinStaObject->dwSessionId);
 
    /* Assign security to the desktop we have created */
    Status = IntAssignDesktopSecurityOnParse(WinStaObject, Desktop, AccessState);
    if (!NT_SUCCESS(Status))
    {
        ObDereferenceObject(Desktop);
        return Status;
    }
 
    /* Initialize the desktop */
    Status = UserInitializeDesktop(Desktop, RemainingName, WinStaObject);
    if (!NT_SUCCESS(Status))
    {
        ObDereferenceObject(Desktop);
        return Status;
    }
 
    /* Set the desktop object and return success */
    *Object = Desktop;
    *pContext = TRUE;
    return STATUS_SUCCESS;
}

Referenced by IntWinStaObjectParse().

IntDesktopOkToClose()

NTSTATUS NTAPI IntDesktopOkToClose

(

_In_ PVOID

Parameters

)

Definition at line 210 of file desktop.c.

{
    PWIN32_OKAYTOCLOSEMETHOD_PARAMETERS OkToCloseParameters = Parameters;
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    if (pti == NULL)
    {
        /* This happens when we leak desktop handles */
        return STATUS_SUCCESS;
    }
 
    /* Do not allow the current desktop or the initial desktop to be closed */
    if (OkToCloseParameters->Handle == pti->ppi->hdeskStartup ||
        OkToCloseParameters->Handle == pti->hdesk)
    {
        return STATUS_ACCESS_DENIED;
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

IntGetActiveDesktop()

PDESKTOP FASTCALL IntGetActiveDesktop

(

VOID

)

Definition at line 1290 of file desktop.c.

{
    return gpdeskInputDesktop;
}

Referenced by co_HOOK_CallHooks(), co_IntInitializeDesktopGraphics(), co_IntShellHookNotify(), IntDeRegisterShellHookWindow(), IntEndDesktopGraphics(), IntGetDesktopWindow(), IntGetFocusMessageQueue(), IntGetMessageWindow(), IntRemoveHook(), IntSetFocusMessageQueue(), NtUserBuildHwndList(), NtUserCallOneParam(), NtUserLockWorkStation(), UserGetDesktopWindow(), and UserGetMessageWindow().

IntGetCurrentThreadDesktopWindow()

HWND FASTCALL IntGetCurrentThreadDesktopWindow

(

VOID

)

Definition at line 1447 of file desktop.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    PDESKTOP pdo = pti->rpdesk;
    if (!pdo)
    {
        ERR("Thread doesn't have a desktop\n");
        return NULL;
    }
    return pdo->DesktopWindow;
}

Referenced by NtUserFindWindowEx().

IntGetDesktopWindow()

HWND FASTCALL IntGetDesktopWindow

(

VOID

)

Definition at line 1402 of file desktop.c.

{
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return NULL;
    }
    return pdo->DesktopWindow;
}

Referenced by co_IntProcessKeyboardMessage(), co_IntSetWindowLongPtr(), co_UserSetParent(), co_WinPosSetWindowPos(), DceUpdateVisRgn(), IntPaintDesktop(), NtUserAlterWindowStyle(), NtUserRedrawWindow(), NtUserSetParent(), NtUserSetWindowLong(), NtUserSetWindowWord(), NtUserWindowFromPoint(), SnapWindow(), UserRealizePalette(), and UserRegisterUserApiHook().

IntGetFocusMessageQueue()

PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue

(

VOID

)

Definition at line 1335 of file desktop.c.

{
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return(NULL);
    }
    return (PUSER_MESSAGE_QUEUE)pdo->ActiveMessageQueue;
}

Referenced by co_IntSetForegroundAndFocusWindow(), co_UserSetFocus(), co_WinPosShowWindow(), DoTheScreenSaver(), IntGetCaptureWindow(), IntHandleAltNumpad(), IntSendDestroyMsg(), NtUserGetGUIThreadInfo(), ProcessKeyEvent(), UserGetForegroundWindow(), UserProcessKeyboardInput(), and UserSendKeyboardInput().

IntGetMessageWindow()

HWND FASTCALL IntGetMessageWindow

(

VOID

)

Definition at line 1425 of file desktop.c.

{
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return NULL;
    }
    return UserHMGetHandle(pdo->spwndMessage);
}

Referenced by NtUserFindWindowEx(), and NtUserSetParent().

IntGetScreenDC()

HDC FASTCALL IntGetScreenDC

(

VOID

)

Definition at line 394 of file winsta.c.

{
    return ScreenDeviceContext;
}

Referenced by co_MsqInsertMouseMessage(), MsqCleanupMessageQueue(), UserSetCursor(), and UserShowCursor().

IntGetThreadDesktopWindow()

PWND FASTCALL IntGetThreadDesktopWindow

(

PTHREADINFO

pti

)

Definition at line 1387 of file desktop.c.

{
    if (!pti) pti = PsGetCurrentThreadWin32Thread();
    if (pti->pDeskInfo) return pti->pDeskInfo->spwnd;
    return NULL;
}

Referenced by ActivateOtherWindowMin().

IntHideDesktop()

NTSTATUS FASTCALL IntHideDesktop

(

PDESKTOP

Desktop

)

Definition at line 1655 of file desktop.c.

{
    PWND DesktopWnd;
 
    DesktopWnd = IntGetWindowObject(Desktop->DesktopWindow);
    if (! DesktopWnd)
    {
        return ERROR_INVALID_WINDOW_HANDLE;
    }
    DesktopWnd->style &= ~WS_VISIBLE;
 
    return STATUS_SUCCESS;
}

Referenced by IntEndDesktopGraphics(), and NtUserSwitchDesktop().

IntPaintDesktop()

BOOL FASTCALL IntPaintDesktop

(

HDC

hDC

)

Definition at line 2130 of file desktop.c.

{
    static WCHAR s_wszSafeMode[] = L"Safe Mode"; // FIXME: Localize!
 
    RECTL Rect;
    HBRUSH DesktopBrush, PreviousBrush;
    HWND hWndDesktop;
    BOOL doPatBlt = TRUE;
    PWND WndDesktop;
    BOOLEAN InSafeMode;
 
    if (GdiGetClipBox(hDC, &Rect) == ERROR)
        return FALSE;
 
    hWndDesktop = IntGetDesktopWindow(); // rpdesk->DesktopWindow;
 
    WndDesktop = UserGetWindowObject(hWndDesktop); // rpdesk->pDeskInfo->spwnd;
    if (!WndDesktop)
        return FALSE;
 
    /* Retrieve the current SafeMode state */
    InSafeMode = (UserGetSystemMetrics(SM_CLEANBOOT) != 0); // gpsi->aiSysMet[SM_CLEANBOOT];
 
    if (!InSafeMode)
    {
        DesktopBrush = (HBRUSH)WndDesktop->pcls->hbrBackground;
 
        /*
         * Paint desktop background
         */
        if (gspv.hbmWallpaper != NULL)
        {
            /* Do not fill the background after it is painted no matter the size of the picture */
            doPatBlt = !IntPaintWallpaper(hDC, WndDesktop);
        }
    }
    else
    {
        /* Black desktop background in Safe Mode */
        DesktopBrush = StockObjects[BLACK_BRUSH];
    }
 
    /* Background is set to none, clear the screen */
    if (doPatBlt)
    {
        PreviousBrush = NtGdiSelectBrush(hDC, DesktopBrush);
        NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right, Rect.bottom, PATCOPY);
        NtGdiSelectBrush(hDC, PreviousBrush);
    }
 
    /*
     * Display the system version on the desktop background
     */
    if (InSafeMode || g_AlwaysDisplayVersion || g_PaintDesktopVersion)
    {
        NTSTATUS Status;
        static WCHAR wszzVersion[1024] = L"\0";
 
        /* Only used in normal mode */
        // We expect at most 4 strings (3 for version, 1 for optional NtSystemRoot)
        static POLYTEXTW VerStrs[4] = {{0},{0},{0},{0}};
        INT i = 0;
        SIZE_T len;
 
        HFONT hFont1 = NULL, hFont2 = NULL, hOldFont = NULL;
        COLORREF crText, color_old;
        UINT align_old;
        INT mode_old;
        PDC pdc;
 
        if (!UserSystemParametersInfo(SPI_GETWORKAREA, 0, &Rect, 0))
        {
            Rect.left = Rect.top = 0;
            Rect.right  = UserGetSystemMetrics(SM_CXSCREEN);
            Rect.bottom = UserGetSystemMetrics(SM_CYSCREEN);
        }
        else
        {
            RECTL_vOffsetRect(&Rect, -Rect.left, -Rect.top);
        }
 
        /*
         * Set up the fonts (otherwise use default ones)
         */
 
        /* Font for the principal version string */
        hFont1 = GreCreateFontIndirectW(&gspv.ncm.lfCaptionFont);
        /* Font for the secondary version strings */
        hFont2 = GreCreateFontIndirectW(&gspv.ncm.lfMenuFont);
 
        if (hFont1)
            hOldFont = NtGdiSelectFont(hDC, hFont1);
 
        if (gspv.hbmWallpaper == NULL)
        {
            /* Retrieve the brush fill colour */
            // TODO: The following code constitutes "GreGetBrushColor".
            PreviousBrush = NtGdiSelectBrush(hDC, DesktopBrush);
            pdc = DC_LockDc(hDC);
            if (pdc)
            {
                crText = pdc->eboFill.ulRGBColor;
                DC_UnlockDc(pdc);
            }
            else
            {
                crText = RGB(0, 0, 0);
            }
            NtGdiSelectBrush(hDC, PreviousBrush);
 
            /* Adjust text colour according to the brush */
            if (GetRValue(crText) + GetGValue(crText) + GetBValue(crText) > 128 * 3)
                crText = RGB(0, 0, 0);
            else
                crText = RGB(255, 255, 255);
        }
        else
        {
            /* Always use white when the text is displayed on top of a wallpaper */
            crText = RGB(255, 255, 255);
        }
 
        color_old = IntGdiSetTextColor(hDC, crText);
        align_old = IntGdiSetTextAlign(hDC, TA_RIGHT);
        mode_old  = IntGdiSetBkMode(hDC, TRANSPARENT);
 
        /* Display the system version information */
        if (!*wszzVersion)
        {
            Status = GetSystemVersionString(wszzVersion,
                                            ARRAYSIZE(wszzVersion),
                                            InSafeMode,
                                            g_AlwaysDisplayVersion);
            if (!InSafeMode && NT_SUCCESS(Status) && *wszzVersion)
            {
                PWCHAR pstr = wszzVersion;
                for (i = 0; (i < ARRAYSIZE(VerStrs)) && *pstr; ++i)
                {
                    VerStrs[i].n = lstrlenW(pstr);
                    VerStrs[i].lpstr = pstr;
                    pstr += (VerStrs[i].n + 1);
                }
            }
        }
        else
        {
            Status = STATUS_SUCCESS;
        }
        if (NT_SUCCESS(Status) && *wszzVersion)
        {
            if (!InSafeMode)
            {
                SIZE Size = {0, 0};
                LONG TotalHeight = 0;
 
                /* Normal Mode: multiple version information text separated by newlines */
                IntGdiSetTextAlign(hDC, TA_RIGHT | TA_BOTTOM);
 
                /* Compute the heights of the strings */
                if (hFont1) NtGdiSelectFont(hDC, hFont1);
                for (i = 0; i < ARRAYSIZE(VerStrs); ++i)
                {
                    if (!VerStrs[i].lpstr || !*VerStrs[i].lpstr || (VerStrs[i].n == 0))
                        break;
 
                    GreGetTextExtentW(hDC, VerStrs[i].lpstr, VerStrs[i].n, &Size, 1);
                    VerStrs[i].y = Size.cy; // Store the string height
                    TotalHeight += Size.cy;
 
                    /* While the first string was using hFont1, all the others use hFont2 */
                    if (hFont2) NtGdiSelectFont(hDC, hFont2);
                }
                /* The total height must not exceed the screen height */
                TotalHeight = min(TotalHeight, Rect.bottom);
 
                /* Display the strings */
                if (hFont1) NtGdiSelectFont(hDC, hFont1);
                for (i = 0; i < ARRAYSIZE(VerStrs); ++i)
                {
                    if (!VerStrs[i].lpstr || !*VerStrs[i].lpstr || (VerStrs[i].n == 0))
                        break;
 
                    TotalHeight -= VerStrs[i].y;
                    GreExtTextOutW(hDC,
                                   Rect.right - 5,
                                   Rect.bottom - TotalHeight - 5,
                                   0, NULL,
                                   VerStrs[i].lpstr,
                                   VerStrs[i].n,
                                   NULL, 0);
 
                    /* While the first string was using hFont1, all the others use hFont2 */
                    if (hFont2) NtGdiSelectFont(hDC, hFont2);
                }
            }
            else
            {
                if (hFont1) NtGdiSelectFont(hDC, hFont1);
 
                /* Safe Mode: single version information text in top center */
                len = wcslen(wszzVersion);
 
                IntGdiSetTextAlign(hDC, TA_CENTER | TA_TOP);
                GreExtTextOutW(hDC, (Rect.right + Rect.left)/2, Rect.top + 3, 0, NULL, wszzVersion, len, NULL, 0);
            }
        }
 
        if (InSafeMode)
        {
            if (hFont1) NtGdiSelectFont(hDC, hFont1);
 
            /* Print Safe Mode text in corners */
            len = wcslen(s_wszSafeMode);
 
            IntGdiSetTextAlign(hDC, TA_LEFT | TA_TOP);
            GreExtTextOutW(hDC, Rect.left, Rect.top + 3, 0, NULL, s_wszSafeMode, len, NULL, 0);
            IntGdiSetTextAlign(hDC, TA_RIGHT | TA_TOP);
            GreExtTextOutW(hDC, Rect.right, Rect.top + 3, 0, NULL, s_wszSafeMode, len, NULL, 0);
            IntGdiSetTextAlign(hDC, TA_LEFT | TA_BOTTOM);
            GreExtTextOutW(hDC, Rect.left, Rect.bottom - 5, 0, NULL, s_wszSafeMode, len, NULL, 0);
            IntGdiSetTextAlign(hDC, TA_RIGHT | TA_BOTTOM);
            GreExtTextOutW(hDC, Rect.right, Rect.bottom - 5, 0, NULL, s_wszSafeMode, len, NULL, 0);
        }
 
        IntGdiSetBkMode(hDC, mode_old);
        IntGdiSetTextAlign(hDC, align_old);
        IntGdiSetTextColor(hDC, color_old);
 
        if (hFont2)
            GreDeleteObject(hFont2);
 
        if (hFont1)
        {
            NtGdiSelectFont(hDC, hOldFont);
            GreDeleteObject(hFont1);
        }
    }
 
    return TRUE;
}

Referenced by co_IntInitializeDesktopGraphics(), DesktopWindowProc(), EngpRegisterGraphicsDevice(), NtUserPaintDesktop(), and UserRealizePalette().

IntRegisterShellHookWindow()

BOOL IntRegisterShellHookWindow

(

HWND

hWnd

)

Definition at line 1774 of file desktop.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    PDESKTOP Desktop = pti->rpdesk;
    PSHELL_HOOK_WINDOW Entry;
 
    TRACE("IntRegisterShellHookWindow\n");
 
    /* First deregister the window, so we can be sure it's never twice in the
     * list.
     */
    IntDeRegisterShellHookWindow(hWnd);
 
    Entry = ExAllocatePoolWithTag(PagedPool,
                                  sizeof(SHELL_HOOK_WINDOW),
                                  TAG_WINSTA);
 
    if (!Entry)
        return FALSE;
 
    Entry->hWnd = hWnd;
 
    InsertTailList(&Desktop->ShellHookWindows, &Entry->ListEntry);
 
    return TRUE;
}

Referenced by NtUserCallHwnd().

IntResolveDesktop()

NTSTATUS FASTCALL IntResolveDesktop	(	IN PEPROCESS	Process,
		IN PUNICODE_STRING	DesktopPath,
		IN BOOL	bInherit,
		OUT HWINSTA *	phWinSta,
		OUT HDESK *	phDesktop
	)

Definition at line 575 of file desktop.c.

{
    NTSTATUS Status;
    HWINSTA hWinSta = NULL, hWinStaDup = NULL;
    HDESK hDesktop = NULL, hDesktopDup = NULL;
    PPROCESSINFO ppi;
    HANDLE hProcess = NULL;
    LUID ProcessLuid;
    USHORT StrSize;
    SIZE_T MemSize;
    PSECURITY_DESCRIPTOR ServiceSD;
    POBJECT_ATTRIBUTES ObjectAttributes = NULL;
    PUNICODE_STRING ObjectName;
    UNICODE_STRING WinStaName, DesktopName;
    const UNICODE_STRING WinSta0Name = RTL_CONSTANT_STRING(L"WinSta0");
    PWINSTATION_OBJECT WinStaObject;
    HWINSTA hTempWinSta = NULL;
    BOOLEAN bUseDefaultWinSta = FALSE;
    BOOLEAN bInteractive = FALSE;
    BOOLEAN bAccessAllowed = FALSE;
 
    ASSERT(UserIsEnteredExclusive());
 
    ASSERT(phWinSta);
    ASSERT(phDesktop);
    ASSERT(DesktopPath);
 
    *phWinSta  = NULL;
    *phDesktop = NULL;
 
    ppi = PsGetProcessWin32Process(Process);
    /* ppi is typically NULL for console applications that connect to Win32 USER */
    if (!ppi) TRACE("IntResolveDesktop: ppi is NULL!\n");
 
    if (ppi && ppi->hwinsta != NULL && ppi->hdeskStartup != NULL)
    {
        /*
         * If this process is the current one, just return the cached handles.
         * Otherwise, open the window station and desktop objects.
         */
        if (Process == PsGetCurrentProcess())
        {
            hWinSta  = ppi->hwinsta;
            hDesktop = ppi->hdeskStartup;
        }
        else
        {
            Status = ObOpenObjectByPointer(ppi->prpwinsta,
                                           0,
                                           NULL,
                                           MAXIMUM_ALLOWED,
                                           ExWindowStationObjectType,
                                           UserMode,
                                           (PHANDLE)&hWinSta);
            if (!NT_SUCCESS(Status))
            {
                ERR("IntResolveDesktop: Could not reference window station 0x%p\n", ppi->prpwinsta);
                SetLastNtError(Status);
                return Status;
            }
 
            Status = ObOpenObjectByPointer(ppi->rpdeskStartup,
                                           0,
                                           NULL,
                                           MAXIMUM_ALLOWED,
                                           ExDesktopObjectType,
                                           UserMode,
                                           (PHANDLE)&hDesktop);
            if (!NT_SUCCESS(Status))
            {
                ERR("IntResolveDesktop: Could not reference desktop 0x%p\n", ppi->rpdeskStartup);
                ObCloseHandle(hWinSta, UserMode);
                SetLastNtError(Status);
                return Status;
            }
        }
 
        *phWinSta  = hWinSta;
        *phDesktop = hDesktop;
        return STATUS_SUCCESS;
    }
 
    /* We will by default use the default window station and desktop */
    RtlInitEmptyUnicodeString(&WinStaName, NULL, 0);
    RtlInitEmptyUnicodeString(&DesktopName, NULL, 0);
 
    /*
     * Parse the desktop path string which can be of the form "WinSta\Desktop"
     * or just "Desktop". In the latter case we use the default window station
     * on which the process is attached to (or if none, "WinSta0").
     */
    if (DesktopPath->Buffer != NULL && DesktopPath->Length > sizeof(WCHAR))
    {
        DesktopName = *DesktopPath;
 
        /* Find the separator */
        while (DesktopName.Length > 0 && *DesktopName.Buffer &&
               *DesktopName.Buffer != OBJ_NAME_PATH_SEPARATOR)
        {
            DesktopName.Buffer++;
            DesktopName.Length -= sizeof(WCHAR);
            DesktopName.MaximumLength -= sizeof(WCHAR);
        }
        if (DesktopName.Length > 0)
        {
            RtlInitEmptyUnicodeString(&WinStaName, DesktopPath->Buffer,
                                      DesktopPath->Length - DesktopName.Length);
            // (USHORT)((ULONG_PTR)DesktopName.Buffer - (ULONG_PTR)DesktopPath->Buffer);
            WinStaName.Length = WinStaName.MaximumLength;
 
            /* Skip the separator */
            DesktopName.Buffer++;
            DesktopName.Length -= sizeof(WCHAR);
            DesktopName.MaximumLength -= sizeof(WCHAR);
        }
        else
        {
            RtlInitEmptyUnicodeString(&WinStaName, NULL, 0);
            DesktopName = *DesktopPath;
        }
    }
 
    TRACE("IntResolveDesktop: WinStaName:'%wZ' ; DesktopName:'%wZ'\n", &WinStaName, &DesktopName);
 
    /* Retrieve the process LUID */
    Status = GetProcessLuid(NULL, Process, &ProcessLuid);
    if (!NT_SUCCESS(Status))
    {
        ERR("IntResolveDesktop: Failed to retrieve the process LUID, Status 0x%08lx\n", Status);
        SetLastNtError(Status);
        return Status;
    }
 
    /*
     * If this process is not the current one, obtain a temporary handle
     * to it so that we can perform handles duplication later.
     */
    if (Process != PsGetCurrentProcess())
    {
        Status = ObOpenObjectByPointer(Process,
                                       OBJ_KERNEL_HANDLE,
                                       NULL,
                                       0,
                                       *PsProcessType,
                                       KernelMode,
                                       &hProcess);
        if (!NT_SUCCESS(Status))
        {
            ERR("IntResolveDesktop: Failed to obtain a handle to process 0x%p, Status 0x%08lx\n", Process, Status);
            SetLastNtError(Status);
            return Status;
        }
        ASSERT(hProcess);
    }
 
    /*
     * If no window station has been specified, search the process handle table
     * for inherited window station handles, otherwise use a default one.
     */
    if (WinStaName.Buffer == NULL)
    {
        /*
         * We want to find a suitable default window station.
         * For applications that can be interactive, i.e. that have allowed
         * access to the single interactive window station on the system,
         * the default window station is 'WinSta0'.
         * For applications that cannot be interactive, i.e. that do not have
         * access to 'WinSta0' (e.g. non-interactive services), the default
         * window station is 'Service-0xXXXX-YYYY$' (created if needed).
         * Precedence will however be taken by any inherited window station
         * that possesses the required interactivity property.
         */
        bUseDefaultWinSta = TRUE;
 
        /*
         * Use the default 'WinSta0' window station. Whether we should
         * use 'Service-0xXXXX-YYYY$' instead will be determined later.
         */
        // RtlInitUnicodeString(&WinStaName, L"WinSta0");
        WinStaName = WinSta0Name;
 
        if (ObFindHandleForObject(Process,
                                  NULL,
                                  ExWindowStationObjectType,
                                  NULL,
                                  (PHANDLE)&hWinSta))
        {
            TRACE("IntResolveDesktop: Inherited window station is: 0x%p\n", hWinSta);
        }
    }
 
    /*
     * If no desktop has been specified, search the process handle table
     * for inherited desktop handles, otherwise use the Default desktop.
     * Note that the inherited desktop that we may use, may not belong
     * to the window station we will connect to.
     */
    if (DesktopName.Buffer == NULL)
    {
        /* Use a default desktop name */
        RtlInitUnicodeString(&DesktopName, L"Default");
 
        if (ObFindHandleForObject(Process,
                                  NULL,
                                  ExDesktopObjectType,
                                  NULL,
                                  (PHANDLE)&hDesktop))
        {
            TRACE("IntResolveDesktop: Inherited desktop is: 0x%p\n", hDesktop);
        }
    }
 
 
    /*
     * We are going to open either a window station or a desktop.
     * Even if this operation is done from kernel-mode, we should
     * "emulate" an opening from user-mode (i.e. using an ObjectAttributes
     * allocated in user-mode, with AccessMode == UserMode) for the
     * Object Manager to perform proper access validation to the
     * window station or desktop.
     */
 
    /*
     * Estimate the maximum size needed for the window station name
     * and desktop name to be given to ObjectAttributes->ObjectName.
     */
    StrSize = 0;
 
    /* Window station name */
    MemSize = _scwprintf(L"Service-0x%x-%x$", MAXULONG, MAXULONG) * sizeof(WCHAR);
    MemSize = gustrWindowStationsDir.Length + sizeof(OBJ_NAME_PATH_SEPARATOR)
              + max(WinStaName.Length, MemSize) + sizeof(UNICODE_NULL);
    if (MemSize > MAXUSHORT)
    {
        ERR("IntResolveDesktop: Window station name length is too long.\n");
        Status = STATUS_NAME_TOO_LONG;
        goto Quit;
    }
    StrSize = max(StrSize, (USHORT)MemSize);
 
    /* Desktop name */
    MemSize = max(DesktopName.Length + sizeof(UNICODE_NULL), sizeof(L"Default"));
    StrSize = max(StrSize, (USHORT)MemSize);
 
    /* Size for the OBJECT_ATTRIBUTES */
    MemSize = ALIGN_UP(sizeof(OBJECT_ATTRIBUTES), sizeof(PVOID));
 
    /* Add the string size */
    MemSize += ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID));
    MemSize += StrSize;
 
    /* Allocate the memory in user-mode */
    Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
                                     (PVOID*)&ObjectAttributes,
                                     0,
                                     &MemSize,
                                     MEM_COMMIT,
                                     PAGE_READWRITE);
    if (!NT_SUCCESS(Status))
    {
        ERR("ZwAllocateVirtualMemory() failed, Status 0x%08lx\n", Status);
        goto Quit;
    }
 
    ObjectName = (PUNICODE_STRING)((ULONG_PTR)ObjectAttributes +
                     ALIGN_UP(sizeof(OBJECT_ATTRIBUTES), sizeof(PVOID)));
 
    RtlInitEmptyUnicodeString(ObjectName,
                              (PWCHAR)((ULONG_PTR)ObjectName +
                                  ALIGN_UP(sizeof(UNICODE_STRING), sizeof(PVOID))),
                              StrSize);
 
 
    /* If we got an inherited window station handle, duplicate and use it */
    if (hWinSta)
    {
        ASSERT(bUseDefaultWinSta);
 
        /* Duplicate the handle if it belongs to another process than the current one */
        if (Process != PsGetCurrentProcess())
        {
            ASSERT(hProcess);
            Status = ZwDuplicateObject(hProcess,
                                       hWinSta,
                                       ZwCurrentProcess(),
                                       (PHANDLE)&hWinStaDup,
                                       0,
                                       0,
                                       DUPLICATE_SAME_ACCESS);
            if (!NT_SUCCESS(Status))
            {
                ERR("IntResolveDesktop: Failed to duplicate the window station handle, Status 0x%08lx\n", Status);
                /* We will use a default window station */
                hWinSta = NULL;
            }
            else
            {
                hWinSta = hWinStaDup;
            }
        }
    }
 
    /*
     * If we have an inherited window station, check whether
     * it is interactive and remember that for later.
     */
    if (hWinSta)
    {
        ASSERT(bUseDefaultWinSta);
 
        /* Reference the inherited window station */
        Status = ObReferenceObjectByHandle(hWinSta,
                                           0,
                                           ExWindowStationObjectType,
                                           KernelMode,
                                           (PVOID*)&WinStaObject,
                                           NULL);
        if (!NT_SUCCESS(Status))
        {
            ERR("Failed to reference the inherited window station, Status 0x%08lx\n", Status);
            /* We will use a default window station */
            if (hWinStaDup)
            {
                ASSERT(hWinSta == hWinStaDup);
                ObCloseHandle(hWinStaDup, UserMode);
                hWinStaDup = NULL;
            }
            hWinSta = NULL;
        }
        else
        {
            ERR("Process LUID is: 0x%x-%x, inherited window station LUID is: 0x%x-%x\n",
                ProcessLuid.HighPart, ProcessLuid.LowPart,
                WinStaObject->luidUser.HighPart, WinStaObject->luidUser.LowPart);
 
            /* Check whether this window station is interactive, and remember it for later */
            bInteractive = !(WinStaObject->Flags & WSS_NOIO);
 
            /* Dereference the window station */
            ObDereferenceObject(WinStaObject);
        }
    }
 
    /* Build a valid window station name */
    Status = RtlStringCbPrintfW(ObjectName->Buffer,
                                ObjectName->MaximumLength,
                                L"%wZ\\%wZ",
                                &gustrWindowStationsDir,
                                &WinStaName);
    if (!NT_SUCCESS(Status))
    {
        ERR("Impossible to build a valid window station name, Status 0x%08lx\n", Status);
        goto Quit;
    }
    ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
 
    TRACE("Parsed initial window station: '%wZ'\n", ObjectName);
 
    /* Try to open the window station */
    InitializeObjectAttributes(ObjectAttributes,
                               ObjectName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    if (bInherit)
        ObjectAttributes->Attributes |= OBJ_INHERIT;
 
    Status = ObOpenObjectByName(ObjectAttributes,
                                ExWindowStationObjectType,
                                UserMode,
                                NULL,
                                MAXIMUM_ALLOWED,
                                NULL,
                                (PHANDLE)&hTempWinSta);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to open the window station '%wZ', Status 0x%08lx\n", ObjectName, Status);
    }
    else
    {
        //
        // FIXME TODO: Perform a window station access check!!
        // If we fail AND bUseDefaultWinSta == FALSE we just quit.
        //
 
        /*
         * Check whether we are opening the (single) interactive
         * window station, and if so, perform an access check.
         */
        /* Check whether we are allowed to perform interactions */
        if (RtlEqualUnicodeString(&WinStaName, &WinSta0Name, TRUE))
        {
            LUID SystemLuid = SYSTEM_LUID;
 
            /* Interactive window station: check for user LUID */
            WinStaObject = InputWindowStation;
 
            Status = STATUS_ACCESS_DENIED;
 
            // TODO: Check also that we compare wrt. window station WinSta0
            // which is the only one that can be interactive on the system.
            if (((!bUseDefaultWinSta || bInherit) && RtlEqualLuid(&ProcessLuid, &SystemLuid)) ||
                 RtlEqualLuid(&ProcessLuid, &WinStaObject->luidUser))
            {
                /* We are interactive on this window station */
                bAccessAllowed = TRUE;
                Status = STATUS_SUCCESS;
            }
        }
        else
        {
            /* Non-interactive window station: we have access since we were able to open it */
            bAccessAllowed = TRUE;
            Status = STATUS_SUCCESS;
        }
    }
 
    /* If we failed, bail out if we were not trying to open the default window station */
    if (!NT_SUCCESS(Status) && !bUseDefaultWinSta) // if (!bAccessAllowed)
        goto Quit;
 
    if (/* bAccessAllowed && */ bInteractive || !bAccessAllowed)
    {
        /*
         * Close WinSta0 if the inherited window station is interactive so that
         * we can use it, or we do not have access to the interactive WinSta0.
         */
        ObCloseHandle(hTempWinSta, UserMode);
        hTempWinSta = NULL;
    }
    if (bInteractive == bAccessAllowed)
    {
        /* Keep using the inherited window station */
        NOTHING;
    }
    else // if (bInteractive != bAccessAllowed)
    {
        /*
         * Close the inherited window station, we will either keep using
         * the interactive WinSta0, or use Service-0xXXXX-YYYY$.
         */
        if (hWinStaDup)
        {
            ASSERT(hWinSta == hWinStaDup);
            ObCloseHandle(hWinStaDup, UserMode);
            hWinStaDup = NULL;
        }
        hWinSta = hTempWinSta; // hTempWinSta is NULL in case bAccessAllowed == FALSE
    }
 
    if (bUseDefaultWinSta)
    {
        if (hWinSta == NULL && !bInteractive)
        {
            /* Build a valid window station name from the LUID */
            Status = RtlStringCbPrintfW(ObjectName->Buffer,
                                        ObjectName->MaximumLength,
                                        L"%wZ\\Service-0x%x-%x$",
                                        &gustrWindowStationsDir,
                                        ProcessLuid.HighPart,
                                        ProcessLuid.LowPart);
            if (!NT_SUCCESS(Status))
            {
                ERR("Impossible to build a valid window station name, Status 0x%08lx\n", Status);
                goto Quit;
            }
            ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
 
            /*
             * Set up a security descriptor for the new service's window station.
             * A service has an associated window station and desktop. The newly
             * created window station and desktop will get this security descriptor
             * if such objects weren't created before.
             */
            Status = IntCreateServiceSecurity(&ServiceSD);
            if (!NT_SUCCESS(Status))
            {
                ERR("Failed to create a security descriptor for service window station, Status 0x%08lx\n", Status);
                goto Quit;
            }
 
            /*
             * Create or open the non-interactive window station.
             * NOTE: The non-interactive window station handle is never inheritable.
             */
            InitializeObjectAttributes(ObjectAttributes,
                                       ObjectName,
                                       OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
                                       NULL,
                                       ServiceSD);
 
            Status = IntCreateWindowStation(&hWinSta,
                                            ObjectAttributes,
                                            UserMode,
                                            KernelMode,
                                            MAXIMUM_ALLOWED,
                                            0, 0, 0, 0, 0);
 
            IntFreeSecurityBuffer(ServiceSD);
 
            if (!NT_SUCCESS(Status))
            {
                ASSERT(hWinSta == NULL);
                ERR("Failed to create or open the non-interactive window station '%wZ', Status 0x%08lx\n",
                    ObjectName, Status);
                goto Quit;
            }
 
            //
            // FIXME: We might not need to always create or open the "Default"
            // desktop on the Service-0xXXXX-YYYY$ window station; we may need
            // to use another one....
            //
 
            /* Create or open the Default desktop on the window station */
            Status = RtlStringCbCopyW(ObjectName->Buffer,
                                      ObjectName->MaximumLength,
                                      L"Default");
            if (!NT_SUCCESS(Status))
            {
                ERR("Impossible to build a valid desktop name, Status 0x%08lx\n", Status);
                goto Quit;
            }
            ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
 
            /*
             * NOTE: The non-interactive desktop handle is never inheritable.
             * The security descriptor is inherited from the newly created
             * window station for the desktop.
             */
            InitializeObjectAttributes(ObjectAttributes,
                                       ObjectName,
                                       OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
                                       hWinSta,
                                       NULL);
 
            Status = IntCreateDesktop(&hDesktop,
                                      ObjectAttributes,
                                      UserMode,
                                      NULL,
                                      NULL,
                                      0,
                                      MAXIMUM_ALLOWED);
            if (!NT_SUCCESS(Status))
            {
                ASSERT(hDesktop == NULL);
                ERR("Failed to create or open the desktop '%wZ' on window station 0x%p, Status 0x%08lx\n",
                    ObjectName, hWinSta, Status);
            }
 
            goto Quit;
        }
/*
        if (hWinSta == NULL)
        {
            Status = STATUS_UNSUCCESSFUL;
            goto Quit;
        }
*/
    }
 
    /*
     * If we got an inherited desktop handle, duplicate and use it,
     * otherwise open a new desktop.
     */
    if (hDesktop != NULL)
    {
        /* Duplicate the handle if it belongs to another process than the current one */
        if (Process != PsGetCurrentProcess())
        {
            ASSERT(hProcess);
            Status = ZwDuplicateObject(hProcess,
                                       hDesktop,
                                       ZwCurrentProcess(),
                                       (PHANDLE)&hDesktopDup,
                                       0,
                                       0,
                                       DUPLICATE_SAME_ACCESS);
            if (!NT_SUCCESS(Status))
            {
                ERR("IntResolveDesktop: Failed to duplicate the desktop handle, Status 0x%08lx\n", Status);
                /* We will use a default desktop */
                hDesktop = NULL;
            }
            else
            {
                hDesktop = hDesktopDup;
            }
        }
    }
 
    if ((hWinSta != NULL) && (hDesktop == NULL))
    {
        Status = RtlStringCbCopyNW(ObjectName->Buffer,
                                   ObjectName->MaximumLength,
                                   DesktopName.Buffer,
                                   DesktopName.Length);
        if (!NT_SUCCESS(Status))
        {
            ERR("Impossible to build a valid desktop name, Status 0x%08lx\n", Status);
            goto Quit;
        }
        ObjectName->Length = (USHORT)(wcslen(ObjectName->Buffer) * sizeof(WCHAR));
 
        TRACE("Parsed initial desktop: '%wZ'\n", ObjectName);
 
        /* Open the desktop object */
        InitializeObjectAttributes(ObjectAttributes,
                                   ObjectName,
                                   OBJ_CASE_INSENSITIVE,
                                   hWinSta,
                                   NULL);
        if (bInherit)
            ObjectAttributes->Attributes |= OBJ_INHERIT;
 
        /* 
         * A sandboxed process can be denied a piece of DESKTOP_ALL_ACCESS 
         * on its startup desktop and must still be able to connect to it.
         */
        Status = ObOpenObjectByName(ObjectAttributes,
                                    ExDesktopObjectType,
                                    UserMode,
                                    NULL,
                                    MAXIMUM_ALLOWED,
                                    NULL,
                                    (PHANDLE)&hDesktop);
        if (!NT_SUCCESS(Status))
        {
            ERR("Failed to open the desktop '%wZ' on window station 0x%p, Status 0x%08lx\n",
                ObjectName, hWinSta, Status);
            goto Quit;
        }
    }
 
Quit:
    /* Release the object attributes */
    if (ObjectAttributes)
    {
        MemSize = 0;
        ZwFreeVirtualMemory(ZwCurrentProcess(),
                            (PVOID*)&ObjectAttributes,
                            &MemSize,
                            MEM_RELEASE);
    }
 
    /* Close the temporary process handle */
    if (hProcess) // if (Process != PsGetCurrentProcess())
        ObCloseHandle(hProcess, KernelMode);
 
    if (NT_SUCCESS(Status))
    {
        *phWinSta  = hWinSta;
        *phDesktop = hDesktop;
        return STATUS_SUCCESS;
    }
    else
    {
        ERR("IntResolveDesktop(%wZ) failed, Status 0x%08lx\n", DesktopPath, Status);
 
        if (hDesktopDup)
            ObCloseHandle(hDesktopDup, UserMode);
        if (hWinStaDup)
            ObCloseHandle(hWinStaDup, UserMode);
 
        if (hDesktop)
            ObCloseHandle(hDesktop, UserMode);
        if (hWinSta)
            ObCloseHandle(hWinSta, UserMode);
 
        SetLastNtError(Status);
        return Status;
    }
}

Referenced by InitThreadCallback(), and NtUserResolveDesktop().

IntSetFocusMessageQueue()

VOID FASTCALL IntSetFocusMessageQueue

(

PUSER_MESSAGE_QUEUE

NewQueue

)

Definition at line 1347 of file desktop.c.

{
    PUSER_MESSAGE_QUEUE Old;
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return;
    }
    if (NewQueue != NULL)
    {
        if (NewQueue->Desktop != NULL)
        {
            TRACE("Message Queue already attached to another desktop!\n");
            return;
        }
        IntReferenceMessageQueue(NewQueue);
        (void)InterlockedExchangePointer((PVOID*)&NewQueue->Desktop, pdo);
    }
    Old = (PUSER_MESSAGE_QUEUE)InterlockedExchangePointer((PVOID*)&pdo->ActiveMessageQueue, NewQueue);
    if (Old != NULL)
    {
        (void)InterlockedExchangePointer((PVOID*)&Old->Desktop, 0);
        gpqForegroundPrev = Old;
        IntDereferenceMessageQueue(Old);
    }
    // Only one Q can have active foreground even when there are more than one desktop.
    if (NewQueue)
    {
        gpqForeground = pdo->ActiveMessageQueue;
    }
    else
    {
        gpqForeground = NULL;
        ERR("ptiLastInput is CLEARED!!\n");
        ptiLastInput = NULL; // ReactOS hacks... should check for process death.
    }
}

Referenced by co_IntSetForegroundMessageQueue(), co_WinPosActivateOtherWindow(), IntSetThreadDesktop(), MsqCleanupMessageQueue(), and UserAttachThreadInput().

IntSetThreadDesktop()

BOOL IntSetThreadDesktop	(	IN HDESK	hDesktop,
		IN BOOL	FreeOnFailure
	)

Definition at line 3400 of file desktop.c.

{
    PDESKTOP pdesk = NULL, pdeskOld;
    PTHREADINFO pti;
    NTSTATUS Status;
    PCLIENTTHREADINFO pctiOld, pctiNew = NULL;
    PCLIENTINFO pci;
 
    ASSERT(NtCurrentTeb());
 
    TRACE("IntSetThreadDesktop hDesktop:0x%p, FOF:%i\n",hDesktop, FreeOnFailure);
 
    pti = PsGetCurrentThreadWin32Thread();
    pci = pti->pClientInfo;
 
    /* If the caller gave us a desktop, ensure it is valid */
    if (hDesktop != NULL)
    {
        /* Validate the new desktop. */
        Status = IntValidateDesktopHandle(hDesktop, UserMode, 0, &pdesk);
        if (!NT_SUCCESS(Status))
        {
            ERR("Validation of desktop handle 0x%p failed\n", hDesktop);
            return FALSE;
        }
 
        if (pti->rpdesk == pdesk)
        {
            /* Nothing to do */
            ObDereferenceObject(pdesk);
            return TRUE;
        }
    }
 
    /* Make sure that we don't own any window in the current desktop */
    if (!IsListEmpty(&pti->WindowListHead))
    {
        if (pdesk)
            ObDereferenceObject(pdesk);
        ERR("Attempted to change thread desktop although the thread has windows!\n");
        EngSetLastError(ERROR_BUSY);
        return FALSE;
    }
 
    /* Desktop is being re-set so clear out foreground. */
    if (pti->rpdesk != pdesk && pti->MessageQueue == gpqForeground)
    {
        // Like above, there shouldn't be any windows, hooks or anything active on this threads desktop!
        IntSetFocusMessageQueue(NULL);
    }
 
    /* Before doing the switch, map the new desktop heap and allocate the new pcti */
    if (pdesk != NULL)
    {
        Status = IntMapDesktopView(pdesk);
        if (!NT_SUCCESS(Status))
        {
            ERR("Failed to map desktop heap!\n");
            ObDereferenceObject(pdesk);
            SetLastNtError(Status);
            return FALSE;
        }
 
        pctiNew = DesktopHeapAlloc(pdesk, sizeof(CLIENTTHREADINFO));
        if (pctiNew == NULL)
        {
            ERR("Failed to allocate new pcti\n");
            IntUnmapDesktopView(pdesk);
            ObDereferenceObject(pdesk);
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }
 
    /*
     * Processes, in particular Winlogon.exe, that manage window stations
     * (especially the interactive WinSta0 window station) and desktops,
     * may not be able to connect at startup to a window station and have
     * an associated desktop as well, if none exists on the system already.
     * Because creating a new window station does not affect the window station
     * associated to the process, and because neither by associating a window
     * station to the process nor creating a new desktop on it does associate
     * a startup desktop to that process, the process has to actually assigns
     * one of its threads to a desktop so that it gets automatically an assigned
     * startup desktop.
     *
     * This is what actually happens for Winlogon.exe, which is started without
     * any window station and desktop. By creating the first (and therefore
     * interactive) WinSta0 window station, then assigning WinSta0 to itself
     * and creating the Default desktop on it, and then assigning this desktop
     * to its main thread, Winlogon.exe basically does the similar steps that
     * would have been done automatically at its startup if there were already
     * an existing WinSta0 window station and Default desktop.
     *
     * Of course all this must not be done if we are a SYSTEM or CSRSS thread.
     */
    // if (pti->ppi->peProcess != gpepCSRSS)
    if (!(pti->TIF_flags & (TIF_SYSTEMTHREAD | TIF_CSRSSTHREAD)) &&
        pti->ppi->rpdeskStartup == NULL && hDesktop != NULL)
    {
        ERR("The process 0x%p '%s' didn't have an assigned startup desktop before, assigning it now!\n",
            pti->ppi->peProcess, pti->ppi->peProcess->ImageFileName);
 
        pti->ppi->hdeskStartup = hDesktop;
        pti->ppi->rpdeskStartup = pdesk;
    }
 
    /* free all classes or move them to the shared heap */
    if (pti->rpdesk != NULL)
    {
        if (!IntCheckProcessDesktopClasses(pti->rpdesk, FreeOnFailure))
        {
            ERR("Failed to move process classes to shared heap!\n");
            if (pdesk)
            {
                DesktopHeapFree(pdesk, pctiNew);
                IntUnmapDesktopView(pdesk);
                ObDereferenceObject(pdesk);
            }
            return FALSE;
        }
    }
 
    pdeskOld = pti->rpdesk;
    if (pti->pcti != &pti->cti)
        pctiOld = pti->pcti;
    else
        pctiOld = NULL;
 
    /* do the switch */
    if (pdesk != NULL)
    {
        pti->rpdesk = pdesk;
        pti->hdesk = hDesktop;
        pti->pDeskInfo = pti->rpdesk->pDeskInfo;
        pti->pcti = pctiNew;
 
        pci->ulClientDelta = DesktopHeapGetUserDelta();
        pci->pDeskInfo = (PVOID)((ULONG_PTR)pti->pDeskInfo - pci->ulClientDelta);
        pci->pClientThreadInfo = (PVOID)((ULONG_PTR)pti->pcti - pci->ulClientDelta);
 
        /* initialize the new pcti */
        if (pctiOld != NULL)
        {
            RtlCopyMemory(pctiNew, pctiOld, sizeof(CLIENTTHREADINFO));
        }
        else
        {
            RtlZeroMemory(pctiNew, sizeof(CLIENTTHREADINFO));
            pci->fsHooks = pti->fsHooks;
            pci->dwTIFlags = pti->TIF_flags;
        }
    }
    else
    {
        pti->rpdesk = NULL;
        pti->hdesk = NULL;
        pti->pDeskInfo = NULL;
        pti->pcti = &pti->cti; // Always point inside so there will be no crash when posting or sending msg's!
        pci->ulClientDelta = 0;
        pci->pDeskInfo = NULL;
        pci->pClientThreadInfo = NULL;
    }
 
    /* clean up the old desktop */
    if (pdeskOld != NULL)
    {
        RemoveEntryList(&pti->PtiLink);
        if (pctiOld) DesktopHeapFree(pdeskOld, pctiOld);
        IntUnmapDesktopView(pdeskOld);
        ObDereferenceObject(pdeskOld);
    }
 
    if (pdesk)
    {
        InsertTailList(&pdesk->PtiList, &pti->PtiLink);
    }
 
    TRACE("IntSetThreadDesktop: pti 0x%p ppi 0x%p switched from object 0x%p to 0x%p\n", pti, pti->ppi, pdeskOld, pdesk);
 
    return TRUE;
}

Referenced by DesktopWindowProc(), ExitThreadCallback(), InitThreadCallback(), NtUserSetInformationThread(), and NtUserSetThreadDesktop().

IntValidateDesktopHandle()

NTSTATUS FASTCALL IntValidateDesktopHandle	(	HDESK	Desktop,
		KPROCESSOR_MODE	AccessMode,
		ACCESS_MASK	DesiredAccess,
		PDESKTOP *	Object
	)

Definition at line 1265 of file desktop.c.

{
    NTSTATUS Status;
 
    Status = ObReferenceObjectByHandle(Desktop,
                                       DesiredAccess,
                                       ExDesktopObjectType,
                                       AccessMode,
                                       (PVOID*)Object,
                                       NULL);
 
    TRACE("IntValidateDesktopHandle: handle:0x%p obj:0x%p access:0x%x Status:0x%lx\n",
          Desktop, *Object, DesiredAccess, Status);
 
    if (!NT_SUCCESS(Status))
        SetLastNtError(Status);
 
    return Status;
}

Referenced by InitThreadCallback(), IntSetThreadDesktop(), NtUserBuildHwndList(), NtUserCloseDesktop(), NtUserGetObjectInformation(), and NtUserSwitchDesktop().

UserGetDesktopDC()

HDC FASTCALL UserGetDesktopDC	(	ULONG	DcType,
		BOOL	bAltDc,
		BOOL	ValidatehWnd
	)

Definition at line 1594 of file desktop.c.

{
    PWND DesktopObject = 0;
    HDC DesktopHDC = 0;
 
    /* This can be called from GDI/DX, so acquire the USER lock */
    UserEnterExclusive();
 
    if (DcType == DCTYPE_DIRECT)
    {
        DesktopObject = UserGetDesktopWindow();
        DesktopHDC = (HDC)UserGetWindowDC(DesktopObject);
    }
    else
    {
        PMONITOR pMonitor = UserGetPrimaryMonitor();
        DesktopHDC = IntGdiCreateDisplayDC(pMonitor->hDev, DcType, bAltDc);
    }
 
    UserLeave();
 
    return DesktopHDC;
}

Referenced by DxEngGetDesktopDC().

UserGetDesktopWindow()

PWND FASTCALL UserGetDesktopWindow

(

VOID

)

Definition at line 1413 of file desktop.c.

{
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return NULL;
    }
    // return pdo->pDeskInfo->spwnd;
    return UserGetWindowObject(pdo->DesktopWindow);
}

Referenced by co_IntProcessMouseMessage(), co_IntSendActivateMessages(), co_IntSendMessageTimeout(), co_IntSetActiveWindow(), co_MsqInsertMouseMessage(), co_UserRedrawWindow(), co_WinPosActivateOtherWindow(), co_WinPosWindowFromPoint(), DefWndDoSizeMove(), DefWndHandleSetCursor(), IntAnimatePalette(), IntDeactivateWindow(), IntDefWindowProc(), IntForceMinimizeWindow(), IntGetClientOrigin(), IntGetLastTopMostWindowNoIME(), IntGetPaintMessage(), IntImeWindowPosChanged(), IntTopLevelWindowFromPoint(), MENU_TrackMouseMenuBar(), MsqSendParentNotify(), NtUserBuildHwndList(), NtUserMessageCall(), SpiNotifyNCMetricsChanged(), SpiSetWallpaper(), UpdateShellHook(), UserClipCursor(), UserGetDesktopDC(), UserPostMessage(), UserRedrawDesktop(), UserSendNotifyMessage(), UserSetCursorPos(), and WinPosDoOwnedPopups().

UserGetMessageWindow()

PWND FASTCALL UserGetMessageWindow

(

VOID

)

Definition at line 1436 of file desktop.c.

{
    PDESKTOP pdo = IntGetActiveDesktop();
    if (!pdo)
    {
        TRACE("No active desktop\n");
        return NULL;
    }
    return pdo->spwndMessage;
}

UserMessageWindowProc()

BOOL FASTCALL UserMessageWindowProc	(	PWND	pwnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	lResult
	)

Definition at line 1545 of file desktop.c.

{
    *lResult = 0;
 
    switch(Msg)
    {
    case WM_NCCREATE:
        pwnd->fnid |= FNID_MESSAGEWND;
        *lResult = (LRESULT)TRUE;
        break;
    case WM_DESTROY:
        pwnd->fnid |= FNID_DESTROY;
        break;
    default:
        ERR("UMWP calling IDWP\n");
        *lResult = IntDefWindowProc(pwnd, Msg, wParam, lParam, FALSE);
    }
 
    return TRUE; /* We are done. Do not do any callbacks to user mode */
}

Referenced by co_IntSendMessageTimeoutSingle(), co_IntSendMessageWithCallBack(), IntDispatchMessage(), and NtUserMessageCall().

UserOpenInputDesktop()

HDESK UserOpenInputDesktop	(	DWORD	dwFlags,
		BOOL	fInherit,
		ACCESS_MASK	dwDesiredAccess
	)

Definition at line 2747 of file desktop.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
    NTSTATUS Status;
    ULONG HandleAttributes = 0;
    HDESK hdesk = NULL;
 
    if (!gpdeskInputDesktop)
    {
        return NULL;
    }
 
    if (pti->ppi->prpwinsta != InputWindowStation)
    {
        ERR("Tried to open input desktop from non interactive winsta!\n");
        EngSetLastError(ERROR_INVALID_FUNCTION);
        return NULL;
    }
 
    if (fInherit) HandleAttributes = OBJ_INHERIT;
 
    /* Create a new handle to the object */
    Status = ObOpenObjectByPointer(
                 gpdeskInputDesktop,
                 HandleAttributes,
                 NULL,
                 dwDesiredAccess,
                 ExDesktopObjectType,
                 UserMode,
                 (PHANDLE)&hdesk);
 
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to open input desktop object\n");
        SetLastNtError(Status);
    }
 
    return hdesk;
}

Referenced by DesktopWindowProc(), and NtUserOpenInputDesktop().

UserRedrawDesktop()

VOID APIENTRY UserRedrawDesktop

(

VOID

)

Definition at line 1619 of file desktop.c.

{
    PWND Window = NULL;
    PREGION Rgn;
 
    Window = UserGetDesktopWindow();
    Rgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
 
    IntInvalidateWindows(Window,
                         Rgn,
                         RDW_FRAME | RDW_ERASE |
                         RDW_INVALIDATE | RDW_ALLCHILDREN);
 
    REGION_Delete(Rgn);
}

Referenced by DxEngRedrawDesktop(), NtUserSetSysColors(), UserChangeDisplaySettings(), and UserRefreshDisplay().

Variable Documentation

DesktopWindowClass

PCLS DesktopWindowClass

extern

ghDesktopSwitchEvent

HANDLE ghDesktopSwitchEvent

extern

WinSta0_DesktopSwitch handle in the CSRSS process.

Definition at line 57 of file desktop.c.

Referenced by IntCreateDesktopSwitchEvent(), and IntWinStaObjectDelete().

gpdeskInputDesktop

PDESKTOP gpdeskInputDesktop

extern

Currently active desktop.

Definition at line 51 of file desktop.c.

Referenced by IntGetActiveDesktop(), IsAllowedFGActive(), NtUserOpenInputDesktop(), NtUserSetInformationThread(), NtUserSwitchDesktop(), and UserOpenInputDesktop().

gpDesktopSwitchEvent

PKEVENT gpDesktopSwitchEvent

extern

WinSta0_DesktopSwitch legacy (NT 3.5+) event.

Definition at line 56 of file desktop.c.

Referenced by IntCreateDesktopSwitchEvent(), IntWinStaObjectDelete(), and NtUserSwitchDesktop().

gpDesktopThreadStartedEvent

PKEVENT gpDesktopThreadStartedEvent

extern

Definition at line 55 of file desktop.c.

Referenced by DesktopThreadMain(), InitDesktopImpl(), and IntCreateWindowStation().

gptiDesktopThread

PTHREADINFO gptiDesktopThread

extern

Definition at line 53 of file desktop.c.

Referenced by co_IntCallHookProc(), co_IntCallSentMessageCallback(), co_IntCallWindowProc(), co_IntClientLoadLibrary(), co_IntClientThreadSetup(), co_IntLoadDefaultCursors(), co_IntLoadSysMenuTemplate(), DesktopThreadMain(), IntCreateDesktop(), IntCreateWindow(), and IntGetAndReferenceClass().

gptiForeground

PTHREADINFO gptiForeground

extern

Definition at line 15 of file focus.c.

Referenced by CanForceFG(), co_IntSetForegroundMessageQueue(), co_UserActivateKeyboardLayout(), ExitThreadCallback(), IdlePing(), InitThreadCallback(), IntImeCheckTopmost(), NtUserNotifyIMEStatus(), and UserAttachThreadInput().

ScreenDeviceContext

HDC ScreenDeviceContext

extern

Definition at line 52 of file desktop.c.

Referenced by co_IntInitializeDesktopGraphics(), EngpRegisterGraphicsDevice(), IntEndDesktopGraphics(), IntGetScreenDC(), IntStretchWallpaper(), NtUserCallNoParam(), and SpiGetSet().