windows_service/service_base.cpp at master · Olster/windows_service · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include "service_base.h"
#include <cassert>

ServiceBase* ServiceBase::m_service = nullptr;

ServiceBase::ServiceBase(const CString& name,
                         const CString& displayName,
                         DWORD dwStartType,
                         DWORD dwErrCtrlType,
                         DWORD dwAcceptedCmds,
                         const CString& depends,
                         const CString& account,
                         const CString& password)
 : m_name(name),
   m_displayName(displayName),
   m_dwStartType(dwStartType),
   m_dwErrorCtrlType(dwErrCtrlType),
   m_depends(depends),
   m_account(account),
   m_password(password),
   m_svcStatusHandle(nullptr) {

  m_svcStatus.dwControlsAccepted = dwAcceptedCmds;
  m_svcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  m_svcStatus.dwCurrentState = SERVICE_START_PENDING;
  m_svcStatus.dwWin32ExitCode = NO_ERROR;
  m_svcStatus.dwServiceSpecificExitCode = 0;
  m_svcStatus.dwCheckPoint = 0;
  m_svcStatus.dwWaitHint = 0;
}

void ServiceBase::SetStatus(DWORD dwState, DWORD dwErrCode, DWORD dwWait) {
  m_svcStatus.dwCurrentState = dwState;
  m_svcStatus.dwWin32ExitCode = dwErrCode;
  m_svcStatus.dwWaitHint = dwWait;

  ::SetServiceStatus(m_svcStatusHandle, &m_svcStatus);
}

void ServiceBase::WriteToEventLog(const CString& msg, WORD type) {
  HANDLE hSource = RegisterEventSource(nullptr, m_name);
  if (hSource) {
    const TCHAR* msgData[2] = {m_name, msg};
    ReportEvent(hSource, type, 0, 0, nullptr, 2, 0, msgData, nullptr);
    DeregisterEventSource(hSource);
  }
}

// static
void WINAPI ServiceBase::SvcMain(DWORD argc, TCHAR* argv[]) {
  assert(m_service);

  m_service->m_svcStatusHandle = ::RegisterServiceCtrlHandlerEx(m_service->GetName(),
                                                                ServiceCtrlHandler, NULL);
  if (!m_service->m_svcStatusHandle) {
    m_service->WriteToEventLog(_T("Can't set service control handler"),
                               EVENTLOG_ERROR_TYPE);
    return;
  }

  m_service->Start(argc, argv);
}

// static
DWORD WINAPI ServiceBase::ServiceCtrlHandler(DWORD ctrlCode, DWORD evtType,
                                             void* evtData, void* /*context*/) {
  switch (ctrlCode) {
    case SERVICE_CONTROL_STOP:
      m_service->Stop();
    break;

    case SERVICE_CONTROL_PAUSE:
      m_service->Pause();
    break;

    case SERVICE_CONTROL_CONTINUE:
      m_service->Continue();
    break;

    case SERVICE_CONTROL_SHUTDOWN:
      m_service->Shutdown();
    break;

    case SERVICE_CONTROL_SESSIONCHANGE:
      m_service->OnSessionChange(evtType, reinterpret_cast<WTSSESSION_NOTIFICATION*>(evtData));
    break;

    default:
    break;
  }

  return 0;
}

bool ServiceBase::RunInternal(ServiceBase* svc) {
  m_service = svc;

  TCHAR* svcName = const_cast<CString&>(m_service->GetName()).GetBuffer();

  SERVICE_TABLE_ENTRY tableEntry[] = {
    {svcName, SvcMain},
    {nullptr, nullptr}
  };

  return ::StartServiceCtrlDispatcher(tableEntry) == TRUE;
}

void ServiceBase::Start(DWORD argc, TCHAR* argv[]) {
  SetStatus(SERVICE_START_PENDING);
  OnStart(argc, argv);
  SetStatus(SERVICE_RUNNING);
}

void ServiceBase::Stop() {
  SetStatus(SERVICE_STOP_PENDING);
  OnStop();
  SetStatus(SERVICE_STOPPED);
}

void ServiceBase::Pause() {
  SetStatus(SERVICE_PAUSE_PENDING);
  OnPause();
  SetStatus(SERVICE_PAUSED);
}

void ServiceBase::Continue() {
  SetStatus(SERVICE_CONTINUE_PENDING);
  OnContinue();
  SetStatus(SERVICE_RUNNING);
}

void ServiceBase::Shutdown() {
  OnShutdown();
  SetStatus(SERVICE_STOPPED);
}