phoenix/ServiceExample
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formatting changes

Browse Source
This commit is contained in:
kdeng00
2020-12-05 23:20:40 -05:00
parent 37af458d5f
commit 12450e2f0e
6 changed files with 559 additions and 559 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ServiceExample/Main.cpp
+83 -83
View File
@@ -17,7 +17,7 @@
template<typename Handle = SC_HANDLE, typename Char = wchar_t> template<typename Handle = SC_HANDLE, typename Char = wchar_t>
VOID ServiceInstall(void); VOID ServiceInstall(void);
template<typename TSTR = LPTSTR, typename CTSTR = LPCTSTR, template<typename TSTR = LPTSTR, typename CTSTR = LPCTSTR,
typename Handle = HANDLE, typename Char = TCHAR> typename Handle = HANDLE, typename Char = TCHAR>
VOID ServiceReportEvent(LPTSTR); VOID ServiceReportEvent(LPTSTR);
std::shared_ptr<models::ServiceInfo<>> service_info(new models::ServiceInfo<>(L"Service Example")); std::shared_ptr<models::ServiceInfo<>> service_info(new models::ServiceInfo<>(L"Service Example"));
@@ -27,32 +27,32 @@ std::shared_ptr<models::ServiceInfo<>> service_info(new models::ServiceInfo<>(L"
int _tmain(int argc, TCHAR *argv[]) int _tmain(int argc, TCHAR *argv[])
{ {
std::cout << "ServiceExample\n"; std::cout << "ServiceExample\n";
if (lstrcmpi(argv[1], TEXT("install")) == 0) if (lstrcmpi(argv[1], TEXT("install")) == 0)
{ {
ServiceInstall(); ServiceInstall();
return -1; return -1;
} }
SERVICE_TABLE_ENTRY SERVICETABLE[] = SERVICE_TABLE_ENTRY SERVICETABLE[] =
{ {
{ service_info->service_name, { service_info->service_name,
(LPSERVICE_MAIN_FUNCTION) (LPSERVICE_MAIN_FUNCTION)
service::ServiceEntryPoint::service_main_start }, service::ServiceEntryPoint::service_main_start },
{ nullptr, nullptr }, { nullptr, nullptr },
}; };
if (!StartServiceCtrlDispatcher(SERVICETABLE)) if (!StartServiceCtrlDispatcher(SERVICETABLE))
{ {
auto func = reinterpret_cast<LPTSTR>(TEXT("StartServiceCtrlDispatcher")); auto func = reinterpret_cast<LPTSTR>(TEXT("StartServiceCtrlDispatcher"));
ServiceReportEvent(func); ServiceReportEvent(func);
} }
return 0; return 0;
} }
@@ -60,89 +60,89 @@ int _tmain(int argc, TCHAR *argv[])
template<typename Handle, typename Char> template<typename Handle, typename Char>
VOID ServiceInstall() VOID ServiceInstall()
{ {
Char buffer[MAX_PATH]; Char buffer[MAX_PATH];
if (!GetModuleFileName(nullptr, buffer, MAX_PATH)) if (!GetModuleFileName(nullptr, buffer, MAX_PATH))
{ {
std::cout << "Cannot install service " << GetLastError() << "\n"; std::cout << "Cannot install service " << GetLastError() << "\n";
return; return;
} }
// Get a handle to the SCM database. // Get a handle to the SCM database.
Handle schSCManager = OpenSCManager( Handle schSCManager = OpenSCManager(
nullptr, // local computer nullptr, // local computer
nullptr, // ServicesActive database nullptr, // ServicesActive database
SC_MANAGER_ALL_ACCESS); // full access rights SC_MANAGER_ALL_ACCESS); // full access rights
if (nullptr == schSCManager) if (nullptr == schSCManager)
{ {
std::cout << "OpenSCManager failed " << GetLastError() << "\n"; std::cout << "OpenSCManager failed " << GetLastError() << "\n";
return; return;
} }
// Create the service // Create the service
Handle schService = CreateService( Handle schService = CreateService(
schSCManager, // SCM database schSCManager, // SCM database
service_info->service_name, // name of service service_info->service_name, // name of service
service_info->service_name, // service name to display service_info->service_name, // service name to display
SERVICE_ALL_ACCESS, // desired access SERVICE_ALL_ACCESS, // desired access
SERVICE_WIN32_OWN_PROCESS, // service type SERVICE_WIN32_OWN_PROCESS, // service type
SERVICE_DEMAND_START, // start type SERVICE_DEMAND_START, // start type
SERVICE_ERROR_NORMAL, // error control type SERVICE_ERROR_NORMAL, // error control type
buffer, // path to service's binary buffer, // path to service's binary
nullptr, // no load ordering group nullptr, // no load ordering group
nullptr, // no tag identifier nullptr, // no tag identifier
nullptr, // no dependencies nullptr, // no dependencies
nullptr, // LocalSystem account nullptr, // LocalSystem account
nullptr); // no password nullptr); // no password
if (schService == nullptr) if (schService == nullptr)
{ {
std::cout << "CreateService failed " << GetLastError() << "\n"; std::cout << "CreateService failed " << GetLastError() << "\n";
CloseServiceHandle(schSCManager); CloseServiceHandle(schSCManager);
return; return;
} }
else else
{ {
std::cout << "Service installed successfully\n"; std::cout << "Service installed successfully\n";
} }
CloseServiceHandle(schService); CloseServiceHandle(schService);
CloseServiceHandle(schSCManager); CloseServiceHandle(schSCManager);
} }
template<typename TStr, typename CTStr, template<typename TStr, typename CTStr,
typename Handle, typename Char> typename Handle, typename Char>
VOID ServiceReportEvent(LPTSTR szFunction) VOID ServiceReportEvent(LPTSTR szFunction)
{ {
CTStr lpszStrings[2]; CTStr lpszStrings[2];
Char Buffer[80]; Char Buffer[80];
Handle hEventSource = RegisterEventSource(nullptr, service_info->service_name); Handle hEventSource = RegisterEventSource(nullptr, service_info->service_name);
if (nullptr != hEventSource) if (nullptr != hEventSource)
{ {
StringCchPrintf(Buffer, 80, TEXT("%s failed with %d"), szFunction, GetLastError()); StringCchPrintf(Buffer, 80, TEXT("%s failed with %d"), szFunction, GetLastError());
lpszStrings[0] = service_info->service_name; lpszStrings[0] = service_info->service_name;
lpszStrings[1] = Buffer; lpszStrings[1] = Buffer;
ReportEvent(hEventSource, // event log handle ReportEvent(hEventSource, // event log handle
EVENTLOG_ERROR_TYPE, // event type EVENTLOG_ERROR_TYPE, // event type
0, // event category 0, // event category
SERVICE_ERROR_NORMAL, // event identifier SERVICE_ERROR_NORMAL, // event identifier
nullptr, // no security identifier nullptr, // no security identifier
2, // size of lpszStrings array 2, // size of lpszStrings array
0, // no binary data 0, // no binary data
lpszStrings, // array of strings lpszStrings, // array of strings
nullptr); // no binary data nullptr); // no binary data
DeregisterEventSource(hEventSource); DeregisterEventSource(hEventSource);
} }
} }
ServiceExample/Models.h
+22 -22
View File
@@ -6,29 +6,29 @@
namespace models namespace models
{ {
template<typename Str = std::wstring, template<typename Str = std::wstring,
typename Char = wchar_t, typename Char = wchar_t,
typename Status = SERVICE_STATUS, typename Status = SERVICE_STATUS,
typename StatusHandle = SERVICE_STATUS_HANDLE, typename StatusHandle = SERVICE_STATUS_HANDLE,
typename Handle = HANDLE> typename Handle = HANDLE>
class ServiceInfo class ServiceInfo
{ {
public: public:
ServiceInfo() ServiceInfo()
{ {
service_stop_event = INVALID_HANDLE_VALUE; service_stop_event = INVALID_HANDLE_VALUE;
} }
ServiceInfo(std::wstring &&name) : ServiceInfo(std::wstring &&name) :
service_name(const_cast<wchar_t*>(name.c_str())) service_name(const_cast<wchar_t*>(name.c_str()))
{ {
service_stop_event = INVALID_HANDLE_VALUE; service_stop_event = INVALID_HANDLE_VALUE;
} }
wchar_t *service_name; wchar_t *service_name;
Status service_status; Status service_status;
StatusHandle service_handle; StatusHandle service_handle;
Handle service_stop_event; Handle service_stop_event;
}; };
} }
#endif #endif
ServiceExample/ServiceControlHandler.hpp
+55 -55
View File
@@ -11,72 +11,72 @@
namespace service namespace service
{ {
class ServiceControlHandler class ServiceControlHandler
{ {
public: public:
template<typename D = DWORD, template<typename D = DWORD,
typename Obj = models::ServiceInfo<>, typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static VOID WINAPI ServiceCtrlHandler(D ctrlCode) static VOID WINAPI ServiceCtrlHandler(D ctrlCode)
{ {
extern Ptr service_info; extern Ptr service_info;
switch (ctrlCode) switch (ctrlCode)
{ {
case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_STOP:
ReportServiceStatus<D>(SERVICE_STOP_PENDING, NO_ERROR, 0); ReportServiceStatus<D>(SERVICE_STOP_PENDING, NO_ERROR, 0);
SetEvent(service_info->service_stop_event); SetEvent(service_info->service_stop_event);
ReportServiceStatus<D>(service_info->service_status.dwCurrentState, NO_ERROR, 0); ReportServiceStatus<D>(service_info->service_status.dwCurrentState, NO_ERROR, 0);
return; return;
case SERVICE_CONTROL_INTERROGATE: case SERVICE_CONTROL_INTERROGATE:
break; break;
default: default:
break; break;
} }
} }
template<typename D = DWORD, template<typename D = DWORD,
typename Obj = models::ServiceInfo<>, typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static VOID ReportServiceStatus(D dwCurrentState, static VOID ReportServiceStatus(D dwCurrentState,
D dwWin32ExitCode, D dwWin32ExitCode,
D dwWaitHint) D dwWaitHint)
{ {
extern Ptr service_info; extern Ptr service_info;
static D dwCheckPoint = 1; static D dwCheckPoint = 1;
service_info->service_status.dwCurrentState = dwCurrentState; service_info->service_status.dwCurrentState = dwCurrentState;
service_info->service_status.dwWin32ExitCode = dwWin32ExitCode; service_info->service_status.dwWin32ExitCode = dwWin32ExitCode;
service_info->service_status.dwWaitHint = dwWaitHint; service_info->service_status.dwWaitHint = dwWaitHint;
if (dwCurrentState == SERVICE_START_PENDING) if (dwCurrentState == SERVICE_START_PENDING)
{ {
service_info->service_status.dwControlsAccepted = 0; service_info->service_status.dwControlsAccepted = 0;
} }
else else
{ {
service_info->service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP; service_info->service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
} }
if ((dwCurrentState == SERVICE_RUNNING) || if ((dwCurrentState == SERVICE_RUNNING) ||
(dwCurrentState == SERVICE_STOPPED)) (dwCurrentState == SERVICE_STOPPED))
{ {
service_info->service_status.dwCheckPoint = 0; service_info->service_status.dwCheckPoint = 0;
} }
else else
{ {
service_info->service_status.dwCheckPoint = dwCheckPoint++; service_info->service_status.dwCheckPoint = dwCheckPoint++;
} }
SetServiceStatus(service_info->service_handle, &service_info->service_status); SetServiceStatus(service_info->service_handle, &service_info->service_status);
} }
private: private:
}; };
} }
#endif #endif
ServiceExample/ServiceEntryPoint.hpp
+128 -128
View File
@@ -13,169 +13,169 @@
namespace service namespace service
{ {
class ServiceEntryPoint class ServiceEntryPoint
{ {
public: public:
ServiceEntryPoint() = default; ServiceEntryPoint() = default;
template<typename D = DWORD, typename TStr = LPTSTR, template<typename D = DWORD, typename TStr = LPTSTR,
typename Handle = HANDLE, typename Handle = HANDLE,
typename Obj = models::ServiceInfo<>, typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static VOID WINAPI service_main_start(D argc, TStr *argv) static VOID WINAPI service_main_start(D argc, TStr *argv)
{ {
extern Ptr service_info; extern Ptr service_info;
service_info->service_handle = RegisterServiceCtrlHandler( service_info->service_handle = RegisterServiceCtrlHandler(
service_info->service_name, service_info->service_name,
service::ServiceControlHandler::ServiceCtrlHandler); service::ServiceControlHandler::ServiceCtrlHandler);
if (!service_info->service_handle) if (!service_info->service_handle)
{ {
return; return;
} }
notify_service_controller_starting(service_info); notify_service_controller_starting(service_info);
if (!starting_service(service_info)) if (!starting_service(service_info))
{ {
return; return;
} }
notify_service_controller_started(service_info); notify_service_controller_started(service_info);
// Start a thread that will perform the main task of the service // Start a thread that will perform the main task of the service
Handle hThread = CreateThread(nullptr, 0, ServiceWorkerThread, nullptr, 0, nullptr); Handle hThread = CreateThread(nullptr, 0, ServiceWorkerThread, nullptr, 0, nullptr);
// Wait until our worker thread exits signaling that the service needs to stop // Wait until our worker thread exits signaling that the service needs to stop
WaitForSingleObject(hThread, INFINITE); WaitForSingleObject(hThread, INFINITE);
close_handle(service_info); close_handle(service_info);
} }
private: private:
template<typename D = DWORD, typename Lp = LPVOID, template<typename D = DWORD, typename Lp = LPVOID,
typename Obj = models::ServiceInfo<>, typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static D WINAPI ServiceWorkerThread(Lp lpParam) static D WINAPI ServiceWorkerThread(Lp lpParam)
{ {
extern Ptr service_info; extern Ptr service_info;
const auto INTERVAL = 1500; const auto INTERVAL = 1500;
const auto some_file_path = "C:\\example_file.txt"; const auto some_file_path = "C:\\example_file.txt";
while (WaitForSingleObject(service_info->service_stop_event, 0) != WAIT_OBJECT_0) while (WaitForSingleObject(service_info->service_stop_event, 0) != WAIT_OBJECT_0)
{ {
std::fstream file(some_file_path, std::ios::out | std::ios::app); std::fstream file(some_file_path, std::ios::out | std::ios::app);
const auto content = "burrow"; const auto content = "burrow";
file << content << "\n"; file << content << "\n";
file.close(); file.close();
Sleep(INTERVAL); Sleep(INTERVAL);
} }
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
template<typename Obj = models::ServiceInfo<>, template<typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static bool starting_service(Ptr service_info) static bool starting_service(Ptr service_info)
{ {
/* /*
* Perform tasks necessary to start the service here * Perform tasks necessary to start the service here
*/ */
// Create a service stop event to wait on later // Create a service stop event to wait on later
service_info->service_stop_event = CreateEvent(nullptr, TRUE, FALSE, nullptr); service_info->service_stop_event = CreateEvent(nullptr, TRUE, FALSE, nullptr);
if (service_info->service_stop_event == nullptr) if (service_info->service_stop_event == nullptr)
{ {
// Error creating event // Error creating event
// Tell service controller we are stopped and exit // Tell service controller we are stopped and exit
service_info->service_status.dwControlsAccepted = 0; service_info->service_status.dwControlsAccepted = 0;
service_info->service_status.dwCurrentState = SERVICE_STOPPED; service_info->service_status.dwCurrentState = SERVICE_STOPPED;
service_info->service_status.dwWin32ExitCode = GetLastError(); service_info->service_status.dwWin32ExitCode = GetLastError();
service_info->service_status.dwCheckPoint = 1; service_info->service_status.dwCheckPoint = 1;
if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE) if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE)
{ {
OutputDebugString(_T( OutputDebugString(_T(
"My Sample Service: ServiceMain: SetServiceStatus returned error")); "My Sample Service: ServiceMain: SetServiceStatus returned error"));
} }
return false; return false;
} }
return true; return true;
} }
template<typename Obj = models::ServiceInfo<>, template<typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static void close_handle(Ptr service_info) static void close_handle(Ptr service_info)
{ {
/* /*
* Perform any cleanup tasks * Perform any cleanup tasks
*/ */
CloseHandle(service_info->service_stop_event); CloseHandle(service_info->service_stop_event);
// Tell the service controller we are stopped // Tell the service controller we are stopped
service_info->service_status.dwControlsAccepted = 0; service_info->service_status.dwControlsAccepted = 0;
service_info->service_status.dwCurrentState = SERVICE_STOPPED; service_info->service_status.dwCurrentState = SERVICE_STOPPED;
service_info->service_status.dwWin32ExitCode = 0; service_info->service_status.dwWin32ExitCode = 0;
service_info->service_status.dwCheckPoint = 3; service_info->service_status.dwCheckPoint = 3;
if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE) if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE)
{ {
OutputDebugString(_T( OutputDebugString(_T(
"My Sample Service: ServiceMain: SetServiceStatus returned error")); "My Sample Service: ServiceMain: SetServiceStatus returned error"));
} }
} }
template<typename Obj = models::ServiceInfo<>, template<typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static void notify_service_controller_starting(Ptr service_info) static void notify_service_controller_starting(Ptr service_info)
{ {
// Tell the service controller we are starting // Tell the service controller we are starting
ZeroMemory(&service_info->service_status, sizeof(service_info->service_status)); ZeroMemory(&service_info->service_status, sizeof(service_info->service_status));
service_info->service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS; service_info->service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
service_info->service_status.dwControlsAccepted = 0; service_info->service_status.dwControlsAccepted = 0;
service_info->service_status.dwCurrentState = SERVICE_START_PENDING; service_info->service_status.dwCurrentState = SERVICE_START_PENDING;
service_info->service_status.dwWin32ExitCode = 0; service_info->service_status.dwWin32ExitCode = 0;
service_info->service_status.dwServiceSpecificExitCode = 0; service_info->service_status.dwServiceSpecificExitCode = 0;
service_info->service_status.dwCheckPoint = 0; service_info->service_status.dwCheckPoint = 0;
if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE) if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE)
{ {
OutputDebugString(_T( OutputDebugString(_T(
"My Sample Service: ServiceMain: SetServiceStatus returned error")); "My Sample Service: ServiceMain: SetServiceStatus returned error"));
} }
} }
template<typename Obj = models::ServiceInfo<>, template<typename Obj = models::ServiceInfo<>,
typename Ptr = std::shared_ptr<Obj>> typename Ptr = std::shared_ptr<Obj>>
static void notify_service_controller_started(Ptr service_info) static void notify_service_controller_started(Ptr service_info)
{ {
// Tell the service controller we are started // Tell the service controller we are started
service_info->service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP; service_info->service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
service_info->service_status.dwCurrentState = SERVICE_RUNNING; service_info->service_status.dwCurrentState = SERVICE_RUNNING;
service_info->service_status.dwWin32ExitCode = 0; service_info->service_status.dwWin32ExitCode = 0;
service_info->service_status.dwCheckPoint = 0; service_info->service_status.dwCheckPoint = 0;
if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE) if (SetServiceStatus(service_info->service_handle, &service_info->service_status) == FALSE)
{ {
OutputDebugString(_T( OutputDebugString(_T(
"My Sample Service: ServiceMain: SetServiceStatus returned error")); "My Sample Service: ServiceMain: SetServiceStatus returned error"));
} }
} }
}; };
} }
#endif #endif