able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/remdsk/server/sessmgr/sessmgr.cpp

2961 lines
80 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1999-2000 Microsoft Corporation
Module Name:
sessmgr.cpp
Abstract:
ATL wizard generated code.
Author:
HueiWang 2/17/2000
--*/
// Note: Proxy/Stub Information
// To build a separate proxy/stub DLL,
// run nmake -f sessmgrps.mk in the project directory.
#include "stdafx.h"
#include "resource.h"
#include <initguid.h>
#include <process.h>
#include <tchar.h>
#include "sessmgr.h"
#include "sessmgr_i.c"
#include <stdio.h>
//#include <new.h>
#include "global.h"
#include "HelpSess.h"
#include "HelpMgr.h"
#include "helper.h"
#include "helpacc.h"
#include <rdshost.h>
#include "policy.h"
#include "remotedesktoputils.h"
#define SETUPLOGFILE_NAME _TEXT("sessmgr.setup.log")
#define SESSMGR_SERVICE 0
#define SESSMGR_REGSERVER 1
#define SESSMGR_UNREGSERVER 2
#define SESSMGR_SP1UPGRADE 3
BEGIN_OBJECT_MAP(ObjectMap)
//OBJECT_ENTRY(CLSID_RemoteDesktopHelpSession, CRemoteDesktopHelpSession)
OBJECT_ENTRY(CLSID_RemoteDesktopHelpSessionMgr, CRemoteDesktopHelpSessionMgr)
END_OBJECT_MAP()
CServiceModule _Module;
HANDLE g_hTSCertificateChanged = NULL;
HANDLE g_hWaitTSCertificateChanged = NULL;
HKEY g_hTSCertificateRegKey = NULL;
VOID CALLBACK
TSCertChangeCallback(
PVOID pContext,
BOOLEAN bTimerOrWaitFired
)
/*++
Callback for TS certificate registry change from threadpool function.
--*/
{
MYASSERT( FALSE == bTimerOrWaitFired );
// Our wait is forever so can't be timeout.
if( FALSE == bTimerOrWaitFired )
{
PostThreadMessage(
_Module.dwThreadID,
WM_LOADTSPUBLICKEY,
0,
0
);
}
else
{
DebugPrintf(
_TEXT("TSCertChangeCallback does not expect timeout...\n") );
MYASSERT(FALSE);
}
}
DWORD
LoadTermSrvSecurityBlob()
/*++
Function to load TS machine specific identification blob, for now
we use TS public key.
--*/
{
DWORD dwStatus;
PBYTE pbTSPublicKey = NULL;
DWORD cbTSPublicKey = 0;
DWORD dwType;
DWORD cbData;
BOOL bSuccess;
BOOL bUsesX509PublicKey = FALSE;
if( NULL == g_hTSCertificateRegKey )
{
MYASSERT(FALSE);
dwStatus = ERROR_INTERNAL_ERROR;
goto CLEANUPANDEXIT;
}
//
// Make sure TS certificate is there before
// we directly load public key from LSA
//
dwStatus = RegQueryValueEx(
g_hTSCertificateRegKey,
REGVALUE_TSX509_CERT,
NULL,
&dwType,
NULL,
&cbData
);
if( ERROR_SUCCESS == dwStatus )
{
DebugPrintf(
_TEXT("TermSrv X509 certificate found, trying to load TS X509 public key\n")
);
cbTSPublicKey = 0;
//
// Current TLSAPI does not support retrival of
// X509 certificate public key and TS cert is in
// special format not standard x509 cert chain.
//
dwStatus = LsCsp_RetrieveSecret(
LSA_TSX509_CERT_PUBLIC_KEY_NAME,
NULL,
&cbTSPublicKey
);
if( LICENSE_STATUS_OK != dwStatus &&
LICENSE_STATUS_INSUFFICIENT_BUFFER != dwStatus )
{
MYASSERT( FALSE );
goto CLEANUPANDEXIT;
}
pbTSPublicKey = (PBYTE)LocalAlloc( LPTR, cbTSPublicKey );
if( NULL == pbTSPublicKey )
{
dwStatus = GetLastError();
goto CLEANUPANDEXIT;
}
dwStatus = LsCsp_RetrieveSecret(
LSA_TSX509_CERT_PUBLIC_KEY_NAME,
pbTSPublicKey,
&cbTSPublicKey
);
//
// Critical error, We have certificate in registry
// but don't have public key in LSA
//
MYASSERT( LICENSE_STATUS_OK == dwStatus );
if( LICENSE_STATUS_OK != dwStatus )
{
DebugPrintf(
_TEXT("TermSrv X509 certificate found but can't load X509 public key\n")
);
goto CLEANUPANDEXIT;
}
bUsesX509PublicKey = TRUE;
}
else
{
DebugPrintf(
_TEXT("TermSrv X509 certificate not found\n")
);
//
// Load pre-define TS public key
//
dwStatus = LsCsp_GetServerData(
LsCspInfo_PublicKey,
pbTSPublicKey,
&cbTSPublicKey
);
// expecting insufficient buffer
if( LICENSE_STATUS_INSUFFICIENT_BUFFER != dwStatus &&
LICENSE_STATUS_OK != dwStatus )
{
// invalid return code.
MYASSERT(FALSE);
goto CLEANUPANDEXIT;
}
MYASSERT( cbTSPublicKey > 0 );
pbTSPublicKey = (PBYTE)LocalAlloc( LPTR, cbTSPublicKey );
if( NULL == pbTSPublicKey )
{
dwStatus = GetLastError();
goto CLEANUPANDEXIT;
}
dwStatus = LsCsp_GetServerData(
LsCspInfo_PublicKey,
pbTSPublicKey,
&cbTSPublicKey
);
if( LICENSE_STATUS_OK != dwStatus )
{
MYASSERT(FALSE);
goto CLEANUPANDEXIT;
}
}
if( ERROR_SUCCESS == dwStatus )
{
dwStatus = HashSecurityData(
pbTSPublicKey,
cbTSPublicKey,
g_TSSecurityBlob
);
MYASSERT( ERROR_SUCCESS == dwStatus );
MYASSERT( g_TSSecurityBlob.Length() > 0 );
DebugPrintf(
_TEXT("HashSecurityData() returns %d\n"), dwStatus
);
if( ERROR_SUCCESS != dwStatus )
{
goto CLEANUPANDEXIT;
}
}
//
// SRV, ADS, ... SKU uses seperate thread
// to register with license server, so we use
// different thread to receive certificate change notification.
// Since TermSrv cached certificate, no reason to queue
// notification once we successfully loaded tersrmv public key
//
if( !IsPersonalOrProMachine() && FALSE == bUsesX509PublicKey )
{
DebugPrintf(
_TEXT("Setting up registry notification...\n")
);
MYASSERT( NULL != g_hTSCertificateChanged );
ResetEvent(g_hTSCertificateChanged);
// register a registry change notification
// RegNotifyChangeKeyValue() only signal once.
dwStatus = RegNotifyChangeKeyValue(
g_hTSCertificateRegKey,
TRUE,
REG_NOTIFY_CHANGE_LAST_SET,
g_hTSCertificateChanged,
TRUE
);
if( ERROR_SUCCESS != dwStatus )
{
MYASSERT(FALSE);
DebugPrintf(
_TEXT("RegNotifyChangeKeyValue() returns %d\n"), dwStatus
);
goto CLEANUPANDEXIT;
}
if( NULL != g_hWaitTSCertificateChanged )
{
if( FALSE == UnregisterWait( g_hWaitTSCertificateChanged ) )
{
dwStatus = GetLastError();
DebugPrintf(
_TEXT("UnregisterWait() returns %d\n"),
dwStatus
);
MYASSERT(FALSE);
}
g_hWaitTSCertificateChanged = NULL;
}
//
// Queue notification to threadpool, we need to use WT_EXECUTEONLYONCE
// since we are registering manual reset event.
//
bSuccess = RegisterWaitForSingleObject(
&g_hWaitTSCertificateChanged,
g_hTSCertificateChanged,
(WAITORTIMERCALLBACK) TSCertChangeCallback,
NULL,
INFINITE,
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE
);
if( FALSE == bSuccess )
{
dwStatus = GetLastError();
DebugPrintf(
_TEXT("RegisterWaitForSingleObject() returns %d\n"), dwStatus
);
}
}
CLEANUPANDEXIT:
if( ERROR_SUCCESS != dwStatus )
{
//
// TS either update its public key or key has change
// and we failed to reload it, there is no reason to
// to continue create help ticket since public key already
/// mismatached, set service status and log error event
//
g_TSSecurityBlob.Empty();
}
if( NULL != pbTSPublicKey )
{
LocalFree(pbTSPublicKey);
}
return HRESULT_FROM_WIN32( dwStatus );
}
DWORD
LoadAndSetupTSCertChangeNotification()
{
DWORD dwStatus;
DWORD dwDisp;
BOOL bSuccess;
//
// Only setup registry change notification if we
// runs on higher SKU
//
g_hTSCertificateChanged = CreateEvent( NULL, TRUE, FALSE, NULL );
if( NULL == g_hTSCertificateChanged )
{
dwStatus = GetLastError();
goto CLEANUPANDEXIT;
}
//
// Open parameters key under TermServices if key isn't
// there, create it, this does not interfere with TermSrv
// since we only create the reg. key not updating values
// under it.
//
dwStatus = RegCreateKeyEx(
HKEY_LOCAL_MACHINE,
REGKEY_TSX509_CERT ,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE | KEY_READ,
NULL,
&g_hTSCertificateRegKey,
&dwDisp
);
if( ERROR_SUCCESS != dwStatus )
{
MYASSERT(FALSE);
DebugPrintf(
_TEXT("RegCreateKeyEx on %s failed with 0x%08x\n"),
REGKEY_TSX509_CERT,
dwStatus
);
goto CLEANUPANDEXIT;
}
//
// Load security blob from TS, currently, we use TS public key
// as security blob
//
dwStatus = LoadTermSrvSecurityBlob();
if( ERROR_SUCCESS != dwStatus )
{
MYASSERT(FALSE);
}
CLEANUPANDEXIT:
return dwStatus;
}
LPCTSTR FindOneOf(LPCTSTR p1, LPCTSTR p2)
{
while (p1 != NULL && *p1 != NULL)
{
LPCTSTR p = p2;
while (p != NULL && *p != NULL)
{
if (*p1 == *p)
return CharNext(p1);
p = CharNext(p);
}
p1 = CharNext(p1);
}
return NULL;
}
void
LogSetup(
IN FILE* pfd,
IN LPCTSTR format, ...
)
/*++
Routine Description:
sprintf() like wrapper around OutputDebugString().
Parameters:
hConsole : Handle to console.
format : format string.
Returns:
None.
Note:
To be replace by generic tracing code.
++*/
{
TCHAR buf[8096]; // max. error text
DWORD dump;
va_list marker;
va_start(marker, format);
try {
_vsntprintf(
buf,
sizeof(buf)/sizeof(buf[0])-1,
format,
marker
);
if( NULL == pfd )
{
OutputDebugString(buf);
}
else
{
_fputts( buf, pfd );
fflush( pfd );
}
}
catch(...) {
}
va_end(marker);
return;
}
DWORD WINAPI
NotifySessionLogoff(
LPARAM pParm
)
/*++
Routine Description:
Routine to notified all currently loaded help that a user has
logoff/disconnect from session, routine is kick off via thread pools'
QueueUserWorkItem().
Parameters:
pContext : logoff or disconnected Session ID
Returns:
None.
Note :
We treat disconnect same as logoff since user might be actually
active on the other session logged in with same credential, so
we rely on resolver.
--*/
{
DebugPrintf(_TEXT("NotifySessionLogoff() started...\n"));
//
// Tell service don't shutdown, we are in process.
//
_Module.AddRef();
CRemoteDesktopHelpSessionMgr::NotifyHelpSesionLogoff( pParm );
_Module.Release();
return ERROR_SUCCESS;
}
/////////////////////////////////////////////////////////////////////////////
void
AddAccountToFilterList(
LPCTSTR lpszAccountName
)
/*++
Routine Description:
Add HelpAssistant account into account filter list, this is temporary
until we have long term solution.
Parameters:
lpszAccountName : Name of HelpAssistant account.
Returns:
None.
Note:
Account filter list is on
HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList
<name of SALEM account> REG_DWORD 0x00000000
--*/
{
HKEY hKey = NULL;
DWORD dwStatus;
DWORD dwValue = 0;
dwStatus = RegCreateKeyEx(
HKEY_LOCAL_MACHINE,
_TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\SpecialAccounts\\UserList"),
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKey,
NULL
);
if( ERROR_SUCCESS == dwStatus )
{
dwStatus = RegSetValueEx(
hKey,
lpszAccountName,
0,
REG_DWORD,
(LPBYTE) &dwValue,
sizeof(DWORD)
);
}
//MYASSERT( ERROR_SUCCESS == dwStatus );
if( NULL != hKey )
{
RegCloseKey( hKey );
}
return;
}
void
CServiceModule::LogSessmgrEventLog(
DWORD dwEventType,
DWORD dwEventCode,
CComBSTR& bstrNoviceDomain,
CComBSTR& bstrNoviceAccount,
CComBSTR& bstrRaType,
CComBSTR& bstrExpertIPFromClient,
CComBSTR& bstrExpertIPFromTS,
DWORD dwErrCode
)
/*++
Description:
Log a Salem specific event log, this includes all event log in sessmgr.
Parameters:
dwEventCode : Event code.
bstrNoviceDomain : Ticket owner's domain name.
bstrNoviceAccount : Ticket owner's user account name.
bstrExpertIPFromClient : Expert's IP address send from mstacax.
bstrExpertIPFromTS : Expert IP address we query from TermSrv.
dwErrCode : Error code.
Returns:
None.
Note:
Max. sessmgr specific log require at most 5 parameters but must
contain novice domain, account name and also expert IP address
send to mstscax and expert IP address we query from TermSrv.
--*/
{
TCHAR szErrCode[256];
LPCTSTR eventString[6];
_stprintf( szErrCode, L"0x%x", dwErrCode );
eventString[0] = (LPCTSTR)bstrNoviceDomain;
eventString[1] = (LPCTSTR)bstrNoviceAccount;
eventString[2] = (LPCTSTR)bstrRaType;
eventString[3] = (LPCTSTR)bstrExpertIPFromClient;
eventString[4] = (LPCTSTR)bstrExpertIPFromTS;
eventString[5] = szErrCode;
LogEventString(
dwEventType,
dwEventCode,
sizeof(eventString)/sizeof(eventString[0]),
eventString,
sizeof(dwErrCode),
&dwErrCode
);
return;
}
/////////////////////////////////////////////////////////////////////////////
void
CServiceModule::LogEventWithStatusCode(
IN DWORD dwEventType,
IN DWORD dwEventId,
IN DWORD dwErrorCode
)
/*++
--*/
{
TCHAR szErrCode[256];
LPCTSTR eventString[1];
eventString[0] = szErrCode;
_stprintf( szErrCode, L"0x%x", dwErrorCode );
LogEventString(
dwEventType,
dwEventId,
1,
eventString
);
return;
}
/////////////////////////////////////////////////////////////////////////////
void
CServiceModule::LogInfoEvent(
IN DWORD code
)
/*++
--*/
{
LogEventString(
EVENTLOG_INFORMATION_TYPE,
code,
0,
NULL
);
}
/////////////////////////////////////////////////////////////////////////////
void
CServiceModule::LogWarningEvent(
IN DWORD code
)
/*++
--*/
{
LogEventString(
EVENTLOG_WARNING_TYPE,
code,
0,
NULL
);
}
/////////////////////////////////////////////////////////////////////////////
void
CServiceModule::LogErrorEvent(
IN DWORD errCode
)
/*++
--*/
{
LogEventString(
EVENTLOG_ERROR_TYPE,
errCode,
0,
NULL
);
}
/////////////////////////////////////////////////////////////////////////////
void
CServiceModule::LogEventString(
IN DWORD dwEventType,
IN DWORD dwEventId,
IN DWORD wNumString,
IN LPCTSTR* lpStrings,
DWORD dwBinaryDataSize, /* 0 */
LPVOID lpRawData /* NULL */
)
/*++
--*/
{
HANDLE hAppLog=NULL;
BOOL bSuccess=FALSE;
WORD wElogType = (WORD) dwEventType;
try {
if(hAppLog=RegisterEventSource(NULL, m_szServiceDispName))
{
bSuccess = ReportEvent(
hAppLog,
wElogType,
0,
dwEventId,
NULL,
(WORD)wNumString,
dwBinaryDataSize,
(const TCHAR **) lpStrings,
lpRawData
);
DeregisterEventSource(hAppLog);
}
}
catch(...) {
}
return;
}
inline HRESULT
CServiceModule::SetupEventViewerSource(
IN FILE* pSetupLog
)
/*++
--*/
{
HKEY hKey = NULL;
DWORD dwData;
TCHAR szBuffer[MAX_PATH + 2];
DWORD dwStatus;
LogSetup( pSetupLog, L"Entering SetupEventViewerSource()...\n" );
_stprintf(
szBuffer,
_TEXT("%s\\%s"),
REGKEY_SYSTEM_EVENTSOURCE,
m_szServiceDispName
);
// Add your source name as a subkey under the Application
// key in the EventLog registry key.
dwStatus = RegCreateKey(
HKEY_LOCAL_MACHINE,
szBuffer,
&hKey
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup(
pSetupLog,
L"RegCreateKey() fail to create key %s with %d\n",
szBuffer,
dwStatus
);
goto CLEANUPANDEXIT;
}
dwStatus = GetModuleFileName(
NULL,
szBuffer,
MAX_PATH+1
);
if( 0 == dwStatus )
{
LogSetup(
pSetupLog,
L"GetModuleFileName() failed with error code %s\n",
dwStatus = GetLastError()
);
goto CLEANUPANDEXIT;
}
// Add the name to the EventMessageFile subkey.
dwStatus = RegSetValueEx(
hKey,
L"EventMessageFile",
0,
REG_SZ,
(LPBYTE) szBuffer,
(_tcslen(szBuffer)+1)*sizeof(TCHAR)
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup(
pSetupLog,
L"Failed to create EventMessageFile value, error code %d\n",
dwStatus
);
goto CLEANUPANDEXIT;
}
// Set the supported event types in the TypesSupported subkey.
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
dwStatus = RegSetValueEx(
hKey,
L"TypesSupported",
0,
REG_DWORD,
(LPBYTE) &dwData,
sizeof(DWORD)
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup(
pSetupLog,
L"Failed to create TypesSupported value, error code %d\n",
dwStatus
);
}
CLEANUPANDEXIT:
if( NULL != hKey )
{
RegCloseKey(hKey);
}
LogSetup(
pSetupLog,
L"Exiting SetupEventViewerSource() with status code %d...\n",
dwStatus
);
return HRESULT_FROM_WIN32(dwStatus);
}
// Although some of these functions are big they are declared inline since they are only used once
inline HRESULT
CServiceModule::RegisterServer(FILE* pSetupLog, BOOL bRegTypeLib, BOOL bService)
{
CRegKey key;
HRESULT hr;
CRegKey keyAppID;
LONG lRes;
LogSetup(
pSetupLog,
L"\nEntering CServiceModule::RegisterServer %d, %d\n",
bRegTypeLib,
bService
);
hr = CoInitialize(NULL);
if (FAILED(hr))
{
LogSetup( pSetupLog, L"CoInitialize() failed with 0x%08x\n", hr );
goto CLEANUPANDEXIT;
}
// Remove any previous service since it may point to
// the incorrect file
//Uninstall();
// Add service entries
UpdateRegistryFromResource(IDR_Sessmgr, TRUE);
// Adjust the AppID for Local Server or Service
lRes = keyAppID.Open(HKEY_CLASSES_ROOT, _T("AppID"), KEY_WRITE);
if (lRes != ERROR_SUCCESS)
{
LogSetup( pSetupLog, L"Open key AppID failed with %d\n", lRes );
hr = HRESULT_FROM_WIN32(lRes);
goto CLEANUPANDEXIT;
}
lRes = key.Open(keyAppID, _T("{038ABBA4-4138-4AC4-A492-4A3DF068BD8A}"), KEY_WRITE);
if (lRes != ERROR_SUCCESS)
{
LogSetup( pSetupLog, L"Open key 038ABBA4-4138-4AC4-A492-4A3DF068BD8A failed with %d\n", lRes );
hr = HRESULT_FROM_WIN32(lRes);
goto CLEANUPANDEXIT;
}
key.DeleteValue(_T("LocalService"));
if (bService)
{
LogSetup( pSetupLog, L"Installing service...\n" );
BOOL bInstallSuccess;
key.SetValue(m_szServiceName, _T("LocalService"));
key.SetValue(_T("-Service"), _T("ServiceParameters"));
if( IsInstalled(pSetupLog) )
{
// update service description.
bInstallSuccess = UpdateService( pSetupLog );
}
else
{
//
// Create service
//
bInstallSuccess = Install(pSetupLog);
}
if( FALSE == bInstallSuccess )
{
LogSetup( pSetupLog, L"Install or update service description failed %d\n", GetLastError() );
MYASSERT( FALSE );
hr = HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR);
}
else
{
LogSetup( pSetupLog, L"successfully installing service...\n" );
if( IsInstalled(pSetupLog) == FALSE )
{
LogSetup( pSetupLog, L"IsInstalled() return FALSE after Install()\n" );
MYASSERT(FALSE);
hr = HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR);
}
SetupEventViewerSource(pSetupLog);
}
}
if( SUCCEEDED(hr) )
{
// Add object entries
hr = CComModule::RegisterServer(bRegTypeLib);
if( FAILED(hr) )
{
LogSetup( pSetupLog, L"CComModule::RegisterServer() on type library failed with 0x%08x\n", hr );
}
}
CoUninitialize();
CLEANUPANDEXIT:
LogSetup( pSetupLog, L"Leaving CServiceModule::RegisterServer 0x%08x\n", hr );
return hr;
}
inline HRESULT CServiceModule::UnregisterServer(FILE* pSetupLog)
{
LogSetup( pSetupLog, L"\nEntering CServiceModule::UnregisterServer\n" );
HRESULT hr = CoInitialize(NULL);
if (FAILED(hr))
{
LogSetup( pSetupLog, L"CoInitialize() failed with 0x%08x\n", hr );
goto CLEANUPANDEXIT;
}
// Remove service entries
UpdateRegistryFromResource(IDR_Sessmgr, FALSE);
// Remove service
Uninstall(pSetupLog);
// Remove object entries
CComModule::UnregisterServer(TRUE);
CoUninitialize();
CLEANUPANDEXIT:
LogSetup( pSetupLog, L"Leaving CServiceModule::UnregisterServer() - 0x%08x\n", hr );
return S_OK;
}
inline void
CServiceModule::Init(
_ATL_OBJMAP_ENTRY* p,
HINSTANCE h,
UINT nServiceNameID,
UINT nServiceDispNameID,
UINT nServiceDescID,
const GUID* plibid
)
/*++
ATL Wizard generated code
--*/
{
CComModule::Init(p, h, plibid);
m_bService = TRUE;
m_dwServiceStartupStatus = ERROR_SUCCESS;
LoadString(h, nServiceNameID, m_szServiceName, sizeof(m_szServiceName) / sizeof(TCHAR));
LoadString(h, nServiceDescID, m_szServiceDesc, sizeof(m_szServiceDesc) / sizeof(TCHAR));
LoadString(h, nServiceDispNameID, m_szServiceDispName, sizeof(m_szServiceDispName)/sizeof(TCHAR));
// set up the initial service status
m_hServiceStatus = NULL;
m_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
m_status.dwCurrentState = SERVICE_STOPPED;
m_status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SESSIONCHANGE;
m_status.dwWin32ExitCode = 0;
m_status.dwServiceSpecificExitCode = 0;
m_status.dwCheckPoint = 0;
m_status.dwWaitHint = 0;
}
LONG CServiceModule::Unlock()
{
LONG l = CComModule::Unlock();
if (l == 0 && !m_bService)
PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
return l;
}
BOOL CServiceModule::IsInstalled(FILE* pSetupLog)
{
LogSetup( pSetupLog, L"\nEntering CServiceModule::IsInstalled()\n" );
BOOL bResult = FALSE;
SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCM != NULL)
{
SC_HANDLE hService = ::OpenService(hSCM, m_szServiceName, SERVICE_QUERY_CONFIG);
if (hService != NULL)
{
LogSetup( pSetupLog, L"OpenService() Succeeded\n" );
bResult = TRUE;
::CloseServiceHandle(hService);
}
else
{
LogSetup( pSetupLog, L"OpenService() failed with %d\n", GetLastError() );
}
::CloseServiceHandle(hSCM);
}
else
{
LogSetup( pSetupLog, L"OpenSCManager() failed with %d\n", GetLastError() );
}
LogSetup( pSetupLog, L"Leaving IsInstalled() - %d\n", bResult );
return bResult;
}
inline BOOL CServiceModule::UpdateService(FILE* pSetupLog)
{
DWORD dwStatus = ERROR_SUCCESS;
SERVICE_DESCRIPTION serviceDesc;
SC_HANDLE hSCM = NULL;
SC_HANDLE hService = NULL;
LogSetup( pSetupLog, L"\nEntering CServiceModule::UpdateServiceDescription()...\n" );
hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCM == NULL)
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"OpenSCManager() failed with %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
hService = ::OpenService( hSCM, m_szServiceName, SERVICE_CHANGE_CONFIG );
if (hService == NULL)
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"OpenService() failed with %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
serviceDesc.lpDescription = (LPTSTR)m_szServiceDesc;
if( FALSE == ChangeServiceConfig2( hService, SERVICE_CONFIG_DESCRIPTION, (LPVOID)&serviceDesc ) )
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"ChangeServiceConfig2() failed with %d\n", dwStatus );
MYASSERT( ERROR_SUCCESS == dwStatus );
}
//
// Performance : Set service to be demand start for upgrade
//
if( FALSE == ChangeServiceConfig(
hService,
SERVICE_NO_CHANGE,
SERVICE_DEMAND_START,
SERVICE_NO_CHANGE,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
m_szServiceDispName
) )
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"ChangeServiceConfig() failed with %d\n", dwStatus );
MYASSERT( ERROR_SUCCESS == dwStatus );
}
CLEANUPANDEXIT:
if( NULL != hService )
{
::CloseServiceHandle(hService);
}
if( NULL != hSCM )
{
::CloseServiceHandle(hSCM);
}
LogSetup( pSetupLog, L"Leaving UpdateServiceDescription::Install() - %d\n", dwStatus );
return dwStatus == ERROR_SUCCESS;
}
inline BOOL CServiceModule::Install(FILE* pSetupLog)
{
DWORD dwStatus = ERROR_SUCCESS;
SERVICE_DESCRIPTION serviceDesc;
SC_HANDLE hSCM;
TCHAR szFilePath[_MAX_PATH];
SC_HANDLE hService;
LogSetup( pSetupLog, L"\nEntering CServiceModule::Install()...\n" );
if (IsInstalled(pSetupLog))
{
LogSetup( pSetupLog, L"Service already installed\n" );
dwStatus = ERROR_SUCCESS;
goto CLEANUPANDEXIT;
}
hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCM == NULL)
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"OpenSCManager() failed with %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
// Get the executable file path
::GetModuleFileName(NULL, szFilePath, _MAX_PATH);
hService = ::CreateService(
hSCM,
m_szServiceName,
m_szServiceDispName,
SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS,
SERVICE_DEMAND_START,
SERVICE_ERROR_NORMAL,
szFilePath,
NULL,
NULL,
_T("RPCSS\0"),
NULL,
NULL
);
if (hService == NULL)
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"CreateService() failed with %d\n", dwStatus );
::CloseServiceHandle(hSCM);
goto CLEANUPANDEXIT;
}
serviceDesc.lpDescription = (LPTSTR)m_szServiceDesc;
if( FALSE == ChangeServiceConfig2( hService, SERVICE_CONFIG_DESCRIPTION, (LPVOID)&serviceDesc ) )
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"ChangeServiceConfig2() failed with %d\n", dwStatus );
MYASSERT( ERROR_SUCCESS == dwStatus );
}
::CloseServiceHandle(hService);
::CloseServiceHandle(hSCM);
CLEANUPANDEXIT:
LogSetup( pSetupLog, L"Leaving CServiceModule::Install() - %d\n", dwStatus );
return dwStatus == ERROR_SUCCESS;
}
inline BOOL CServiceModule::Uninstall(FILE* pSetupLog)
{
BOOL bStatus = TRUE;
SC_HANDLE hService;
SC_HANDLE hSCM;
SERVICE_STATUS status;
LogSetup( pSetupLog, L"\nEntering CServiceModule::Uninstall()...\n" );
if (!IsInstalled(pSetupLog))
{
LogSetup( pSetupLog, L"Service is not installed...\n" );
goto CLEANUPANDEXIT;
}
hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCM == NULL)
{
LogSetup( pSetupLog, L"OpenSCManager() failed with %d\n", GetLastError() );
bStatus = FALSE;
goto CLEANUPANDEXIT;
}
hService = ::OpenService(hSCM, m_szServiceName, SERVICE_STOP | DELETE);
if (hService == NULL)
{
::CloseServiceHandle(hSCM);
LogSetup( pSetupLog, L"OpenService() failed with %d\n", GetLastError() );
bStatus = FALSE;
goto CLEANUPANDEXIT;
}
::ControlService(hService, SERVICE_CONTROL_STOP, &status);
bStatus = ::DeleteService(hService);
if( FALSE == bStatus )
{
LogSetup( pSetupLog, L"DeleteService() failed with %d\n", GetLastError() );
}
::CloseServiceHandle(hService);
::CloseServiceHandle(hSCM);
CLEANUPANDEXIT:
LogSetup( pSetupLog, L"Leaving CServiceModule::Uninstall()\n" );
return bStatus;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Service startup and registration
inline void CServiceModule::Start()
{
SERVICE_TABLE_ENTRY st[] =
{
{ m_szServiceName, _ServiceMain },
{ NULL, NULL }
};
if (m_bService && !::StartServiceCtrlDispatcher(st))
{
m_bService = FALSE;
}
if (m_bService == FALSE)
Run();
}
inline void CServiceModule::ServiceMain(DWORD /* dwArgc */, LPTSTR* /* lpszArgv */)
{
// Register the control request handler
m_status.dwCurrentState = SERVICE_START_PENDING;
m_hServiceStatus = RegisterServiceCtrlHandlerEx(m_szServiceName, HandlerEx, this);
if (m_hServiceStatus == NULL)
{
//LogEvent(_T("Handler not installed"));
return;
}
m_status.dwWin32ExitCode = S_OK;
m_status.dwCheckPoint = 0;
m_status.dwWaitHint = SERVICE_STARTUP_WAITHINT;
SetServiceStatus(SERVICE_START_PENDING);
// When the Run function returns, the service has stopped.
Run();
SetServiceStatus(SERVICE_STOPPED);
}
inline void CServiceModule::Handler(DWORD dwOpcode)
{
switch (dwOpcode)
{
case SERVICE_CONTROL_STOP:
SetServiceStatus(SERVICE_STOP_PENDING);
if( PostThreadMessage(dwThreadID, WM_QUIT, 0, 0) == FALSE )
{
DWORD dwStatus = GetLastError();
}
break;
case SERVICE_CONTROL_PAUSE:
break;
case SERVICE_CONTROL_CONTINUE:
break;
case SERVICE_CONTROL_INTERROGATE:
break;
case SERVICE_CONTROL_SHUTDOWN:
break;
//default:
// LogEvent(_T("Bad service request"));
}
}
inline DWORD WINAPI
CServiceModule::HandlerEx(
DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext
)
/*++
--*/
{
DWORD dwRetCode;
switch (dwControl)
{
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_PAUSE:
case SERVICE_CONTROL_CONTINUE:
case SERVICE_CONTROL_INTERROGATE:
case SERVICE_CONTROL_SHUTDOWN:
dwRetCode = NO_ERROR;
_Handler(dwControl);
break;
#if DISABLESECURITYCHECKS
// this is require for Salem Unit test, we need to update
// user session status but for pcHealth, resolver will
// always popup invitation dialog so no need to track
// user session status.
case SERVICE_CONTROL_SESSIONCHANGE:
MYASSERT( NULL != lpEventData );
if( NULL != lpEventData )
{
switch( dwEventType )
{
case WTS_SESSION_LOGON:
DebugPrintf(
_TEXT("Session %d has log on...\n"),
((WTSSESSION_NOTIFICATION *)lpEventData)->dwSessionId
);
break;
case WTS_SESSION_LOGOFF:
case WTS_CONSOLE_DISCONNECT:
case WTS_REMOTE_DISCONNECT:
DebugPrintf(
_TEXT("Session %d has log off...\n"),
((WTSSESSION_NOTIFICATION *)lpEventData)->dwSessionId
);
//
// Deadlock if we use other thread to process logoff or
// disconnect.
//
// Notification thread lock pending help table and need
// to run Resolver in COM, COM is in the middle of
// dispatching create help ticket call which also need
// lock to pending help table, this causes deadlock
//
PostThreadMessage(
_Module.dwThreadID,
WM_SESSIONLOGOFFDISCONNECT,
0,
(LPARAM)((WTSSESSION_NOTIFICATION *)lpEventData)->dwSessionId
);
}
}
dwRetCode = NO_ERROR;
break;
#endif
default:
dwRetCode = ERROR_CALL_NOT_IMPLEMENTED;
}
return dwRetCode;
}
void WINAPI CServiceModule::_ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv)
{
_Module.ServiceMain(dwArgc, lpszArgv);
}
void WINAPI CServiceModule::_Handler(DWORD dwOpcode)
{
_Module.Handler(dwOpcode);
}
void CServiceModule::SetServiceStatus(DWORD dwState)
{
m_status.dwCurrentState = dwState;
::SetServiceStatus(m_hServiceStatus, &m_status);
}
HANDLE CServiceModule::gm_hIdle = NULL;
HANDLE CServiceModule::gm_hIdleMonitorThread = NULL;
HANDLE CServiceModule::gm_hICSAlertEvent = NULL;
unsigned __stdcall
StartupInitThread( void* ptr )
{
HRESULT hRes = S_OK;
DWORD dwErrCode = ERROR_SUCCESS;
hRes = g_HelpSessTable.OpenSessionTable(NULL);
if( SUCCEEDED(hRes) )
{
CRemoteDesktopHelpSessionMgr::NotifyPendingHelpServiceStartup();
}
else
{
dwErrCode = SESSMGR_E_HELPSESSIONTABLE;
}
if( FAILED(hRes) )
{
_Module.LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
dwErrCode,
hRes
);
hRes = dwErrCode;
}
_endthreadex( hRes );
return hRes;
}
ULONG
CServiceModule::AddRef()
{
CCriticalSectionLocker l( m_Locks );
m_RefCount++;
if( m_RefCount > 0 )
{
ResetEvent( gm_hIdle );
}
return m_RefCount;
}
ULONG
CServiceModule::Release()
{
CCriticalSectionLocker l( m_Locks );
m_RefCount--;
if( m_RefCount <= 0 )
{
// Only signal idle when there is no more pending help
if( g_HelpSessTable.NumEntries() == 0 )
{
SetEvent( gm_hIdle );
}
}
return m_RefCount;
}
unsigned int WINAPI
CServiceModule::IdleMonitorThread( void* ptr )
{
DWORD dwStatus = ERROR_SUCCESS;
CServiceModule* pServiceModule = (CServiceModule *)ptr;
HANDLE hWaitHandles[] = {gm_hICSAlertEvent, gm_hIdle};
CoInitialize(NULL);
if( pServiceModule != NULL )
{
while (TRUE)
{
dwStatus = WaitForMultipleObjects(
sizeof( hWaitHandles ) / sizeof( hWaitHandles[0] ),
hWaitHandles,
FALSE,
EXPIRE_HELPSESSION_PERIOD
);
if( WAIT_TIMEOUT == dwStatus )
{
// expire help ticket, refer to session logoff/disconnect
// comment above on why PostThreadMessage.
PostThreadMessage(
_Module.dwThreadID,
WM_EXPIREHELPSESSION,
0,
0
);
}
else if( WAIT_OBJECT_0 == dwStatus )
{
// ICS has signal us something has changed.
ResetEvent( gm_hICSAlertEvent );
}
else if( WAIT_OBJECT_0 + 1 == dwStatus )
{
// we have been idel for too long, time to try shutdown.
// idle event will only be signal when there is no
// pending help so we don't have to worry about address
// changes.
Sleep( IDLE_SHUTDOWN_PERIOD );
dwStatus = WaitForSingleObject( gm_hIdle, 0 );
if( WAIT_OBJECT_0 == dwStatus )
{
// no one holding object, time to shutdown
dwStatus = ERROR_SUCCESS;
break;
}
}
else if( WAIT_FAILED == dwStatus )
{
// some bad thing happen, shutdown.
//MYASSERT(FALSE);
break;
}
}
}
// TOBE enable with ICS work
//pServiceModule->LogInfoEvent( SESSMGR_I_SERVICE_IDLESTOP );
pServiceModule->Handler(SERVICE_CONTROL_STOP);
CoUninitialize();
_endthreadex( dwStatus );
return dwStatus;
}
BOOL
CServiceModule::InitializeSessmgr()
{
CCriticalSectionLocker l( m_Locks );
//
// Already initialize.
//
if( m_Initialized )
{
return TRUE;
}
//
// Service failed to startup, just return without initialize
// anything
//
if( !_Module.IsSuccessServiceStartup() )
{
return FALSE;
}
DWORD dwStatus;
unsigned int junk;
//
// Start ICSHELPER library.
//
dwStatus = StartICSLib();
if( ERROR_SUCCESS != dwStatus )
{
// Log an error event, we still need to startup
// so that we can report error back to caller
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_ICSHELPER,
dwStatus
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_ICSHELPER;
}
else
{
CRemoteDesktopHelpSessionMgr::NotifyPendingHelpServiceStartup();
}
m_Initialized = TRUE;
return _Module.IsSuccessServiceStartup();
}
void CServiceModule::Run()
{
//
// Mark we are not initialized yet...
//
m_Initialized = FALSE;
_Module.dwThreadID = GetCurrentThreadId();
DWORD dwStatus;
unsigned int dwJunk;
WSADATA wsData;
ISAFRemoteDesktopCallback* pIResolver = NULL;
LPWSTR pszSysAccName = NULL;
DWORD cbSysAccName = 0;
LPWSTR pszSysDomainName = NULL;
DWORD cbSysDomainName = 0;
SID_NAME_USE SidType;
HRESULT hr;
//
// **** DO NOT CHANGE SEQUENCE ****
//
// Refer to XP RAID 407457 for detail
//
// A thread named SessMgr!DpNatHlpThread is calling into dpnhupnp.dll,
// which is doing COM-related stuff, this is happening before the
// sessmgr!CServiceModule__Run method calls CoInitializeSecurity.
// When you do COM stuff before calling CoInitSec, COM do it for you,
// and you end up accepting the defaults
//
hr = g_HelpAccount.Initialize();
if( FAILED(hr) )
{
dwStatus = SESSMGR_E_HELPACCOUNT;
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_HELPACCOUNT;
MYASSERT(FALSE);
}
hr = LoadLocalSystemSID();
if( FAILED(hr) )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
MYASSERT(FALSE);
}
//
// We always need to startup otherwise will cause caller to timeout
// or AV.
//
hr = CoInitialize(NULL);
// If you are running on NT 4.0 or higher you can use the following call
// instead to make the EXE free threaded.
// This means that calls come in on a random RPC thread
// HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
_ASSERTE(SUCCEEDED(hr));
CSecurityDescriptor sd;
sd.InitializeFromThreadToken(); // get a default DACL
#ifndef DISABLESECURITYCHECKS
if( _Module.IsSuccessServiceStartup() )
{
BOOL bSuccess;
CComBSTR bstrHelpAccName;
//
// Retrieve System account name, might not be necessary since this
// pre-defined account shouldn't be localizable.
//
pszSysAccName = NULL;
cbSysAccName = 0;
pszSysDomainName = NULL;
cbSysDomainName = 0;
bSuccess = LookupAccountSid(
NULL,
g_pSidSystem,
pszSysAccName,
&cbSysAccName,
pszSysDomainName,
&cbSysDomainName,
&SidType
);
if( TRUE == bSuccess ||
ERROR_INSUFFICIENT_BUFFER == GetLastError() )
{
pszSysAccName = (LPWSTR) LocalAlloc( LPTR, (cbSysAccName + 1) * sizeof(WCHAR) );
pszSysDomainName = (LPWSTR) LocalAlloc( LPTR, (cbSysDomainName + 1) * sizeof(WCHAR) );
if( NULL != pszSysAccName && NULL != pszSysDomainName )
{
bSuccess = LookupAccountSid(
NULL,
g_pSidSystem,
pszSysAccName,
&cbSysAccName,
pszSysDomainName,
&cbSysDomainName,
&SidType
);
if( TRUE == bSuccess )
{
hr = sd.Allow( pszSysAccName, COM_RIGHTS_EXECUTE );
}
}
}
if( FALSE == bSuccess )
{
dwStatus = GetLastError();
hr = HRESULT_FROM_WIN32( dwStatus );
MYASSERT( SUCCEEDED(hr) );
}
//
// Add access permission to help assistant account
if( SUCCEEDED(hr) )
{
//
// Allow access to HelpAssistant account
//
hr = g_HelpAccount.GetHelpAccountNameEx( bstrHelpAccName );
if( SUCCEEDED(hr) )
{
hr = sd.Allow( (LPCTSTR)bstrHelpAccName, COM_RIGHTS_EXECUTE );
MYASSERT( SUCCEEDED(hr) );
}
}
//
// If we failed in setting DACL, we still need to startup but without
// full security, however, our interface will fail because service
// does not initialize correctly.
//
if( FAILED(hr) )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_RESTRICTACCESS,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_RESTRICTACCESS;
}
}
#endif
//
// We still need to startup or client might behave weird; interface call
// will be block by checking service startup status.
//
hr = CoInitializeSecurity(
sd,
-1,
NULL,
NULL,
RPC_C_AUTHN_LEVEL_PKT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_NONE,
NULL
);
_ASSERTE(SUCCEEDED(hr));
hr = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE);
_ASSERTE(SUCCEEDED(hr));
//
// Load unknown string for event loggging
//
g_UnknownString.LoadString( IDS_UNKNOWN );
//
// Load RA and URA string for event log
//
g_RAString.LoadString( IDS_RA_STRING );
g_URAString.LoadString( IDS_URA_STRING );
if( _Module.IsSuccessServiceStartup() )
{
//
// Startup TLSAPI in order to get public key
//
dwStatus = TLSInit();
if( LICENSE_STATUS_OK != dwStatus )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
dwStatus
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
MYASSERT(FALSE);
}
}
if( _Module.IsSuccessServiceStartup() )
{
//
// Load TermSrv public key, on PRO/PER we load public key from
// non-x509 certificate, on other SKU, we register a registry change
// notification and post ourself a message regarding public key
// change.
//
dwStatus = LoadAndSetupTSCertChangeNotification();
MYASSERT( ERROR_SUCCESS == dwStatus );
if( ERROR_SUCCESS != dwStatus )
{
// Log an error event, we still need to startup
// so that we can report error back to caller
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
dwStatus
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
}
}
if( _Module.IsSuccessServiceStartup() )
{
//
// Create an event for ICS to signal us
// any address change
//
gm_hICSAlertEvent = CreateEvent(
NULL,
TRUE,
FALSE,
NULL
);
if( NULL == gm_hICSAlertEvent )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
GetLastError()
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
MYASSERT(FALSE);
}
}
if( _Module.IsSuccessServiceStartup() )
{
//
// Initialize encryption library
//
dwStatus = TSHelpAssistantInitializeEncryptionLib();
if( ERROR_SUCCESS != dwStatus )
{
// Log an error event, we still need to startup
// so that we can report error back to caller
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_INIT_ENCRYPTIONLIB,
dwStatus
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_INIT_ENCRYPTIONLIB;
MYASSERT(FALSE);
}
}
if( _Module.IsSuccessServiceStartup() )
{
//
// startup WSA so we can invoke gethostname()
// critical error if we can startup WSA
if( WSAStartup(0x0101, &wsData) != 0 )
{
// Log an error event, we still need to startup
// so that we can report error back to caller
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_WSASTARTUP,
GetLastError()
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_WSASTARTUP;
}
}
if( _Module.IsSuccessServiceStartup() )
{
hr = g_HelpSessTable.OpenSessionTable(NULL);
if( FAILED(hr) )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_HELPSESSIONTABLE,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_HELPSESSIONTABLE;
MYASSERT(FALSE);
}
}
if( _Module.IsSuccessServiceStartup() )
{
//
// Service might startup from system restore, re-setup HelpAssistant account
// settings
if( g_HelpSessTable.NumEntries() == 0)
{
g_HelpAccount.EnableHelpAssistantAccount(FALSE);
g_HelpAccount.EnableRemoteInteractiveRight(FALSE);
}
else
{
//
// make sure HelpAssistant account is enabled and can logon locally
//
g_HelpAccount.EnableHelpAssistantAccount(TRUE);
g_HelpAccount.EnableRemoteInteractiveRight(TRUE);
g_HelpAccount.SetupHelpAccountTSSettings();
}
//
// Create an manual reset event for background thread to terminate
// service
//
gm_hIdle = CreateEvent(
NULL,
TRUE,
(g_HelpSessTable.NumEntries() == 0) ? TRUE : FALSE,
NULL
);
if( NULL == gm_hIdle )
{
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
GetLastError()
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
MYASSERT(FALSE);
}
// Create nackground thread thread
gm_hIdleMonitorThread = (HANDLE)_beginthreadex(
NULL,
0,
IdleMonitorThread,
(HANDLE)this,
0,
&dwJunk
);
if( NULL == gm_hIdleMonitorThread )
{
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
}
}
//LogEvent(_T("Service started"));
if (m_bService)
SetServiceStatus(SERVICE_RUNNING);
// TOBE enable with ICS work
//LogInfoEvent(SESSMGR_I_SERVICE_START);
//
// Load resolver, this will put one ref. count on it
// so it won't got unload until we are done.
//
hr = CoCreateInstance(
SESSIONRESOLVERCLSID,
NULL,
CLSCTX_SERVER,
IID_ISAFRemoteDesktopCallback,
(void **)&pIResolver
);
MYASSERT( SUCCEEDED(hr) );
if( FAILED(hr) )
{
//
// Can't initialize session resolver,
// session resolver will not be able to
// do caching.
//
LogEventWithStatusCode(
EVENTLOG_WARNING_TYPE,
SESSMGR_E_SESSIONRESOLVER,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_SESSIONRESOLVER;
}
else
{
//
// Create global interface table
//
hr = InitializeGlobalInterfaceTable();
if( SUCCEEDED(hr) )
{
//
// register resolver interface with GIT, resolver has some
// data structure that depends on single instance.
//
hr = RegisterResolverWithGIT(pIResolver);
}
if( FAILED(hr) )
{
//
// Not critical, Resolver function is disabled.
LogEventWithStatusCode(
EVENTLOG_WARNING_TYPE,
SESSMGR_E_REGISTERSESSIONRESOLVER,
hr
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_REGISTERSESSIONRESOLVER;
}
}
MSG msg;
while (GetMessage(&msg, 0, 0, 0))
{
switch( msg.message )
{
case WM_EXPIREHELPSESSION:
DebugPrintf(_TEXT("Executing TimeoutHelpSesion()...\n"));
CRemoteDesktopHelpSessionMgr::TimeoutHelpSesion();
break;
case WM_SESSIONLOGOFFDISCONNECT:
DebugPrintf(_TEXT("Executing NotifySessionLogoff() %d...\n"), msg.lParam);
NotifySessionLogoff( msg.lParam );
break;
case WM_LOADTSPUBLICKEY:
DebugPrintf( _TEXT("Executing LoadTermSrvSecurityBlob() ...\n") );
dwStatus = LoadTermSrvSecurityBlob();
if( ERROR_SUCCESS != dwStatus )
{
// Log an error event, we still need to startup
// so that we can report error back to caller
LogEventWithStatusCode(
EVENTLOG_ERROR_TYPE,
SESSMGR_E_GENERALSTARTUP,
dwStatus
);
_Module.m_dwServiceStartupStatus = SESSMGR_E_GENERALSTARTUP;
}
break;
case WM_HELPERRDSADDINEXIT:
DebugPrintf( _TEXT("WM_HELPERRDSADDINEXIT()...\n") );
CRemoteDesktopHelpSessionMgr::NotifyExpertLogoff( msg.wParam, (BSTR)msg.lParam );
break;
default:
DispatchMessage(&msg);
}
}
CleanupMonitorExpertList();
if( g_hWaitTSCertificateChanged )
{
UnregisterWait( g_hWaitTSCertificateChanged );
g_hWaitTSCertificateChanged = NULL;
}
if( g_hTSCertificateChanged )
{
CloseHandle( g_hTSCertificateChanged );
g_hTSCertificateChanged = NULL;
}
if( g_hTSCertificateRegKey )
{
RegCloseKey( g_hTSCertificateRegKey );
g_hTSCertificateRegKey = NULL;
}
//
//
if( NULL != pIResolver )
{
pIResolver->Release();
}
_Module.RevokeClassObjects();
// TOBE enable with ICS work
//LogInfoEvent(SESSMGR_I_SERVICE_STOP);
CoUninitialize();
if( NULL != gm_hIdle )
{
CloseHandle( gm_hIdle );
}
if( WSACleanup() != 0 )
{
// shutting down, ignore WSA error
#if DBG
OutputDebugString( _TEXT("WSACleanup() failed...\n") );
#endif
}
#if DBG
OutputDebugString( _TEXT("Help Session Manager Exited...\n") );
#endif
// Close the help session table, help session table
// open by init. thread
g_HelpSessTable.CloseSessionTable();
// Stop ICS library, ignore error code.
StopICSLib();
TSHelpAssistantEndEncryptionLib();
UnInitializeGlobalInterfaceTable();
if( NULL != pszSysAccName )
{
LocalFree( pszSysAccName );
}
if( NULL != pszSysDomainName )
{
LocalFree( pszSysDomainName );
}
TLSShutdown();
}
HRESULT
CreatePendingHelpTable(
FILE* pSetupLog
)
/*++
Routine to create pending help table registry key, if registry key already exist,
set the DACL to system context only.
--*/
{
PACL pAcl=NULL;
DWORD dwStatus = ERROR_SUCCESS;
PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
DWORD cbAcl = 0;
PSID pSidSystem = NULL;
HKEY hKey = NULL;
LogSetup( pSetupLog, L"\nEntering CreatePendingHelpTable\n" );
pSecurityDescriptor = (PSECURITY_DESCRIPTOR)LocalAlloc(LPTR, sizeof(SECURITY_DESCRIPTOR));
if( NULL == pSecurityDescriptor )
{
LogSetup( pSetupLog, L"Can't alloc memory for SECURITY_DESCRIPTOR\n" );
dwStatus = GetLastError();
goto CLEANUPANDEXIT;
}
//
// Initialize the security descriptor.
//
if (!InitializeSecurityDescriptor(
pSecurityDescriptor,
SECURITY_DESCRIPTOR_REVISION
))
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"InitializeSecurityDescriptor() failed with %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
dwStatus = CreateSystemSid( &pSidSystem );
if( ERROR_SUCCESS != dwStatus )
{
LogSetup( pSetupLog, L"CreateSystemSid() failed with %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
cbAcl = GetLengthSid( pSidSystem ) + sizeof(ACL) + (2 * (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)));
pAcl = (PACL) LocalAlloc( LPTR, cbAcl );
if( NULL == pAcl )
{
LogSetup( pSetupLog, L"Can't alloc memory for ACL\n" );
dwStatus = GetLastError();
goto CLEANUPANDEXIT;
}
//
// Initialize the ACL.
//
if (!InitializeAcl(pAcl, cbAcl, ACL_REVISION))
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"InitializeAcl() failed with error code %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
//
if (!AddAccessAllowedAce(pAcl,
ACL_REVISION,
GENERIC_READ | GENERIC_WRITE | GENERIC_ALL,
pSidSystem
))
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"AddAccessAllowedAce() failed with error code %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
if (!SetSecurityDescriptorDacl(pSecurityDescriptor,
TRUE, pAcl, FALSE))
{
dwStatus = GetLastError();
LogSetup( pSetupLog, L"SetSecurityDescriptorDacl() failed with error code %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
//
// Create/open the pending table registry key
//
dwStatus = RegCreateKeyEx(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK _TEXT("\\") REGKEY_HELPSESSIONTABLE,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKey,
NULL
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup( pSetupLog, L"RegCreateKeyEx() failed with error code %d\n", dwStatus );
goto CLEANUPANDEXIT;
}
//
// Set table (registry) DACL
//
dwStatus = RegSetKeySecurity(
hKey,
DACL_SECURITY_INFORMATION,
pSecurityDescriptor
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup( pSetupLog, L"RegSetKeySecurity() failed with error code %d\n", dwStatus );
}
CLEANUPANDEXIT:
if( NULL != hKey )
{
RegCloseKey(hKey);
}
if( pAcl != NULL )
{
LocalFree(pAcl);
}
if( pSecurityDescriptor != NULL )
{
LocalFree( pSecurityDescriptor );
}
if( pSidSystem != NULL )
{
FreeSid( pSidSystem );
}
LogSetup( pSetupLog, L"CreatePendingHelpTable() return %d\n", dwStatus );
return HRESULT_FROM_WIN32(dwStatus);
}
void
UpgradeSessmgr(
FILE* pSetupLog
)
/*++
Routine to upgrade session manager
--*/
{
LogSetup( pSetupLog, L"\nEntering UpgradeSessmgr\n" );
//
// Migrate fAllowToGetHelp policy in HKLM\Software\Microsoft\Remote Desktop\Policies
// to termsrv so listening thread can look at single place.
//
DWORD dwValue;
DWORD dwStatus;
DWORD dwSize;
DWORD dwType;
HKEY hKey;
BOOL bUpgradeFromB1 = FALSE;
LogSetup( pSetupLog, L"Setting policy registry key\n" );
//
// Open TS registry key under HKLM\System\CurrentControlSet\Control\Terminal Serv...
//
dwStatus = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
REG_CONTROL_GETHELP,
0,
KEY_READ | KEY_WRITE,
&hKey
);
if( ERROR_SUCCESS == dwStatus )
{
dwStatus = GetPolicyAllowGetHelpSetting(
HKEY_LOCAL_MACHINE,
OLD_REG_CONTROL_GETHELP,
RDS_ALLOWGETHELP_VALUENAME,
&dwValue
);
if( ERROR_SUCCESS == dwStatus )
{
LogSetup( pSetupLog, L"B1 policy value %d\n", dwValue );
//
// Delete the old policy key, ignore error.
//
RegDelKey( HKEY_LOCAL_MACHINE, OLD_REG_CONTROL_GETHELP );
//
// This value exists in old Salem policy key, system must be
// upgrading from B1.
//
dwStatus = RegSetValueEx(
hKey,
RDS_ALLOWGETHELP_VALUENAME,
0,
REG_DWORD,
(PBYTE)&dwValue,
sizeof(dwValue)
);
bUpgradeFromB1 = TRUE;
}
else
{
LogSetup( pSetupLog, L"B1 policy key does not exist\n" );
dwSize = sizeof(dwValue);
//
// Upgrade from B2 and beyond, check to see if fAllowToGetHelp exist
// if not, set it to 1.
//
dwStatus = RegQueryValueEx(
hKey,
RDS_ALLOWGETHELP_VALUENAME,
0,
&dwType,
(PBYTE)&dwValue,
&dwSize
);
if( ERROR_FILE_NOT_FOUND == dwStatus || REG_DWORD != dwType )
{
//
// default is not allow to get help if
// value does not exist.
//
dwValue = 1;
dwStatus = RegSetValueEx(
hKey,
RDS_ALLOWGETHELP_VALUENAME,
0,
REG_DWORD,
(PBYTE)&dwValue,
sizeof(dwValue)
);
}
else
{
LogSetup( pSetupLog, L"Existing fAllowToGetHelp Policy value %d\n", dwValue );
}
}
LogSetup( pSetupLog, L"Setting fAllowGetHelp policy key result - %d\n", dwStatus );
RegCloseKey( hKey );
}
else
{
LogSetup(
pSetupLog,
L"Can't open registry key %s, error code %d\n",
REG_CONTROL_GETHELP,
dwStatus
);
}
if( TRUE == bUpgradeFromB1 )
{
//
// B1, help assistant account password is clear text, this will fix the
// security leak.
//
LogSetup( pSetupLog, L"Upgrade from B1, delete all pending help and reset account password\n" );
RegDelKey(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK _TEXT("\\") REGKEY_HELPSESSIONTABLE
);
g_HelpAccount.ResetHelpAccountPassword();
}
LogSetup( pSetupLog, L"Leaving UpgradeSessmgr\n" );
return;
}
#define UNINSTALL_BEFORE_INSTALL _TEXT("UninstallBeforeInstall")
HRESULT
InstallUninstallSessmgr(
DWORD code
)
/*++
--*/
{
FILE* pSetupLog;
TCHAR LogFile[MAX_PATH+1];
HRESULT hRes = S_OK;
DWORD dwStatus = ERROR_SUCCESS;
HKEY hKey = NULL;
DWORD dwValue = 1;
DWORD dwType;
DWORD cbData = sizeof(dwValue);
GetWindowsDirectory( LogFile, MAX_PATH );
lstrcat( LogFile, L"\\" );
lstrcat( LogFile, SETUPLOGFILE_NAME );
pSetupLog = _tfopen( LogFile, L"a+t" );
MYASSERT( NULL != pSetupLog );
LogSetup( pSetupLog, L"\n\n********* Install/uninstall sessmgr service *********\n" );
//
// no checking on return, if failure, we just do OutputDebugString();
//
switch( code )
{
case SESSMGR_UNREGSERVER:
{
LogSetup( pSetupLog, L"Uninstalling sessmgr service\n" );
//
// Delete all pending help session.
//
dwStatus = RegDelKey(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK _TEXT("\\") REGKEY_HELPSESSIONTABLE
);
LogSetup( pSetupLog, L"Delete pending table return %d\n", dwStatus );
//
// We might not be running in system context so deleting registry and
// cleanup LSA key will fail, write a key to our control location to
// mark such that delete everything before install
//
dwStatus = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK,
0,
KEY_ALL_ACCESS,
&hKey
);
if( ERROR_SUCCESS == dwStatus )
{
dwStatus = RegSetValueEx(
hKey,
UNINSTALL_BEFORE_INSTALL,
0,
REG_DWORD,
(BYTE *) &dwValue,
sizeof(dwValue)
);
if( ERROR_SUCCESS != dwStatus )
{
LogSetup( pSetupLog, L"Failed to set value, error code %d\n", dwStatus );
MYASSERT(FALSE);
}
RegCloseKey( hKey );
}
else
{
// This is OK since we havn't been install before.
LogSetup( pSetupLog, L"Failed to open control key, error code %d\n", dwStatus );
}
//
// Initialize to get help account name.
//
hRes = g_HelpAccount.Initialize();
LogSetup( pSetupLog, L"Initialize help account return 0x%08x\n", hRes );
//
// ignore error, try to delete the account
hRes = g_HelpAccount.DeleteHelpAccount();
LogSetup( pSetupLog, L"Delete help account return 0x%08x\n", hRes );
MYASSERT( SUCCEEDED(hRes) );
hRes = _Module.UnregisterServer(pSetupLog);
LogSetup( pSetupLog, L"UnregisterServer() returns 0x%08x\n", hRes );
if( ERROR_SUCCESS == StartICSLib() )
{
// Non-critical if we can't startup the lib since after we shutdown,
// we would have close all the port
CloseAllOpenPorts();
StopICSLib();
}
}
break;
case SESSMGR_REGSERVER:
{
LogSetup( pSetupLog, L"Installing as non-service\n" );
#if DBG
AddAccountToFilterList( HELPASSISTANTACCOUNT_NAME );
MYASSERT( ERROR_SUCCESS == g_HelpAccount.CreateHelpAccount() ) ;
hRes = _Module.RegisterServer(pSetupLog, TRUE, FALSE);
#else
hRes = E_INVALIDARG;
#endif
}
break;
//case SESSMGR_UPGRADE:
//
// TODO - ICS work, add upgrade special code.
//
case SESSMGR_SERVICE:
{
LogSetup( pSetupLog, L"Installing sessmgr service\n" );
hRes = S_OK;
//
// Clean up again, we might not be running in system
// context at the time of uninstall so clean up will failed.
//
dwStatus = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK,
0,
KEY_ALL_ACCESS,
&hKey
);
if( ERROR_SUCCESS == dwStatus )
{
//
// Check to see if previous uninstall failed,
// we only need to check value exists.
//
dwStatus = RegQueryValueEx(
hKey,
UNINSTALL_BEFORE_INSTALL,
0,
&dwType,
(BYTE *) &dwValue,
&cbData
);
if( ERROR_SUCCESS != dwStatus || REG_DWORD != dwType )
{
//
// No previous uninstall information, no need to delete anything
//
LogSetup( pSetupLog, L"UninstallBeforeInstall value not found or invalid, code %d\n", dwStatus );
}
else
{
LogSetup( pSetupLog, L"UninstallBeforeInstall exists, cleanup previous uninstall\n" );
//
// Previous uninstall failed, delete all pending help session,
// and clean up encryption key
//
dwStatus = RegDelKey(
HKEY_LOCAL_MACHINE,
REGKEYCONTROL_REMDSK _TEXT("\\") REGKEY_HELPSESSIONTABLE
);
//
// It's OK to fail here since we reset encryption key making existing
// ticket useless and will be deleted on expire.
//
LogSetup( pSetupLog, L"Delete pending table return %d\n", dwStatus );
dwStatus = TSHelpAssistantInitializeEncryptionLib();
if( ERROR_SUCCESS == dwStatus )
{
dwStatus = TSHelpAssisantEndEncryptionCycle();
if( ERROR_SUCCESS != dwStatus )
{
LogSetup( pSetupLog, L"TSHelpAssisantEndEncryptionCycle() returns 0x%08x\n", dwStatus );
LogSetup( pSetupLog, L"sessmgr setup can't continue\n" );
// Critical security error, existing ticket might still be valid
hRes = HRESULT_FROM_WIN32( dwStatus );
}
TSHelpAssistantEndEncryptionLib();
}
else
{
LogSetup( pSetupLog, L"TSHelpAssistantInitializeEncryptionLib return %d\n", dwStatus );
LogSetup( pSetupLog, L"sessmgr setup can't continue\n" );
// Critical security error, existing ticket might still be valid
hRes = HRESULT_FROM_WIN32( dwStatus );
}
}
if( SUCCEEDED(hRes) )
{
//
// Delete reg. value to uninstall before install only when successfully
// resetting encryption key
//
RegDeleteValue( hKey, UNINSTALL_BEFORE_INSTALL );
}
RegCloseKey( hKey );
}
if( SUCCEEDED(hRes) )
{
hRes = g_HelpAccount.CreateHelpAccount();
if( SUCCEEDED(hRes) )
{
CComBSTR bstrHelpAccName;
hRes = g_HelpAccount.GetHelpAccountNameEx( bstrHelpAccName );
MYASSERT( SUCCEEDED(hRes) );
if( FAILED(hRes) )
{
// not a critical error, we can still use help
LogSetup( pSetupLog, L"Failed to retrieve HelpAssistantaccount name - 0x%08x\n", hRes );
}
else
{
LogSetup( pSetupLog, L"HelpAssistant account name - %s\n", bstrHelpAccName );
// Add HelpAssistantAccount into account filter list
AddAccountToFilterList( bstrHelpAccName );
}
//
// Two type of SP install, one thru SP1 installer and the other is
// normal NT setup including all SP fixes.
// We disable account on setup and let service startup to re-enable it
//
g_HelpAccount.EnableHelpAssistantAccount(FALSE);
//
// Upgrade session manager
//
UpgradeSessmgr(pSetupLog);
LogSetup( pSetupLog, L"Successfully setup account\n" );
hRes = _Module.RegisterServer(pSetupLog, TRUE, TRUE);
if( FAILED(hRes) )
{
LogSetup( pSetupLog, L"Failed to register/installing service - 0x%08x\n", hRes );
}
}
else
{
LogSetup( pSetupLog, L"Creating Help Assistant account failed with 0x%08x\n", hRes );
(void) g_HelpAccount.DeleteHelpAccount();
hRes = E_FAIL;
}
}
if( SUCCEEDED(hRes) )
{
hRes = CreatePendingHelpTable(pSetupLog);
if( FAILED(hRes) )
{
LogSetup(
pSetupLog,
L"CreatePendingHelpTable() failed - 0x%08x\n",
hRes
);
}
}
}
break;
default:
LogSetup( pSetupLog, L"Invalid setup operation %d\n", code );
hRes = E_UNEXPECTED;
}
LogSetup( pSetupLog, L"\n*** Finish Setup with Status 0x%08x ***\n", hRes );
if( pSetupLog )
{
fflush( pSetupLog );
fclose( pSetupLog);
}
return hRes;
}
/////////////////////////////////////////////////////////////////////////////
//
extern "C" int WINAPI _tWinMain(HINSTANCE hInstance,
HINSTANCE /*hPrevInstance*/, LPTSTR lpCmdLine, int /*nShowCmd*/)
{
HRESULT hRes;
CComBSTR bstrErrMsg;
CComBSTR bstrServiceDesc;
DWORD dwStatus;
lpCmdLine = GetCommandLine(); //this line necessary for _ATL_MIN_CRT
_Module.Init(ObjectMap, hInstance, IDS_SERVICENAME, IDS_SERVICEDISPLAYNAME, IDS_SERVICEDESC, &LIBID_RDSESSMGRLib);
_Module.m_bService = TRUE;
TCHAR szTokens[] = _T("-/");
//
// We don't do OS version checking as in Win9x case, some of our
// call uses API not exists on Win9x so will get unresolve
// reference when running on Win9x box.
//
bstrServiceDesc.LoadString( IDS_SERVICEDISPLAYNAME );
LPCTSTR lpszToken = FindOneOf(lpCmdLine, szTokens);
while (lpszToken != NULL)
{
if (lstrcmpi(lpszToken, _T("UnregServer"))==0)
{
return InstallUninstallSessmgr( SESSMGR_UNREGSERVER );
}
else if (lstrcmpi(lpszToken, _T("RegServer"))==0)
{
return InstallUninstallSessmgr( SESSMGR_REGSERVER );
}
else if (lstrcmpi(lpszToken, _T("Service"))==0)
{
return InstallUninstallSessmgr( SESSMGR_SERVICE );
}
else if ( lstrcmpi(lpszToken, _T("SP1Upgrade"))==0)
{
// BUGL 602653, HelpAssistant account is not disable at clean install
// disable account here and let service start up to re-enable.
return EnableLocalAccount( HELPASSISTANTACCOUNT_NAME, FALSE );
}
lpszToken = FindOneOf(lpszToken, szTokens);
}
// Are we Service or Local Server
CRegKey keyAppID;
LONG lRes = keyAppID.Open(HKEY_CLASSES_ROOT, _T("AppID"), KEY_READ);
if (lRes != ERROR_SUCCESS)
{
_Module.LogErrorEvent( SESSMGR_E_SETUP );
return lRes;
}
CRegKey key;
lRes = key.Open(keyAppID, _T("{038ABBA4-4138-4AC4-A492-4A3DF068BD8A}"), KEY_READ);
if (lRes != ERROR_SUCCESS)
{
_Module.LogErrorEvent( SESSMGR_E_SETUP );
return lRes;
}
TCHAR szValue[_MAX_PATH];
DWORD dwLen = _MAX_PATH;
lRes = key.QueryValue(szValue, _T("LocalService"), &dwLen);
_Module.m_bService = FALSE;
if (lRes == ERROR_SUCCESS)
_Module.m_bService = TRUE;
_Module.Start();
// When we get here, the service has been stopped
return _Module.m_status.dwWin32ExitCode;
}
Reference in a new issue Copy permalink