windows service的C++封装实现
windows系统服务入口的封装类，service是基类，service_manager是管理类。支持UNICODE，可以多服务封装在一个程序里面，过程当然都是自动的。拥有自动防错系统，在服务异常退出的时候会去关闭服务，而不是开着服务直接没了进程。写一个类，继承service，然后在哪里出一个实例，就可以了。service中有很多虚函数，可以重载了监听对应事件(我应该写的比较明白吧)。get_service_name，返回UNICODE的字符串指针，定义服务名称。注意是纯虚函数，必须实现。get_dependence，也是返回UNICODE的字符指针。指明这个服务依赖什么服务。get_service_type返回服务类型，其实也就是是否可以交互。get_contral_accepts，支持的信号(例如是否可以暂停)，默认可以暂停。on_start开始时候调用的函数，下同。
使用方法
#include
#include "service.h"
class test_service : public service{
public:
virtual LPTSTRget_service_name ();
virtual DWORD on_start (DWORD argc, LPTSTR * argv);
virtual DWORD on_stop ();
virtual DWORD on_shutdown ();
};
LPTSTR test_service::get_service_name ()
{
return _T ("test_service");
}
DWORD test_service::on_start (DWORD argc, LPTSTR * argv)
{
return service::on_start (argc, argv);
}
DWORD test_service::on_stop ()
{
return service::on_stop ();
}
DWORD test_service::on_shutdown ()
{
return service::on_shutdown ();
}
int _tmain (int argc, _TCHAR * argv[])
{
test_service ts;
if (argc == 1)
service_manager::start ();
else if (!_tcscmp (argv[1], _T ("install")))
service_manager::install_services (NULL, false);
else if (!_tcscmp (argv[1], _T ("remove")))
service_manager::remove_services (NULL);
return 0;
}
------------service.h-------------------
#include
using namespace std;
#include
#pragma comment(lib, "psapi")
typedef basic_string < TCHAR > tstring;
#ifndef _SERVICE_H_
#define _SERVICE_H_
class service {
public:
service ();
~service ();
virtual LPTSTRget_service_name () = 0;
virtual LPTSTRget_dependence ();
virtual DWORD get_service_type ();
virtual DWORD get_contral_accepts ();
virtual DWORD on_start (DWORD argc, LPTSTR * argv);
virtual DWORD on_stop ();
virtual DWORD on_interrogate ();
virtual DWORD on_pause ();
virtual DWORD on_continue ();
virtual DWORD on_shutdown ();
voidpre_start (SERVICE_STATUS_HANDLE hServiceStatus,
DWORD argc, LPTSTR * argv);
BOOL SetServiceStatus (DWORD dwState);
protected:
SERVICE_STATUS_HANDLE hServiceStatus;
SERVICE_STATUS ServiceStatus;
};
class service_manager {
public:
service_manager ();
~service_manager ();
DWORDregister_service (service * s);
DWORDunregister_service (service * s);
LPSERVICE_TABLE_ENTRYget_service_entries ();
service *get_service (LPCTSTR lpName);
static service_manager *get_service_manager();
static intinstall_services (LPCTSTR lpServiceName, bool
autostart);
static intremove_services (LPCTSTR lpServiceName);
static intstart();
static void WINAPIservice_start (DWORD argc, LPTSTR * argv);
static DWORD WINAPIctrl_handler (DWORD dwControl, DWORD
dwEventType,
LPVOID lpEventData, LPVOID lpContext);
static TCHAR *service_status_name[];
protected:
static service_manager *this_for_static;
vector < service * >service_list;
};
#endif //_SERVICE_H_
----------------------------------------
------------service.cpp-----------------
// service.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#define PRINTERROR(x) _tprintf (_T ("%s failed, errorcode 0x%0.8X\n"),(x), GetLastError ())
service_manager *service_manager::this_for_static = NULL;
TCHAR *service_manager::service_status_name[] = {
_T ("SERVICE_UNKNOWN"),
_T ("SERVICE_STOPPED"),
_T ("SERVICE_START_PENDING"),
_T ("SERVICE_STOP_PENDING"),
_T ("SERVICE_RUNNING"),
_T ("SERVICE_CONTINUE_PENDING"),
_T ("SERVICE_PAUSE_PENDING"),
_T ("SERVICE_PAUSED")
};
service::service ()
{
if (service_manager::get_service_manager () == NULL)
new service_manager ();
service_manager::get_service_manager ()->register_service
(this);
}
service::~service ()
{
if (service_manager::get_service_manager () == NULL)
return;
service_manager::get_service_manager ()->unregister_service(this);
}
LPTSTR service::get_dependence ()
{
return NULL;
}
DWORD service::get_service_type ()
{
return 0;
}
DWORD service::get_contral_accepts ()
{
return SERVICE_ACCEPT_PAUSE_CONTINUE | SERVICE_ACCEPT_SHUTDOWN |
SERVICE_ACCEPT_STOP;
}
DWORD service::on_start (DWORD argc, LPTSTR * argv)
{
return SERVICE_RUNNING;
}
DWORD service::on_stop ()
{
return SERVICE_STOPPED;
}
DWORD service::on_interrogate ()
{
return SERVICE_RUNNING;
}
DWORD service::on_pause ()
{
return SERVICE_PAUSED;
}
DWORD service::on_continue ()
{
return SERVICE_RUNNING;
}
DWORD service::on_shutdown ()
{
return SERVICE_STOPPED;
}
void service::pre_start (SERVICE_STATUS_HANDLE hServiceStatus,
DWORD argc, LPTSTR * argv)
{
this->hServiceStatus = hServiceStatus;
ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = 0;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 10000;
SetServiceStatus (0);
ServiceStatus.dwCurrentState = on_start (argc, argv);
if (ServiceStatus.dwCurrentState == SERVICE_STOPPED)
ServiceStatus.dwWin32ExitCode = ServiceStatus.dwCurrentState;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
ServiceStatus.dwControlsAccepted = get_contral_accepts ();
SetServiceStatus (0);
return;
}
BOOL service::SetServiceStatus (DWORD dwState)
{
TCHAR lpOutString[0x400];
if (dwState != 0)
ServiceStatus.dwCurrentState = dwState;
if (ServiceStatus.dwCurrentState > 7)
return 0;
BOOL rslt =::SetServiceStatus (hServiceStatus, &ServiceStatus);
if (rslt)
_stprintf (lpOutString,
_T ("%s set service status %s successed.\n"),
get_service_name (),
service_manager::service_status_name[ServiceStatus.
dwCurrentState]);
else
_stprintf (lpOutString,
_T
("%s set service status %s failed, errorcode 0x%0.8X\n"),
get_service_name (),
service_manager::service_status_name[ServiceStatus.
dwCurrentState],
GetLastError ());
OutputDebugString ((LPCTSTR) lpOutString);
return rslt;
}
service_manager::service_manager ()
{
if (this_for_static != NULL)
return;
this_for_static = this;
}
service_manager::\~service_manager ()
{
this_for_static = NULL;
}
DWORD service_manager::register_service (service * s)
{
vector < service * >::iterator iter;
iter = service_list.begin ();
for (; iter != service_list.end (); iter++)
if (*iter == s)
return 1;
service_list.push_back (s);
return 0;
}
DWORD service_manager::unregister_service (service * s)
{
vector < service * >::iterator iter;
iter = service_list.begin ();
for (; iter != service_list.end (); iter++)
if (*iter == s) {
service_list.erase (iter);
return 0;
}
return -1;
}
LPSERVICE_TABLE_ENTRY service_manager::get_service_entries ()
{
UINT i;
LPSERVICE_TABLE_ENTRY lte = NULL;
lte = new SERVICE_TABLE_ENTRY[service_list.size () + 1];
for (i = 0; i < service_list.size (); i++) {
lte[i].lpServiceName = service_list[i]->get_service_name
();
lte[i].lpServiceProc = (LPSERVICE_MAIN_FUNCTION) service_start;
}
lte[i].lpServiceName = NULL;
lte[i].lpServiceProc = NULL;
return lte;
}
service *service_manager::get_service (LPCTSTR lpName)
{
for (UINT i = 0; i < service_list.size (); i++)
if (!_tcscmp (service_list[i]->get_service_name (), lpName))
return service_list[i];
return NULL;
}
int service_manager::install_services (LPCTSTR lpServiceName, bool
autostart)
{
UINT i;
int rslt = 0;
DWORD service_type;
TCHAR binary_path[0x400];
SC_HANDLE hSCManager = NULL, hService = NULL;
service *pservice;
if (lpServiceName == NULL) {
for (i = 0; i < this_for_static->service_list.size (); i++)
install_services (this_for_static->service_list[i]->
get_service_name (), autostart);
return 0;
}
pservice = this_for_static->get_service (lpServiceName);
if (pservice == NULL) {
_tprintf (_T ("get_service %s failed, don't have this service\n"),
lpServiceName);
return -1;
}
if (!GetModuleFileNameEx (GetCurrentProcess (), NULL, binary_path,
0x400)) {
PRINTERROR (_T ("GetModuleFileNameEx"));
return -1;
}
if (this_for_static->service_list.size () < 2)
service_type = SERVICE_WIN32_OWN_PROCESS;
else
service_type = SERVICE_WIN32_SHARE_PROCESS;
__try {
hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCManager == NULL) {
rslt = -1;
__leave;
}
hService = CreateService (hSCManager, lpServiceName, lpServiceName,
SC_MANAGER_ALL_ACCESS,
pservice->
get_service_type () | service_type,
(autostart ? SERVICE_AUTO_START :
SERVICE_DEMAND_START),
SERVICE_ERROR_NORMAL, binary_path, NULL,
NULL, pservice->get_dependence (), NULL,
NULL);
if (hService == NULL) {
rslt = -2;
__leave;
}
}
__finally {
if (hService != NULL)
CloseServiceHandle (hService);
if (hSCManager != NULL)
CloseServiceHandle (hSCManager);
if (rslt == 0)
_tprintf (_T ("install_services %s successed\n"), lpServiceName);
if (rslt == -1)
PRINTERROR (_T ("OpenSCManager"));
if (rslt == -2)
PRINTERROR (_T ("CreateService"));
}
return rslt;
}
int service_manager::remove_services (LPCTSTR lpServiceName)
{
int rslt = 0;
UINT i;
SC_HANDLE hSCManager, hService;
service *pservice;
if (lpServiceName == NULL) {
for (i = 0; i < this_for_static->service_list.size (); i++)
remove_services (this_for_static->service_list[i]->
get_service_name ());
return 0;
}
pservice = this_for_static->get_service (lpServiceName);
if (pservice == NULL) {
_tprintf (_T ("get_service failed, don't have this service\n"));
return -1;
}
__try {
hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hSCManager == NULL) {
rslt = -1;
__leave;
}
hService =
OpenService (hSCManager, lpServiceName, SC_MANAGER_ALL_ACCESS);
if (hService == NULL) {
rslt = -2;
__leave;
}
if (!DeleteService (hService)) {
rslt = -3;
__leave;
}
}
__finally {
if (hService != NULL)
CloseServiceHandle (hService);
if (hSCManager != NULL)
CloseServiceHandle (hSCManager);
if (rslt == 0)
_tprintf (_T ("remove_services %s successed\n"), lpServiceName);
if (rslt == -1)
PRINTERROR (_T ("OpenSCManager"));
if (rslt == -2)
PRINTERROR (_T ("OpenService"));
if (rslt == -3)
PRINTERROR (_T ("DeleteService"));
}
return rslt;
}
int service_manager::start ()
{
if (!StartServiceCtrlDispatcher
(this_for_static->get_service_entries ()))
OutputDebugString (_T ("StartServiceCtrlDispatcher failed\n"));
return 0;
}
void WINAPI service_manager::service_start (DWORD argc, LPTSTR *
argv)
{
SERVICE_STATUS_HANDLE hServiceStatus;
service *pservice = this_for_static->get_service
(argv[0]);
if (pservice == NULL) {
OutputDebugString (_T
("get_service failed, don't have this service\n"));
return;
}
hServiceStatus =
RegisterServiceCtrlHandlerEx (argv[0], ctrl_handler, (LPVOID)
pservice);
if (hServiceStatus == NULL) {
OutputDebugString (_T ("RegisterServiceCtrlHandlerEx return NULL\n"));
return;
}
__try {
pservice->pre_start (hServiceStatus, argc, argv);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
pservice->SetServiceStatus (SERVICE_STOPPED);
}
return;
}
DWORD WINAPI service_manager::ctrl_handler (DWORD dwControl,
DWORD dwEventType,
LPVOID lpEventData,
LPVOID lpContext)
{
DWORD status;
service *pservice = (service *) lpContext;
SetLastError (NO_ERROR);
__try {
switch (dwControl) {
case SERVICE_CONTROL_STOP:
status = pservice->on_stop ();
break;
case SERVICE_CONTROL_SHUTDOWN:
status = pservice->on_shutdown ();
break;
case SERVICE_CONTROL_PAUSE:
status = pservice->on_pause ();
break;
case SERVICE_CONTROL_INTERROGATE:
status = pservice->on_interrogate ();
break;
case SERVICE_CONTROL_CONTINUE:
status = pservice->on_continue ();
break;
default:
return GetLastError ();
}
pservice->SetServiceStatus (status);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
pservice->SetServiceStatus (SERVICE_STOPPED);
}
return GetLastError ();
}
service_manager *service_manager::get_service_manager ()
{
return this_for_static;
}
----------------------------------------
之所有list没有写成map是因为在某个服务处理过程中可能需要用到服务的名称。写成map就需要反向查询，也不是很方便。register_service中会查询这个服务是否已经注册过，注意不能用服务名对比的方法。这也是我才发现的一个问题，C++在基类的构造函数中的时候，虚函数指针是指向基类虚函数表的。在某个service子类构造的时候，其基类(service)构造函数会自动调用register_service方法注册自身。如果在register_service用取得服务名的方法，此时虚函数指针指向了基类的虚函数表。也就是说，我们会调用到一个纯虚函数入口，从而产生C++错误。所以必须手工来匹配指针，大家忍耐忍耐。