You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
786 lines
21 KiB
786 lines
21 KiB
//#--------------------------------------------------------------
|
|
//
|
|
// File: ldm.cpp
|
|
//
|
|
// Synopsis: This file holds the implementation of the
|
|
// CServiceModule class and WinMain
|
|
//
|
|
// History: 11/15/2000 serdarun Created
|
|
//
|
|
// Copyright (C) 1999-2000 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
//#--------------------------------------------------------------
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include <initguid.h>
|
|
#include "ldm.h"
|
|
#include "ldm_i.c"
|
|
|
|
#include "mainwindow.h"
|
|
#include <stdio.h>
|
|
#include "SAKeypadController.h"
|
|
#include "display.h"
|
|
#include "sacomguid.h"
|
|
|
|
CServiceModule _Module;
|
|
|
|
DWORD
|
|
SetAclForComObject (
|
|
/*[in]*/ PSECURITY_DESCRIPTOR pSD,
|
|
/*[out*/ PACL *ppacl
|
|
);
|
|
|
|
BEGIN_OBJECT_MAP(ObjectMap)
|
|
OBJECT_ENTRY(CLSID_SAKeypadController, CSAKeypadController)
|
|
END_OBJECT_MAP()
|
|
|
|
const wchar_t szServiceAppID[] = L"{0678A0EA-A69E-4211-8A3E-EBF80BB64D38}";
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Although some of these functions are big they are declared inline
|
|
// since they are only used once
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
inline HRESULT CServiceModule::RegisterServer(BOOL bRegTypeLib, BOOL bService)
|
|
{
|
|
HRESULT hr = CoInitialize(NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
SATraceString ("LDM Service registration failed");
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Remove any previous service since it may point to
|
|
// the incorrect file
|
|
Uninstall();
|
|
|
|
// Add service entries
|
|
UpdateRegistryFromResource(IDR_Ldm, TRUE);
|
|
|
|
// Adjust the AppID for Local Server or Service
|
|
CRegKey keyAppID;
|
|
|
|
LONG lRes = keyAppID.Open(HKEY_CLASSES_ROOT, _T("AppID"), KEY_WRITE);
|
|
|
|
if (lRes != ERROR_SUCCESS)
|
|
return lRes;
|
|
|
|
CRegKey key;
|
|
lRes = key.Open(keyAppID, szServiceAppID, KEY_WRITE);
|
|
if (lRes != ERROR_SUCCESS)
|
|
return lRes;
|
|
key.DeleteValue(_T("LocalService"));
|
|
|
|
if (bService)
|
|
{
|
|
key.SetValue(_T("saldm"), _T("LocalService"));
|
|
key.SetValue(_T("-Service"), _T("ServiceParameters"));
|
|
// Create service
|
|
Install();
|
|
}
|
|
|
|
// Add object entries
|
|
hr = CComModule::RegisterServer(bRegTypeLib);
|
|
|
|
CoUninitialize();
|
|
return hr;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
inline HRESULT CServiceModule::UnregisterServer()
|
|
{
|
|
HRESULT hr = CoInitialize(NULL);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
// Remove service entries
|
|
UpdateRegistryFromResource(IDR_Ldm, FALSE);
|
|
// Remove service
|
|
Uninstall();
|
|
// Remove object entries
|
|
CComModule::UnregisterServer(TRUE);
|
|
CoUninitialize();
|
|
return S_OK;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
inline void CServiceModule::Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h,
|
|
UINT nServiceNameID, UINT nServiceShortNameID,
|
|
const GUID* plibid)
|
|
{
|
|
CComModule::Init(p, h, plibid);
|
|
|
|
m_bService = TRUE;
|
|
|
|
LoadString(h, nServiceNameID, m_szServiceName, sizeof(m_szServiceName) / sizeof(TCHAR));
|
|
LoadString(h, nServiceShortNameID, m_szServiceShortName, sizeof(m_szServiceShortName) / 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_SHUTDOWN;
|
|
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()
|
|
{
|
|
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)
|
|
{
|
|
bResult = TRUE;
|
|
::CloseServiceHandle(hService);
|
|
}
|
|
::CloseServiceHandle(hSCM);
|
|
}
|
|
return bResult;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
inline BOOL CServiceModule::Install()
|
|
{
|
|
if (IsInstalled())
|
|
return TRUE;
|
|
|
|
SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
|
|
if (hSCM == NULL)
|
|
{
|
|
SATraceString ("CServiceModule::Install, Couldn't open service manager...");
|
|
return FALSE;
|
|
}
|
|
|
|
// Get the executable file path
|
|
TCHAR szFilePath[_MAX_PATH +1];
|
|
DWORD dwResult = ::GetModuleFileName(NULL, szFilePath, _MAX_PATH);
|
|
if (0 == dwResult)
|
|
{
|
|
return (FALSE);
|
|
}
|
|
szFilePath [_MAX_PATH] = L'\0';
|
|
|
|
SC_HANDLE hService = ::CreateService(
|
|
hSCM, m_szServiceShortName, m_szServiceName,
|
|
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
|
|
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL,
|
|
szFilePath, NULL, NULL, _T("RPCSS\0"), NULL, NULL);
|
|
|
|
if (hService == NULL)
|
|
{
|
|
::CloseServiceHandle(hSCM);
|
|
SATraceString ("CServiceModule::Install, Couldn't create service...");
|
|
return FALSE;
|
|
}
|
|
|
|
::CloseServiceHandle(hService);
|
|
::CloseServiceHandle(hSCM);
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
inline BOOL CServiceModule::Uninstall()
|
|
{
|
|
if (!IsInstalled())
|
|
return TRUE;
|
|
|
|
SC_HANDLE hSCM = ::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
|
|
|
|
if (hSCM == NULL)
|
|
{
|
|
SATraceString ("CServiceModule::Uninstall, Couldn't open service manager...");
|
|
return FALSE;
|
|
}
|
|
|
|
SC_HANDLE hService = ::OpenService(hSCM, m_szServiceName, SERVICE_STOP | DELETE);
|
|
|
|
if (hService == NULL)
|
|
{
|
|
::CloseServiceHandle(hSCM);
|
|
SATraceString ("CServiceModule::Uninstall, Couldn't open service...");
|
|
return FALSE;
|
|
}
|
|
SERVICE_STATUS status;
|
|
::ControlService(hService, SERVICE_CONTROL_STOP, &status);
|
|
|
|
BOOL bDelete = ::DeleteService(hService);
|
|
::CloseServiceHandle(hService);
|
|
::CloseServiceHandle(hSCM);
|
|
|
|
if (bDelete)
|
|
return TRUE;
|
|
|
|
SATraceString ("CServiceModule::Uninstall, Service could not be deleted...");
|
|
return FALSE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
// Logging functions
|
|
void CServiceModule::LogEvent(LPCTSTR pFormat, ...)
|
|
{
|
|
TCHAR chMsg[256];
|
|
HANDLE hEventSource;
|
|
LPTSTR lpszStrings[1];
|
|
va_list pArg;
|
|
|
|
va_start(pArg, pFormat);
|
|
_vstprintf(chMsg, pFormat, pArg);
|
|
va_end(pArg);
|
|
|
|
lpszStrings[0] = chMsg;
|
|
|
|
if (m_bService)
|
|
{
|
|
/* Get a handle to use with ReportEvent(). */
|
|
hEventSource = RegisterEventSource(NULL, m_szServiceName);
|
|
if (hEventSource != NULL)
|
|
{
|
|
/* Write to event log. */
|
|
ReportEvent(hEventSource, EVENTLOG_INFORMATION_TYPE, 0, 0, NULL, 1, 0, (LPCTSTR*) &lpszStrings[0], NULL);
|
|
DeregisterEventSource(hEventSource);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// As we are not running as a service, just write the error to the console.
|
|
_putts(chMsg);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
// 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 = RegisterServiceCtrlHandler(m_szServiceName, _Handler);
|
|
|
|
if (m_hServiceStatus == NULL)
|
|
{
|
|
return;
|
|
}
|
|
SetServiceStatus(SERVICE_START_PENDING);
|
|
|
|
m_status.dwWin32ExitCode = S_OK;
|
|
m_status.dwCheckPoint = 0;
|
|
m_status.dwWaitHint = 0;
|
|
|
|
// 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 we have a handle to the window, close the window
|
|
//
|
|
if (_Module.hwnd)
|
|
{
|
|
PostMessage(_Module.hwnd, WM_CLOSE, 0, 0);
|
|
}
|
|
//
|
|
// quit the message pump with WM_QUIT message
|
|
//
|
|
else
|
|
{
|
|
PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
|
|
}
|
|
|
|
break;
|
|
case SERVICE_CONTROL_PAUSE:
|
|
break;
|
|
case SERVICE_CONTROL_CONTINUE:
|
|
break;
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
break;
|
|
case SERVICE_CONTROL_SHUTDOWN:
|
|
|
|
//
|
|
// post IOCTL_SADISPLAY_SHUTDOWN_MESSAGE to display driver
|
|
//
|
|
PostLCDShutdownMessage();
|
|
|
|
//
|
|
// If we have a handle to the window, close the window
|
|
//
|
|
if (_Module.hwnd)
|
|
{
|
|
PostMessage(_Module.hwnd, WM_CLOSE, 0, 0);
|
|
}
|
|
//
|
|
// quit the message pump with WM_QUIT message
|
|
//
|
|
else
|
|
{
|
|
PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
|
|
}
|
|
|
|
|
|
break;
|
|
default:
|
|
SATracePrintf ("LDM received unknown control request:%d", dwOpcode);
|
|
}
|
|
}
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: PostLCDShutdownMessage
|
|
//
|
|
// Synopsis: This is the CServiceModule private method to send
|
|
// the shutdown message to the LCD
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// History: serdarun Created 04/05/2001
|
|
//
|
|
//-----------------------------------------------------------------
|
|
void CServiceModule::PostLCDShutdownMessage()
|
|
{
|
|
|
|
CDisplay objDisplay;
|
|
|
|
//
|
|
// send IOCTL_SADISPLAY_SHUTDOWN_MESSAGE message to display driver
|
|
// using the CDisplay class method
|
|
//
|
|
|
|
//
|
|
// lock the display first
|
|
//
|
|
objDisplay.Lock ();
|
|
|
|
//
|
|
// post the shutdown now
|
|
//
|
|
objDisplay.Shutdown ();
|
|
|
|
|
|
} // end of CServiceModule::PostLCDShutdownMessage method
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
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);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
void CServiceModule::Run()
|
|
{
|
|
_Module.dwThreadID = GetCurrentThreadId();
|
|
|
|
HRESULT 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));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CSecurityDescriptor sd;
|
|
|
|
sd.InitializeFromThreadToken();
|
|
|
|
|
|
PACL pacl = NULL;
|
|
//
|
|
//
|
|
// Add ACLs to the SD using the builtin RIDs.
|
|
//
|
|
DWORD dwRetVal = SetAclForComObject (
|
|
(PSECURITY_DESCRIPTOR) sd.m_pSD,
|
|
&pacl
|
|
);
|
|
if (ERROR_SUCCESS != dwRetVal) {return;}
|
|
|
|
hr = CoInitializeSecurity(
|
|
sd,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
|
|
RPC_C_IMP_LEVEL_IDENTIFY,
|
|
NULL,
|
|
EOAC_NONE,
|
|
NULL);
|
|
|
|
_ASSERTE(SUCCEEDED(hr));
|
|
|
|
// Register the class with COM
|
|
//
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
hr = _Module.RegisterClassObjects(CLSCTX_SERVER, REGCLS_MULTIPLEUSE);
|
|
|
|
_ASSERTE(SUCCEEDED(hr));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (m_bService)
|
|
SetServiceStatus(SERVICE_RUNNING);
|
|
|
|
|
|
CMainWindow m_ieWindow;
|
|
|
|
hr = m_ieWindow.Initialize();
|
|
m_ieWindow.id = _Module.dwThreadID;
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
_Module.hwnd = NULL;
|
|
SATraceString ("Main window initialization failed");
|
|
}
|
|
else
|
|
{
|
|
_Module.hwnd = m_ieWindow.m_hWnd;
|
|
m_ieWindow.ShowWindow(SW_SHOW);
|
|
m_ieWindow.UpdateWindow();
|
|
}
|
|
|
|
MSG msg;
|
|
|
|
while (GetMessage(&msg, NULL, 0, 0))
|
|
{
|
|
|
|
if ( (m_ieWindow.m_pMainInPlaceAO!= 0) && (!m_ieWindow.m_bActiveXFocus)/*&& (msg.wParam == VK_TAB) */)
|
|
m_ieWindow.m_pMainInPlaceAO->TranslateAccelerator(&msg);
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
|
|
}
|
|
_Module.RevokeClassObjects();
|
|
|
|
}
|
|
|
|
//
|
|
// cleanup
|
|
//
|
|
if (pacl) {LocalFree (pacl);}
|
|
CoUninitialize();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
extern "C" int WINAPI _tWinMain(HINSTANCE hInstance,
|
|
HINSTANCE /*hPrevInstance*/, LPTSTR lpCmdLine, int /*nShowCmd*/)
|
|
{
|
|
|
|
lpCmdLine = GetCommandLine(); //this line necessary for _ATL_MIN_CRT
|
|
|
|
_Module.Init(ObjectMap, hInstance, IDS_SERVICENAME,
|
|
IDS_SERVICESHORTNAME, &LIBID_LDMLib);
|
|
|
|
_Module.m_bService = TRUE;
|
|
TCHAR szTokens[] = _T("-/");
|
|
|
|
LPCTSTR lpszToken = FindOneOf(lpCmdLine, szTokens);
|
|
while (lpszToken != NULL)
|
|
{
|
|
if (lstrcmpi(lpszToken, _T("UnregServer"))==0)
|
|
return _Module.UnregisterServer();
|
|
|
|
// Register as Local Server
|
|
if (lstrcmpi(lpszToken, _T("RegServer"))==0)
|
|
return _Module.RegisterServer(TRUE, FALSE);
|
|
|
|
// Register as Service
|
|
if (lstrcmpi(lpszToken, _T("Service"))==0)
|
|
return _Module.RegisterServer(TRUE, TRUE);
|
|
|
|
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)
|
|
{
|
|
return lRes;
|
|
}
|
|
|
|
CRegKey key;
|
|
|
|
lRes = key.Open(keyAppID, szServiceAppID, KEY_READ);
|
|
|
|
if (lRes != ERROR_SUCCESS)
|
|
{
|
|
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;
|
|
}
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: SetAclForComObject
|
|
//
|
|
// Synopsis: method for providing only the Local System and Admins rights
|
|
// to access the COM object
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: MKarki 11/15/2001 Created
|
|
// serdarun 04/07/2002 remove admin from list
|
|
//----------------------------------------------------------------
|
|
DWORD
|
|
SetAclForComObject (
|
|
/*[in]*/ PSECURITY_DESCRIPTOR pSD,
|
|
/*[out*/ PACL *ppacl
|
|
)
|
|
{
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
int cbAcl = 0;
|
|
PACL pacl = NULL;
|
|
PSID psidLocalSystemSid = NULL;
|
|
SID_IDENTIFIER_AUTHORITY siaLocalSystemSidAuthority = SECURITY_NT_AUTHORITY;
|
|
|
|
CSATraceFunc objTraceFunc ("SetAclFromComObject");
|
|
|
|
do
|
|
{
|
|
if (NULL == pSD)
|
|
{
|
|
SATraceString ("SetAclFromComObject - invalid parameter passed in");
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Create a SID for Local System account
|
|
//
|
|
BOOL bRetVal = AllocateAndInitializeSid (
|
|
&siaLocalSystemSidAuthority,
|
|
1,
|
|
SECURITY_LOCAL_SYSTEM_RID,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
&psidLocalSystemSid
|
|
);
|
|
if (!bRetVal)
|
|
{
|
|
dwError = GetLastError ();
|
|
SATraceFailure ("SetAclFromComObject:AllocateAndInitializeSid (LOCAL SYSTEM) failed", dwError);
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Calculate the length of required ACL buffer
|
|
// with 1 ACE
|
|
//
|
|
cbAcl = sizeof (ACL)
|
|
+ sizeof (ACCESS_ALLOWED_ACE)
|
|
+ GetLengthSid( psidLocalSystemSid );
|
|
|
|
pacl = (PACL) LocalAlloc ( 0, cbAcl );
|
|
if (NULL == pacl)
|
|
{
|
|
dwError = ERROR_OUTOFMEMORY;
|
|
SATraceFailure ("SetAclFromComObject::LocalAlloc failed:", dwError);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// initialize the ACl now
|
|
//
|
|
bRetVal =InitializeAcl(
|
|
pacl,
|
|
cbAcl,
|
|
ACL_REVISION2
|
|
);
|
|
if (!bRetVal)
|
|
{
|
|
dwError = GetLastError();
|
|
SATraceFailure ("SetAclFromComObject::InitializeAcl failed:", dwError);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Add ACE with EVENT_ALL_ACCESS for Local System account
|
|
//
|
|
bRetVal = AddAccessAllowedAce (
|
|
pacl,
|
|
ACL_REVISION2,
|
|
COM_RIGHTS_EXECUTE,
|
|
psidLocalSystemSid
|
|
);
|
|
if (!bRetVal)
|
|
{
|
|
dwError = GetLastError();
|
|
SATraceFailure ("SetAclFromComObject::AddAccessAllowedAce (LOCAL SYSTEM) failed:", dwError);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Set the ACL which allows EVENT_ALL_ACCESS for all users and
|
|
// Local System to the security descriptor.
|
|
bRetVal = SetSecurityDescriptorDacl (
|
|
pSD,
|
|
TRUE,
|
|
pacl,
|
|
FALSE
|
|
);
|
|
if (!bRetVal)
|
|
{
|
|
dwError = GetLastError();
|
|
SATraceFailure ("SetAclFromComObject::SetSecurityDescriptorDacl failed:", dwError);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// success
|
|
//
|
|
}
|
|
while (false);
|
|
|
|
//
|
|
// in case of error, cleanup
|
|
//
|
|
if (dwError)
|
|
{
|
|
if ( pacl )
|
|
{
|
|
LocalFree ( pacl );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ppacl = pacl;
|
|
}
|
|
|
|
|
|
//
|
|
// free up resources now
|
|
//
|
|
if ( psidLocalSystemSid ) {FreeSid ( psidLocalSystemSid );}
|
|
|
|
return (dwError);
|
|
|
|
}//End of SetAclFromComObject method
|
|
|
|
|
|
|