768 lines
25 KiB
C++
768 lines
25 KiB
C++
// --------------------------------------------------------------------------
|
|
// Module Name: ThemeServerClient.cpp
|
|
//
|
|
// Copyright (c) 2000, Microsoft Corporation
|
|
//
|
|
// This file contains a class that implements the theme server functions that
|
|
// are executed in a client context (winlogon context).
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include "StandardHeader.h"
|
|
#include "ThemeServerClient.h"
|
|
|
|
#include <lpcthemes.h>
|
|
#include <uxthemep.h>
|
|
#include <UxThemeServer.h>
|
|
|
|
#include "SingleThreadedExecution.h"
|
|
#include "StatusCode.h"
|
|
#include "ThemeManagerService.h"
|
|
#include <Impersonation.h>
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeManagerAPI::s_pThemeManagerAPIServer
|
|
// CThemeManagerAPI::s_hPort
|
|
// CThemeManagerAPI::s_hToken
|
|
// CThemeManagerAPI::s_hEvent
|
|
// CThemeManagerAPI::s_hWaitObject
|
|
// CThemeManagerAPI::s_pLock
|
|
//
|
|
// Purpose: Static member variables.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
CThemeManagerAPIServer* CThemeServerClient::s_pThemeManagerAPIServer = NULL;
|
|
HANDLE CThemeServerClient::s_hPort = NULL;
|
|
HANDLE CThemeServerClient::s_hToken = NULL;
|
|
HANDLE CThemeServerClient::s_hEvent = NULL;
|
|
HANDLE CThemeServerClient::s_hWaitObject = NULL;
|
|
HMODULE CThemeServerClient::s_hModuleUxTheme = NULL;
|
|
CCriticalSection* CThemeServerClient::s_pLock = NULL;
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::WaitForServiceReady
|
|
//
|
|
// Arguments: dwTimeout = Number of ticks to wait.
|
|
//
|
|
// Returns: DWORD
|
|
//
|
|
// Purpose: Check if the service is autostart. If so then wait the
|
|
// designated amount of time for the service. If the service
|
|
// is then running or was running but isn't autostart then
|
|
// re-establish the connection to the server.
|
|
//
|
|
// History: 2000-10-10 vtan created
|
|
// 2000-11-29 vtan converted to a Win32 service
|
|
// --------------------------------------------------------------------------
|
|
|
|
DWORD CThemeServerClient::WaitForServiceReady (DWORD dwTimeout)
|
|
|
|
{
|
|
DWORD dwWaitResult;
|
|
NTSTATUS status;
|
|
|
|
dwWaitResult = WAIT_TIMEOUT;
|
|
if (s_pThemeManagerAPIServer->IsAutoStart())
|
|
{
|
|
status = s_pThemeManagerAPIServer->Wait(dwTimeout);
|
|
#ifdef DBG
|
|
if (STATUS_TIMEOUT == status)
|
|
{
|
|
INFORMATIONMSG("Wait on auto start theme service timed out.");
|
|
}
|
|
#endif /* DBG */
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
if (NT_SUCCESS(status) && s_pThemeManagerAPIServer->IsRunning())
|
|
{
|
|
status = ReestablishConnection();
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
THR(InitUserRegistry());
|
|
THR(InitUserTheme(FALSE));
|
|
dwWaitResult = WAIT_OBJECT_0;
|
|
}
|
|
}
|
|
return(dwWaitResult);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::WatchForStart
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Opens or creates the theme server announce event. This is a
|
|
// manual reset event which the theme server pulses when it
|
|
// starts up. This allows winlogon to initiate new connections
|
|
// to the theme server without having to wait for logon or
|
|
// logoff events to happen.
|
|
//
|
|
// This event is intentionally leaked and cleaned up when the
|
|
// winlogon process for the session goes away.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::WatchForStart (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
s_hEvent = CThemeManagerService::OpenStartEvent(NtCurrentPeb()->SessionId, SYNCHRONIZE);
|
|
if (s_hEvent != NULL)
|
|
{
|
|
if (RegisterWaitForSingleObject(&s_hWaitObject,
|
|
s_hEvent,
|
|
CB_ServiceStart,
|
|
NULL,
|
|
INFINITE,
|
|
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE) != FALSE)
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
status = CStatusCode::StatusCodeOfLastError();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = CStatusCode::StatusCodeOfLastError();
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::UserLogon
|
|
//
|
|
// Arguments: hToken = Token of user logging on.
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Signals the server that a user is logging on and gives the
|
|
// server the handle to the token. The server will grant access
|
|
// to the port based on the user's logon SID. Then perform work
|
|
// to initialize the environment for the user logging on.
|
|
//
|
|
// History: 2000-10-10 vtan created
|
|
// 2000-11-29 vtan converted to a Win32 service
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::UserLogon (HANDLE hToken)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
status = NotifyUserLogon(hToken);
|
|
if (STATUS_PORT_DISCONNECTED == status)
|
|
{
|
|
status = ReestablishConnection();
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = NotifyUserLogon(hToken);
|
|
}
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::UserLogoff
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Signals the server that the current user for this session is
|
|
// logging off. The server will remove the access that was
|
|
// granted at logon and reinitialize the theme settings to the
|
|
// ".Default" settings.
|
|
//
|
|
// History: 2000-10-10 vtan created
|
|
// 2000-11-29 vtan converted to a Win32 service
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::UserLogoff (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
status = NotifyUserLogoff();
|
|
if (STATUS_PORT_DISCONNECTED == status)
|
|
{
|
|
status = ReestablishConnection();
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = NotifyUserLogoff();
|
|
}
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::UserInitTheme
|
|
//
|
|
// Arguments: BOOL
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Called at logon, or when Terminal Server connects a user to a
|
|
// remote session or reconnects to a local session. Needs to
|
|
// evaluate the environment and decide if themes need to be loaded
|
|
// or unloaded.
|
|
//
|
|
// History: 2000-01-18 rfernand created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::UserInitTheme (BOOL fPolicyCheckOnly)
|
|
|
|
{
|
|
bool fSuccessfulImpersonation;
|
|
|
|
// If there's a token impersonate the user. Otherwise use the system context.
|
|
|
|
if (s_hToken != NULL)
|
|
{
|
|
fSuccessfulImpersonation = NT_SUCCESS(CImpersonation::ImpersonateUser(GetCurrentThread(), s_hToken));
|
|
}
|
|
else
|
|
{
|
|
fSuccessfulImpersonation = true;
|
|
}
|
|
if (fSuccessfulImpersonation)
|
|
{
|
|
(HRESULT)InitUserTheme(fPolicyCheckOnly);
|
|
}
|
|
if (fSuccessfulImpersonation && (s_hToken != NULL))
|
|
{
|
|
TBOOL(RevertToSelf());
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::StaticInitialize
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Initializes static member variables. Allocate a
|
|
// CThemeManagerAPIServer and a lock for this object.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::StaticInitialize (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
if (s_pThemeManagerAPIServer == NULL)
|
|
{
|
|
status = STATUS_NO_MEMORY;
|
|
s_pThemeManagerAPIServer = new CThemeManagerAPIServer;
|
|
if (s_pThemeManagerAPIServer != NULL)
|
|
{
|
|
s_pLock = new CCriticalSection;
|
|
if (s_pLock != NULL)
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::StaticTerminate
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Release static member variables initialized.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::StaticTerminate (void)
|
|
|
|
{
|
|
if (s_pLock != NULL)
|
|
{
|
|
delete s_pLock;
|
|
s_pLock = NULL;
|
|
}
|
|
if (s_pThemeManagerAPIServer != NULL)
|
|
{
|
|
s_pThemeManagerAPIServer->Release();
|
|
s_pThemeManagerAPIServer = NULL;
|
|
}
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::NotifyUserLogon
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Execute the send message to the server and tell it that the
|
|
// given user is now logged on. This will instruct the server
|
|
// to grant access to the ThemeApiPort.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::NotifyUserLogon (HANDLE hToken)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
CSingleThreadedExecution lock(*s_pLock);
|
|
|
|
if (s_hPort != NULL)
|
|
{
|
|
status = InformServerUserLogon(hToken);
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_PORT_DISCONNECTED;
|
|
}
|
|
|
|
// Keep a copy of the token as well in case of demand start of
|
|
// the theme server so we can impersonate the user when we load
|
|
// their theme using InitUserTheme. Don't copy it if it already
|
|
// exists.
|
|
|
|
if (s_hToken == NULL)
|
|
{
|
|
TBOOL(DuplicateHandle(GetCurrentProcess(),
|
|
hToken,
|
|
GetCurrentProcess(),
|
|
&s_hToken,
|
|
0,
|
|
FALSE,
|
|
DUPLICATE_SAME_ACCESS));
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::NotifyUserLogoff
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Tell the server that the logged on user is logged off. This
|
|
// will remove access to ThemeApiPort.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::NotifyUserLogoff (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
CSingleThreadedExecution lock(*s_pLock);
|
|
|
|
if (s_hToken != NULL)
|
|
{
|
|
ReleaseHandle(s_hToken);
|
|
if (s_hPort != NULL)
|
|
{
|
|
status = InformServerUserLogoff();
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_PORT_DISCONNECTED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::InformServerUserLogon
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Tell the server that the logged on user is logged off. This
|
|
// will remove access to ThemeApiPort.
|
|
//
|
|
// History: 2000-12-05 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::InformServerUserLogon (HANDLE hToken)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
THEMESAPI_PORT_MESSAGE portMessageIn, portMessageOut;
|
|
|
|
ZeroMemory(&portMessageIn, sizeof(portMessageIn));
|
|
ZeroMemory(&portMessageOut, sizeof(portMessageOut));
|
|
portMessageIn.apiThemes.apiGeneric.ulAPINumber = API_THEMES_USERLOGON;
|
|
portMessageIn.apiThemes.apiSpecific.apiUserLogon.in.hToken = hToken;
|
|
portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_THEMES);
|
|
portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(THEMESAPI_PORT_MESSAGE));
|
|
status = NtRequestWaitReplyPort(s_hPort,
|
|
&portMessageIn.portMessage,
|
|
&portMessageOut.portMessage);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = portMessageOut.apiThemes.apiGeneric.status;
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
THR(InitUserTheme(FALSE));
|
|
}
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::InformServerUserLogoff
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Tell the server that the logged on user is logged off. This
|
|
// will remove access to ThemeApiPort.
|
|
//
|
|
// History: 2000-12-05 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::InformServerUserLogoff (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
THEMESAPI_PORT_MESSAGE portMessageIn, portMessageOut;
|
|
|
|
ZeroMemory(&portMessageIn, sizeof(portMessageIn));
|
|
ZeroMemory(&portMessageOut, sizeof(portMessageOut));
|
|
portMessageIn.apiThemes.apiGeneric.ulAPINumber = API_THEMES_USERLOGOFF;
|
|
portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_THEMES);
|
|
portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(THEMESAPI_PORT_MESSAGE));
|
|
status = NtRequestWaitReplyPort(s_hPort,
|
|
&portMessageIn.portMessage,
|
|
&portMessageOut.portMessage);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = portMessageOut.apiThemes.apiGeneric.status;
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
THR(InitUserRegistry());
|
|
THR(InitUserTheme(FALSE));
|
|
}
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::SessionCreate
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Signal the server that a new session is being created. This
|
|
// allows the server to allocate a data blob for this session.
|
|
//
|
|
// History: 2000-11-11 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::SessionCreate (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
CSingleThreadedExecution lock(*s_pLock);
|
|
|
|
if (s_hModuleUxTheme == NULL)
|
|
{
|
|
s_hModuleUxTheme = LoadLibrary(TEXT("uxtheme.dll"));
|
|
}
|
|
if (s_hModuleUxTheme != NULL)
|
|
{
|
|
void *pfnRegister, *pfnUnregister, *pfnClearStockObjects;
|
|
|
|
// Get the uxtheme function addresses in this process address space.
|
|
// 34 = ThemeHooksInstall
|
|
// 35 = ThemeHooksRemove
|
|
// 62 = ServerClearStockObjects
|
|
|
|
pfnRegister = GetProcAddress(s_hModuleUxTheme, MAKEINTRESOURCEA(34));
|
|
pfnUnregister = GetProcAddress(s_hModuleUxTheme, MAKEINTRESOURCEA(35));
|
|
pfnClearStockObjects = GetProcAddress(s_hModuleUxTheme, MAKEINTRESOURCEA(62));
|
|
|
|
if ((pfnRegister != NULL) && (pfnUnregister != NULL) && (pfnClearStockObjects != NULL))
|
|
{
|
|
DWORD dwStackSizeReserve, dwStackSizeCommit;
|
|
ULONG ulReturnLength;
|
|
IMAGE_NT_HEADERS *pNTHeaders;
|
|
SYSTEM_BASIC_INFORMATION systemBasicInformation;
|
|
THEMESAPI_PORT_MESSAGE portMessageIn, portMessageOut;
|
|
|
|
// Get system basic information for stack size defaults.
|
|
|
|
status = NtQuerySystemInformation(SystemBasicInformation,
|
|
&systemBasicInformation,
|
|
sizeof(systemBasicInformation),
|
|
&ulReturnLength);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
dwStackSizeReserve = systemBasicInformation.AllocationGranularity;
|
|
dwStackSizeCommit = systemBasicInformation.PageSize;
|
|
}
|
|
else
|
|
{
|
|
dwStackSizeReserve = dwStackSizeCommit = 0;
|
|
}
|
|
|
|
// Go to the image header for this process and get the stack size
|
|
// defaults if they are specified. Otherwise use system defaults (above).
|
|
|
|
pNTHeaders = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress);
|
|
if (pNTHeaders != NULL)
|
|
{
|
|
dwStackSizeReserve = static_cast<DWORD>(pNTHeaders->OptionalHeader.SizeOfStackReserve);
|
|
dwStackSizeCommit = static_cast<DWORD>(pNTHeaders->OptionalHeader.SizeOfStackCommit);
|
|
}
|
|
|
|
// Make the call.
|
|
|
|
ZeroMemory(&portMessageIn, sizeof(portMessageIn));
|
|
ZeroMemory(&portMessageOut, sizeof(portMessageOut));
|
|
portMessageIn.apiThemes.apiGeneric.ulAPINumber = API_THEMES_SESSIONCREATE;
|
|
portMessageIn.apiThemes.apiSpecific.apiSessionCreate.in.pfnRegister = pfnRegister;
|
|
portMessageIn.apiThemes.apiSpecific.apiSessionCreate.in.pfnUnregister = pfnUnregister;
|
|
portMessageIn.apiThemes.apiSpecific.apiSessionCreate.in.pfnClearStockObjects = pfnClearStockObjects;
|
|
portMessageIn.apiThemes.apiSpecific.apiSessionCreate.in.dwStackSizeReserve = dwStackSizeReserve;
|
|
portMessageIn.apiThemes.apiSpecific.apiSessionCreate.in.dwStackSizeCommit = dwStackSizeCommit;
|
|
portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_THEMES);
|
|
portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(THEMESAPI_PORT_MESSAGE));
|
|
status = NtRequestWaitReplyPort(s_hPort,
|
|
&portMessageIn.portMessage,
|
|
&portMessageOut.portMessage);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = portMessageOut.apiThemes.apiGeneric.status;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = CStatusCode::StatusCodeOfLastError();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = CStatusCode::StatusCodeOfLastError();
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::SessionDestroy
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Signal the server that the current session is about to be
|
|
// destroyed. This allows the server to release the data blob
|
|
// allocated.
|
|
//
|
|
// History: 2000-11-11 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::SessionDestroy (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
THEMESAPI_PORT_MESSAGE portMessageIn, portMessageOut;
|
|
CSingleThreadedExecution lock(*s_pLock);
|
|
|
|
ZeroMemory(&portMessageIn, sizeof(portMessageIn));
|
|
ZeroMemory(&portMessageOut, sizeof(portMessageOut));
|
|
portMessageIn.apiThemes.apiGeneric.ulAPINumber = API_THEMES_SESSIONDESTROY;
|
|
portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_THEMES);
|
|
portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(THEMESAPI_PORT_MESSAGE));
|
|
status = NtRequestWaitReplyPort(s_hPort,
|
|
&portMessageIn.portMessage,
|
|
&portMessageOut.portMessage);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = portMessageOut.apiThemes.apiGeneric.status;
|
|
}
|
|
if (s_hModuleUxTheme != NULL)
|
|
{
|
|
TBOOL(FreeLibrary(s_hModuleUxTheme));
|
|
s_hModuleUxTheme = NULL;
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::ReestablishConnection
|
|
//
|
|
// Arguments: <none>
|
|
//
|
|
// Returns: NTSTATUS
|
|
//
|
|
// Purpose: Reconnects to theme server. If the reconnection is established
|
|
// the re-create the session data. This will not correct any
|
|
// disconnected ports that some clients may have but because this
|
|
// is called in winlogon it re-establish this correctly for
|
|
// session 0 in all cases.
|
|
//
|
|
// UnregisterUserApiHook must be called to clear any left over
|
|
// registrations from a server that died. Then go ahead and
|
|
// re-initialize the environment anyway.
|
|
//
|
|
// History: 2000-11-17 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
NTSTATUS CThemeServerClient::ReestablishConnection (void)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
ReleaseHandle(s_hPort);
|
|
status = s_pThemeManagerAPIServer->ConnectToServer(&s_hPort);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = SessionCreate();
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
(BOOL)UnregisterUserApiHook();
|
|
THR(ReestablishServerConnection());
|
|
}
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// CThemeServerClient::CB_ServiceStart
|
|
//
|
|
// Arguments: pParameter = User parameter.
|
|
// TimerOrWaitFired = Timer or wait fired.
|
|
//
|
|
// Returns: <none>
|
|
//
|
|
// Purpose: Callback called when the theme server ready event is signaled.
|
|
// This indicates that the service was demand started or
|
|
// restarted in the event of failure.
|
|
//
|
|
// History: 2000-11-29 vtan created
|
|
// --------------------------------------------------------------------------
|
|
|
|
void CALLBACK CThemeServerClient::CB_ServiceStart (void *pParameter, BOOLEAN TimerOrWaitFired)
|
|
|
|
{
|
|
UNREFERENCED_PARAMETER(pParameter);
|
|
UNREFERENCED_PARAMETER(TimerOrWaitFired);
|
|
|
|
NTSTATUS status;
|
|
CSingleThreadedExecution lock(*s_pLock);
|
|
|
|
// If there is a connection ping it.
|
|
|
|
if (s_hPort != NULL)
|
|
{
|
|
THEMESAPI_PORT_MESSAGE portMessageIn, portMessageOut;
|
|
|
|
ZeroMemory(&portMessageIn, sizeof(portMessageIn));
|
|
ZeroMemory(&portMessageOut, sizeof(portMessageOut));
|
|
portMessageIn.apiThemes.apiGeneric.ulAPINumber = API_THEMES_PING;
|
|
portMessageIn.portMessage.u1.s1.DataLength = sizeof(API_THEMES);
|
|
portMessageIn.portMessage.u1.s1.TotalLength = static_cast<CSHORT>(sizeof(THEMESAPI_PORT_MESSAGE));
|
|
status = NtRequestWaitReplyPort(s_hPort,
|
|
&portMessageIn.portMessage,
|
|
&portMessageOut.portMessage);
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
status = portMessageOut.apiThemes.apiGeneric.status;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = STATUS_PORT_DISCONNECTED;
|
|
}
|
|
if (STATUS_PORT_DISCONNECTED == status)
|
|
{
|
|
HDESK hDeskCurrent, hDeskInput;
|
|
|
|
// Set this thread's desktop to the input desktop so
|
|
// that the theme change can be broadcast to the input
|
|
// desktop. This is Default in most cases where a logged
|
|
// on user is active but in the non-logged on user case
|
|
// this will be Winlogon. Restore the thread's desktop
|
|
// when done.
|
|
|
|
TSTATUS(ReestablishConnection());
|
|
hDeskCurrent = hDeskInput = NULL;
|
|
if (s_hToken != NULL)
|
|
{
|
|
hDeskCurrent = GetThreadDesktop(GetCurrentThreadId());
|
|
hDeskInput = OpenInputDesktop(0, FALSE, MAXIMUM_ALLOWED);
|
|
if ((hDeskCurrent != NULL) && (hDeskInput != NULL))
|
|
{
|
|
TBOOL(SetThreadDesktop(hDeskInput));
|
|
}
|
|
if (NT_SUCCESS(CImpersonation::ImpersonateUser(GetCurrentThread(), s_hToken)))
|
|
{
|
|
TSTATUS(InformServerUserLogon(s_hToken));
|
|
}
|
|
if ((hDeskCurrent != NULL) && (hDeskInput != NULL))
|
|
{
|
|
SetThreadDesktop(hDeskCurrent);
|
|
(BOOL)CloseDesktop(hDeskInput);
|
|
}
|
|
TBOOL(RevertToSelf());
|
|
}
|
|
else
|
|
{
|
|
THR(InitUserRegistry());
|
|
THR(InitUserTheme(FALSE));
|
|
}
|
|
}
|
|
|
|
// Reset the event here and now.
|
|
|
|
TBOOL(ResetEvent(s_hEvent));
|
|
|
|
// Unregister the original wait (it only executes once anyway). This
|
|
// call will return a failure code with the callback in progress.
|
|
// Ignore this error. The thread pool will clean up the wait.
|
|
|
|
(BOOL)UnregisterWait(s_hWaitObject);
|
|
|
|
// Reregister the wait as execute once only again waiting for
|
|
// the next time the event is signaled.
|
|
|
|
TBOOL(RegisterWaitForSingleObject(&s_hWaitObject,
|
|
s_hEvent,
|
|
CB_ServiceStart,
|
|
NULL,
|
|
INFINITE,
|
|
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE));
|
|
}
|
|
|