#include "service.h"
#include "tlog.h"
#include "tconvert.h"
#include "tfilepath.h"
#ifdef _MSC_VER
#pragma warning(disable : 4996)
#endif
#ifdef _WIN32
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <tchar.h>
#else
#include <string.h>
#include <errno.h>
#endif
#define SZDEPENDENCIES ""
#ifdef _WIN32
//------------------------------------------------------------------------------
static LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize) {
DWORD dwRet;
LPTSTR lpszTemp = NULL;
dwRet = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_ARGUMENT_ARRAY,
NULL, GetLastError(), LANG_NEUTRAL, (LPTSTR)&lpszTemp, 0, NULL);
// supplied buffer is not long enough
if (!dwRet || ((long)dwSize < (long)dwRet + 14))
lpszBuf[0] = TEXT('\0');
else {
lpszTemp[lstrlen(lpszTemp) - 2] =
TEXT('\0'); // remove cr and newline character
_stprintf(lpszBuf, TEXT("%s (0x%x)"), lpszTemp, GetLastError());
}
if (lpszTemp) LocalFree((HLOCAL)lpszTemp);
return lpszBuf;
}
#endif // _WIN32
//------------------------------------------------------------------------------
std::string getLastErrorText() {
std::string errText;
#ifdef _WIN32
char errBuff[256];
errText = GetLastErrorText(errBuff, sizeof(errBuff));
#else
errText = strerror(errno);
#endif
return errText;
}
//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================
class TService::Imp {
public:
Imp() {}
#ifdef _WIN32
static void WINAPI serviceMain(DWORD dwArgc, LPTSTR *lpszArgv);
static void WINAPI serviceCtrl(DWORD dwCtrlCode);
static BOOL WINAPI controlHandler(DWORD dwCtrlType);
static bool reportStatusToSCMgr(long currentState, long win32ExitCode,
long waitHint);
#endif
std::string m_name;
std::string m_displayName;
static bool m_console;
#ifdef _WIN32
static SERVICE_STATUS_HANDLE m_hService;
static SERVICE_STATUS m_ssStatus; // current status of the service
static DWORD m_dwErr;
#endif
};
#ifdef _WIN32
SERVICE_STATUS_HANDLE TService::Imp::m_hService = 0;
SERVICE_STATUS TService::Imp::m_ssStatus;
DWORD TService::Imp::m_dwErr = 0;
#endif
bool TService::Imp::m_console = false;
//------------------------------------------------------------------------------
TService::TService(const std::string &name, const std::string &displayName)
: m_imp(new Imp) {
m_imp->m_name = name;
m_imp->m_displayName = displayName;
m_instance = this;
}
//------------------------------------------------------------------------------
TService::~TService() {}
//------------------------------------------------------------------------------
TService *TService::instance() { return m_instance; }
//------------------------------------------------------------------------------
TService *TService::m_instance = 0;
//------------------------------------------------------------------------------
void TService::setStatus(Status status, long exitCode, long waitHint) {
#ifdef _WIN32
if (!isRunningAsConsoleApp())
TService::Imp::reportStatusToSCMgr(status, exitCode, waitHint);
else {
if (status == Stopped) exit(1);
}
#else
if (status == Stopped) exit(1);
#endif
}
//------------------------------------------------------------------------------
std::string TService::getName() const { return m_imp->m_name; }
//------------------------------------------------------------------------------
std::string TService::getDisplayName() const { return m_imp->m_displayName; }
//------------------------------------------------------------------------------
#ifdef _WIN32
void WINAPI TService::Imp::serviceCtrl(DWORD dwCtrlCode) {
// Handle the requested control code.
//
switch (dwCtrlCode) {
// Stop the service.
//
// SERVICE_STOP_PENDING should be reported before
// setting the Stop Event - hServerStopEvent - in
// ServiceStop(). This avoids a race condition
// which may result in a 1053 - The Service did not respond...
// error.
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN: {
TService::Imp::reportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR,
3000 /*1*/ /*0*/);
TService::instance()->onStop();
TService::Imp::reportStatusToSCMgr(SERVICE_STOPPED, NO_ERROR, 3000);
return;
}
// Update the service status.
//
case SERVICE_CONTROL_INTERROGATE:
break;
// invalid control code
//
default:
break;
}
reportStatusToSCMgr(m_ssStatus.dwCurrentState, NO_ERROR, 0);
}
//------------------------------------------------------------------------------
void WINAPI TService::Imp::serviceMain(DWORD dwArgc, LPTSTR *lpszArgv) {
// register our service control handler:
//
m_hService = RegisterServiceCtrlHandler(
TService::instance()->getName().c_str(), TService::Imp::serviceCtrl);
if (m_hService == 0) goto cleanup;
// SERVICE_STATUS members that don't change in example
//
m_ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
m_ssStatus.dwServiceSpecificExitCode = 0;
// report the status to the service control manager.
//
if (!reportStatusToSCMgr(SERVICE_START_PENDING, // service state
NO_ERROR, // exit code
3000)) // wait hint
goto cleanup;
// AGGIUNGERE INIZIALIZZAZIONE QUI
if (!reportStatusToSCMgr(SERVICE_RUNNING, // service state
NO_ERROR, // exit code
0)) // wait hint
goto cleanup;
TService::instance()->onStart(dwArgc, lpszArgv);
cleanup:
// try to report the stopped status to the service control manager.
//
if (m_hService) reportStatusToSCMgr(SERVICE_STOPPED, m_dwErr, 0);
return;
}
//------------------------------------------------------------------------------
//
// TService::Imp::controlHandler( DWORD dwCtrlType )
//
// PURPOSE: Handled console control events
//
// PARAMETERS:
// dwCtrlType - type of control event
//
// RETURN VALUE:
// True - handled
// False - unhandled
//
// COMMENTS:
//
BOOL WINAPI TService::Imp::controlHandler(DWORD dwCtrlType) {
switch (dwCtrlType) {
case CTRL_CLOSE_EVENT:
case CTRL_LOGOFF_EVENT:
case CTRL_SHUTDOWN_EVENT:
case CTRL_BREAK_EVENT: // use Ctrl+C or Ctrl+Break to simulate
case CTRL_C_EVENT: // SERVICE_CONTROL_STOP in debug mode
_tprintf(TEXT("Stopping %s.\n"),
TService::instance()->getDisplayName().c_str());
TService::instance()->onStop();
return TRUE;
break;
}
return FALSE;
}
//------------------------------------------------------------------------------
//
// FUNCTION: ReportStatusToSCMgr()
//
// PURPOSE: Sets the current status of the service and
// reports it to the Service Control Manager
//
// PARAMETERS:
// dwCurrentState - the state of the service
// dwWin32ExitCode - error code to report
// dwWaitHint - worst case estimate to next checkpoint
//
// RETURN VALUE:
// TRUE - success
// FALSE - failure
//
// COMMENTS:
//
//------------------------------------------------------------------------------
bool TService::Imp::reportStatusToSCMgr(long currentState, long win32ExitCode,
long waitHint) {
/*
SERVICE_STATUS srvStatus; // Declare a SERVICE_STATUS structure,
and fill it in
srvStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; // We're a service
running in our own process
// Set the state of the service from the argument, and save it away
// for future use
_dwPrevState=_dwCurrState;
srvStatus.dwCurrentState = _dwCurrState = dwState;
// Which commands will we accept from the SCM? All the common ones...
srvStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_PAUSE_CONTINUE |
SERVICE_ACCEPT_SHUTDOWN;
srvStatus.dwWin32ExitCode = dwExitCode; // Set the Win32 exit code for
the service
srvStatus.dwServiceSpecificExitCode = 0; // Set the service-specific exit
code
srvStatus.dwCheckPoint = dwProgress; // Set the checkpoint value
srvStatus.dwWaitHint = __WAIT_TIME_FOR_SERVICE; // 3 second timeout for
waits
return SetServiceStatus( _hService, &srvStatus); // pass the structure to the
SCM
*/
static DWORD dwCheckPoint = 1;
BOOL fResult = true;
if (!m_console) // when running as a console application we don't report to
// the SCM
{
if (currentState == SERVICE_START_PENDING)
m_ssStatus.dwControlsAccepted = 0;
else
m_ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_PAUSE_CONTINUE |
SERVICE_ACCEPT_SHUTDOWN;
;
m_ssStatus.dwCurrentState = currentState;
m_ssStatus.dwWin32ExitCode = win32ExitCode;
m_ssStatus.dwWaitHint = waitHint;
if ((currentState == SERVICE_RUNNING) || (currentState == SERVICE_STOPPED))
m_ssStatus.dwCheckPoint = 0;
else
m_ssStatus.dwCheckPoint = dwCheckPoint++;
// Report the status of the service to the service control manager.
//
if (!(fResult = SetServiceStatus(m_hService, &m_ssStatus))) {
TService::addToMessageLog(QString("Failed to set the service status"));
}
}
return !!fResult;
}
#endif
//------------------------------------------------------------------------------
void TService::run(int argc, char *argv[], bool console) {
m_imp->m_console = console;
/*
#ifdef _DEBUG
DebugBreak();
#endif
*/
#ifdef _WIN32
if (console) {
_tprintf(TEXT("Starting %s.\n"),
TService::instance()->getDisplayName().c_str());
SetConsoleCtrlHandler(TService::Imp::controlHandler, TRUE);
TService::instance()->onStart(argc, argv);
} else {
SERVICE_TABLE_ENTRY dispatchTable[2];
std::string name = TService::instance()->getName().c_str();
dispatchTable[0].lpServiceName = (char *)name.c_str();
dispatchTable[0].lpServiceProc =
(LPSERVICE_MAIN_FUNCTION)TService::Imp::serviceMain;
dispatchTable[1].lpServiceName = NULL;
dispatchTable[1].lpServiceProc = NULL;
if (!StartServiceCtrlDispatcher(dispatchTable))
TService::addToMessageLog(QString(TEXT("Service start failed.")));
}
#else
TService::instance()->onStart(argc, argv);
#endif
}
//------------------------------------------------------------------------------
void TService::start(const std::string &name) {}
//------------------------------------------------------------------------------
void TService::stop(const std::string &name) {}
//------------------------------------------------------------------------------
bool TService::isRunningAsConsoleApp() const { return m_imp->m_console; }
//------------------------------------------------------------------------------
void TService::install(const std::string &name, const std::string &displayName,
const TFilePath &appPath) {
#ifdef _WIN32
SC_HANDLE schService;
SC_HANDLE schSCManager;
schSCManager = OpenSCManager(NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS); // access required
if (schSCManager) {
schService = CreateService(
schSCManager, // SCManager database
name.c_str(), // name of service
displayName.c_str(), // name to display
SERVICE_ALL_ACCESS, // desired access
SERVICE_WIN32_OWN_PROCESS, // service type
SERVICE_DEMAND_START, // start type
SERVICE_ERROR_NORMAL, // error control type
::to_string(appPath.getWideString()).c_str(), // service's binary
NULL, // no load ordering group
NULL, // no tag identifier
TEXT(SZDEPENDENCIES), // dependencies
NULL, // LocalSystem account
NULL); // no password
if (schService) {
_tprintf(TEXT("%s installed.\n"), displayName.c_str());
CloseServiceHandle(schService);
} else {
_tprintf(TEXT("CreateService failed - %s\n"), getLastErrorText().c_str());
}
CloseServiceHandle(schSCManager);
} else
_tprintf(TEXT("OpenSCManager failed - %s\n"), getLastErrorText().c_str());
#endif
}
//------------------------------------------------------------------------------
void TService::remove(const std::string &name) {
#ifdef _WIN32
std::string displayName = name;
SC_HANDLE schService;
SC_HANDLE schSCManager;
schSCManager = OpenSCManager(NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS); // access required
if (schSCManager) {
schService = OpenService(schSCManager, name.c_str(), SERVICE_ALL_ACCESS);
if (schService) {
SERVICE_STATUS ssStatus; // current status of the service
// try to stop the service
if (ControlService(schService, SERVICE_CONTROL_STOP, &ssStatus)) {
_tprintf(TEXT("Stopping %s."), displayName.c_str());
Sleep(1000);
while (QueryServiceStatus(schService, &ssStatus)) {
if (ssStatus.dwCurrentState == SERVICE_STOP_PENDING) {
_tprintf(TEXT("."));
Sleep(1000);
} else
break;
}
if (ssStatus.dwCurrentState == SERVICE_STOPPED)
_tprintf(TEXT("\n%s stopped.\n"), displayName.c_str());
else
_tprintf(TEXT("\n%s failed to stop.\n"), displayName.c_str());
}
// now remove the service
if (DeleteService(schService))
_tprintf(TEXT("%s removed.\n"), displayName.c_str());
else
_tprintf(TEXT("DeleteService failed - %s\n"),
getLastErrorText().c_str());
CloseServiceHandle(schService);
} else
_tprintf(TEXT("OpenService failed - %s\n"), getLastErrorText().c_str());
CloseServiceHandle(schSCManager);
} else
_tprintf(TEXT("OpenSCManager failed - %s\n"), getLastErrorText().c_str());
#endif
}
//------------------------------------------------------------------------------
void TService::addToMessageLog(const QString &msg) {
addToMessageLog(msg.toStdString());
}
void TService::addToMessageLog(const std::string &msg) {
#ifdef _WIN32
TCHAR szMsg[256];
HANDLE hEventSource;
LPCTSTR lpszStrings[2];
if (!TService::Imp::m_console) {
TService::Imp::m_dwErr = GetLastError();
// Use event logging to log the error.
//
hEventSource =
RegisterEventSource(NULL, TService::instance()->getName().c_str());
_stprintf(szMsg, TEXT("%s error: %d"),
TService::instance()->getName().c_str(), TService::Imp::m_dwErr);
lpszStrings[0] = szMsg;
lpszStrings[1] = msg.c_str();
if (hEventSource != NULL) {
ReportEvent(hEventSource, // handle of event source
EVENTLOG_ERROR_TYPE, // event type
0, // event category
0, // event ID
NULL, // current user's SID
2, // strings in lpszStrings
0, // no bytes of raw data
lpszStrings, // array of error strings
NULL); // no raw data
(VOID) DeregisterEventSource(hEventSource);
}
} else {
std::cout << msg.c_str();
}
#else
if (!TService::Imp::m_console) {
QString str(msg.c_str());
TSysLog::error(str);
} else {
std::cout << msg.c_str();
}
#endif
}