mirror of
https://github.com/monero-project/monero.git
synced 2024-11-17 16:27:39 +00:00
326 lines
11 KiB
C++
326 lines
11 KiB
C++
// Copyright (c) 2014, The Monero Project
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
// materials provided with the distribution.
|
|
//
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
// used to endorse or promote products derived from this software without specific
|
|
// prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Parts of this file are originally copyright (c) 2006-2013, Andrey N. Sabelnikov
|
|
|
|
#ifndef _SERVICE_IMPL_BASE_H_
|
|
#define _SERVICE_IMPL_BASE_H_
|
|
|
|
#pragma comment(lib, "advapi32.lib")
|
|
|
|
|
|
namespace epee
|
|
{
|
|
class service_impl_base {
|
|
public:
|
|
service_impl_base();
|
|
virtual ~service_impl_base();
|
|
|
|
virtual const char *get_name() = 0;
|
|
virtual const char *get_caption() = 0;
|
|
virtual const char *get_description() = 0;
|
|
|
|
bool run_service();
|
|
virtual bool install();
|
|
virtual bool remove();
|
|
virtual bool init();
|
|
void set_control_accepted(unsigned controls);
|
|
void set_status(unsigned state, unsigned pending = 0);
|
|
unsigned get_control_accepted();
|
|
|
|
private:
|
|
virtual void service_main() = 0;
|
|
virtual unsigned service_handler(unsigned control, unsigned event_code,
|
|
void *pdata) = 0;
|
|
//-------------------------------------------------------------------------
|
|
static service_impl_base*& instance();
|
|
//-------------------------------------------------------------------------
|
|
static DWORD __stdcall _service_handler(DWORD control, DWORD event,
|
|
void *pdata, void *pcontext);
|
|
static void __stdcall service_entry(DWORD argc, char **pargs);
|
|
virtual SERVICE_FAILURE_ACTIONSA* get_failure_actions();
|
|
|
|
private:
|
|
SC_HANDLE m_manager;
|
|
SC_HANDLE m_service;
|
|
SERVICE_STATUS_HANDLE m_status_handle;
|
|
DWORD m_accepted_control;
|
|
};
|
|
|
|
inline service_impl_base::service_impl_base() {
|
|
m_manager = 0;
|
|
m_service = 0;
|
|
m_status_handle = 0;
|
|
m_accepted_control = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN
|
|
| SERVICE_ACCEPT_PAUSE_CONTINUE;
|
|
|
|
instance() = this;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline service_impl_base::~service_impl_base() {
|
|
if (m_service) {
|
|
::CloseServiceHandle(m_service);
|
|
}
|
|
m_service = 0;
|
|
if (m_manager) {
|
|
::CloseServiceHandle(m_manager);
|
|
}
|
|
m_manager = 0;
|
|
instance() = 0;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline service_impl_base*& service_impl_base::instance() {
|
|
static service_impl_base *pservice = NULL;
|
|
return pservice;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
bool service_impl_base::install() {
|
|
CHECK_AND_ASSERT(!m_service, false);
|
|
const char *psz_descr = get_description();
|
|
SERVICE_FAILURE_ACTIONSA* fail_acts = get_failure_actions();
|
|
|
|
char sz_path[MAX_PATH];
|
|
::GetModuleFileNameA(0, sz_path, sizeof(sz_path));
|
|
::GetShortPathNameA(sz_path, sz_path, sizeof(sz_path));
|
|
|
|
while (TRUE) {
|
|
if (!m_manager) {
|
|
m_manager = ::OpenSCManager(NULL, NULL, GENERIC_ALL);
|
|
if (!m_manager) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to OpenSCManager(), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
m_service = ::CreateServiceA(m_manager, get_name(), get_caption(),
|
|
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START,
|
|
SERVICE_ERROR_IGNORE, sz_path, 0, 0, 0, 0, 0);
|
|
if (!m_service) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to CreateService(), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
|
|
if (psz_descr) {
|
|
SERVICE_DESCRIPTIONA sd = { (char*) psz_descr };
|
|
if (!::ChangeServiceConfig2A(m_service, SERVICE_CONFIG_DESCRIPTION,
|
|
&sd)) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to ChangeServiceConfig2(SERVICE_CONFIG_DESCRIPTION), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fail_acts) {
|
|
if (!::ChangeServiceConfig2A(m_service, SERVICE_CONFIG_FAILURE_ACTIONS,
|
|
fail_acts)) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to ChangeServiceConfig2(SERVICE_CONFIG_FAILURE_ACTIONS), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
LOG_PRINT("Installed succesfully.", LOG_LEVEL_0);
|
|
return true;
|
|
}
|
|
LOG_PRINT("Failed to install.", LOG_LEVEL_0);
|
|
return false;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
bool service_impl_base::remove() {
|
|
CHECK_AND_ASSERT(!m_service, false);
|
|
|
|
while (TRUE) {
|
|
if (!m_manager) {
|
|
m_manager = ::OpenSCManager(0, 0, GENERIC_ALL);
|
|
if (!m_manager) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to OpenSCManager(), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!m_service) {
|
|
m_service = ::OpenServiceA(m_manager, get_name(), SERVICE_STOP | DELETE);
|
|
if (!m_service) {
|
|
int err = GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to OpenService(), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
|
|
SERVICE_STATUS status = { };
|
|
if (!::ControlService(m_service, SERVICE_CONTROL_STOP, &status)) {
|
|
int err = ::GetLastError();
|
|
if (err == ERROR_SHUTDOWN_IN_PROGRESS)
|
|
continue;
|
|
else if (err != ERROR_SERVICE_NOT_ACTIVE) {
|
|
LOG_ERROR(
|
|
"Failed to ControlService(SERVICE_CONTROL_STOP), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!::DeleteService(m_service)) {
|
|
int err = ::GetLastError();
|
|
LOG_ERROR(
|
|
"Failed to ControlService(SERVICE_CONTROL_STOP), last err="
|
|
<< log_space::get_win32_err_descr(err));
|
|
break;
|
|
}
|
|
|
|
LOG_PRINT("Removed successfully.", LOG_LEVEL_0);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
bool service_impl_base::init() {
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
bool service_impl_base::run_service() {
|
|
CHECK_AND_ASSERT(!m_service, false);
|
|
|
|
long error_code = 0;
|
|
|
|
SERVICE_TABLE_ENTRYA service_table[2];
|
|
ZeroMemory(&service_table, sizeof(service_table));
|
|
|
|
service_table->lpServiceName = (char*) get_name();
|
|
service_table->lpServiceProc = service_entry;
|
|
|
|
LOG_PRINT("[+] Start service control dispatcher for \"" << get_name() << "\"",
|
|
LOG_LEVEL_1);
|
|
|
|
error_code = 1;
|
|
BOOL res = ::StartServiceCtrlDispatcherA(service_table);
|
|
if (!res) {
|
|
int err = GetLastError();
|
|
LOG_PRINT(
|
|
"[+] Error starting service control dispatcher, err="
|
|
<< log_space::get_win32_err_descr(err), LOG_LEVEL_1);
|
|
return false;
|
|
} else {
|
|
LOG_PRINT("[+] End service control dispatcher for \"" << get_name() << "\"",
|
|
LOG_LEVEL_1);
|
|
}
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline DWORD __stdcall service_impl_base::_service_handler(DWORD control,
|
|
DWORD event, void *pdata, void *pcontext) {
|
|
CHECK_AND_ASSERT(pcontext, ERROR_CALL_NOT_IMPLEMENTED);
|
|
|
|
service_impl_base *pservice = (service_impl_base*) pcontext;
|
|
return pservice->service_handler(control, event, pdata);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
void __stdcall service_impl_base::service_entry(DWORD argc, char **pargs) {
|
|
service_impl_base *pme = instance();
|
|
LOG_PRINT("instance: " << pme, LOG_LEVEL_4);
|
|
if (!pme) {
|
|
LOG_ERROR("Error: at service_entry() pme = NULL");
|
|
return;
|
|
}
|
|
pme->m_status_handle = ::RegisterServiceCtrlHandlerExA(pme->get_name(),
|
|
_service_handler, pme);
|
|
|
|
pme->set_status(SERVICE_RUNNING);
|
|
pme->service_main();
|
|
pme->set_status(SERVICE_STOPPED);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline
|
|
void service_impl_base::set_status(unsigned state, unsigned pending) {
|
|
if (!m_status_handle)
|
|
return;
|
|
|
|
SERVICE_STATUS status = { 0 };
|
|
status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
|
|
status.dwCurrentState = state;
|
|
status.dwControlsAccepted = m_accepted_control;
|
|
/*status.dwWin32ExitCode = NO_ERROR;
|
|
status.dwServiceSpecificExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
|
|
status.dwCheckPoint = 0;
|
|
status.dwWaitHint = 0;
|
|
|
|
status.dwCurrentState = state;*/
|
|
|
|
if (state == SERVICE_START_PENDING || state == SERVICE_STOP_PENDING
|
|
|| state == SERVICE_CONTINUE_PENDING || state == SERVICE_PAUSE_PENDING) {
|
|
status.dwWaitHint = 2000;
|
|
status.dwCheckPoint = pending;
|
|
}
|
|
::SetServiceStatus(m_status_handle, &status);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
inline
|
|
void service_impl_base::set_control_accepted(unsigned controls) {
|
|
m_accepted_control = controls;
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
inline
|
|
unsigned service_impl_base::get_control_accepted() {
|
|
return m_accepted_control;
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
inline SERVICE_FAILURE_ACTIONSA* service_impl_base::get_failure_actions() {
|
|
// first 3 failures in 30 minutes. Service will be restarted.
|
|
// do nothing for next failures
|
|
static SC_ACTION sa[] = { { SC_ACTION_RESTART, 3 * 1000 }, {
|
|
SC_ACTION_RESTART, 3 * 1000 }, { SC_ACTION_RESTART, 3 * 1000 }, {
|
|
SC_ACTION_NONE, 0 } };
|
|
|
|
static SERVICE_FAILURE_ACTIONSA sfa = { 1800, // interval for failures counter - 30 min
|
|
"", NULL, 4, (SC_ACTION*) &sa };
|
|
|
|
// TODO: refactor this code, really unsafe!
|
|
return &sfa;
|
|
}
|
|
}
|
|
|
|
#endif //_SERVICE_IMPL_BASE_H_
|