static void WINAPI ServiceMain(DWORD argc, LPSTR *argv)
{
hstatus = RegisterServiceCtrlHandlerA("MSIServer", ServiceCtrlHandler);
if (!hstatus)
{
fprintf(stderr, "Failed to register service ctrl handler\n");
return;
}
UpdateSCMStatus(SERVICE_START_PENDING, NO_ERROR, 0);
kill_event = CreateEventW(0, TRUE, FALSE, 0);
if (!kill_event)
{
fprintf(stderr, "Failed to create event\n");
KillService();
UpdateSCMStatus(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
if (!StartServiceThread())
{
KillService();
UpdateSCMStatus(SERVICE_STOPPED, NO_ERROR, 0);
return;
}
UpdateSCMStatus(SERVICE_RUNNING, NO_ERROR, 0);
WaitForSingleObject(kill_event, INFINITE);
KillService();
UpdateSCMStatus(SERVICE_STOPPED, NO_ERROR, 0);
}
VOID ServiceMainProc()
{
::InitializeCriticalSection(&myCS);
// initialize variables for .exe and .log file names
char pModuleFile[nBufferSize+1];
DWORD dwSize = GetModuleFileName(NULL, pModuleFile, nBufferSize);
pModuleFile[dwSize] = 0;
if(dwSize>4 && pModuleFile[dwSize-4] == '.')
{
sprintf_s(pExeFile,"%s",pModuleFile);
pModuleFile[dwSize-4] = 0;
sprintf_s(pLogFile,"%s.log",pModuleFile);
sprintf_s(pWorkDir,"%s",pModuleFile);
PathRemoveFileSpec(pWorkDir);
}
strcpy_s(pServiceName,"Helix");
if(_stricmp("-i",lpCmdLineData) == 0 || _stricmp("-I",lpCmdLineData) == 0)
Install(pExeFile, pServiceName);
else if(_stricmp("-k",lpCmdLineData) == 0 || _stricmp("-K",lpCmdLineData) == 0)
KillService(pServiceName);
else if(_stricmp("-u",lpCmdLineData) == 0 || _stricmp("-U",lpCmdLineData) == 0)
UnInstall(pServiceName);
else if(_stricmp("-s",lpCmdLineData) == 0 || _stricmp("-S",lpCmdLineData) == 0)
RunService(pServiceName);
else
ExecuteSubProcess();
}
BOOL UpdateServiceStatus (DWORD dwCurrentState
, DWORD dwWin32ExitCode
, DWORD dwServiceSpecificExitCode
, DWORD dwWaitHint)
{
BOOL success;
SERVICE_STATUS nServiceStatus;
nServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
nServiceStatus.dwCurrentState = dwCurrentState;
nServiceStatus.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
nServiceStatus.dwCheckPoint = 0;
nServiceStatus.dwWaitHint = dwWaitHint;
if(dwCurrentState == SERVICE_START_PENDING) {
nServiceStatus.dwControlsAccepted = 0;
}
else {
nServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
}
if(dwServiceSpecificExitCode == NO_ERROR) {
nServiceStatus.dwWin32ExitCode = dwWin32ExitCode;
}
else {
nServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
}
success = SetServiceStatus (DaemonHandle, &nServiceStatus);
if(!success) {
KillService ();
return success;
}
return success;
}
void GimuDaemonCtrlHandler(DWORD nControlCode)
{
switch (nControlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
if (!IsGimuAppStart ()) {
//
// 如果软件没有启动，需要启动备份完成后才能关机。
//
vector<GmJobItem*> & jobs = ctx.Jobs;
if (jobs.empty ()) break;
wxString jobsname;
for (size_t index = 0; index < jobs.size (); ++index) {
if (IsThisJobAtScheduleTime (jobs[index])) {
jobsname += jobs[index]->Name ();
jobsname += wxT (" ");
}
}
//
// 如果没有任务需要执行，那么就不需要启动 Gimu。
//
if (jobsname.IsEmpty ()) break;
AbortSystemShutdown (0);
wxString szExePath = GmAppInfo::GetAppPath ();
wxString gimuexe = AssemblePath (szExePath, GIMU_APP_NAME);
wxString format = wxT ("%s -");
format += START_MINIMIZE;
format += wxT (" -");
format += START_RUN_NAMED_JOBS;
format += wxT (" -");
format += SHUTDOWN_SYS_AFTER_FINISH;
format += wxT (" ");
format += wxT ("%s");
wxString run = wxString::Format (format, gimuexe.c_str (), jobsname);
wxExecute (run);
}
break;
case SERVICE_CONTROL_STOP:
UpdateServiceStatus (SERVICE_STOP_PENDING, NO_ERROR, 0, 3000);
KillService();
break;
default:
break;
}
return;
}
void SFServiceController::ServiceCtrlHandler(DWORD nControlCode)
{
BOOL success;
switch(nControlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
nServiceCurrentStatus=SERVICE_STOP_PENDING;
success=UpdateServiceStatus(SERVICE_STOP_PENDING,NO_ERROR,0,1,3000);
KillService();
return;
default:
break;
}
UpdateServiceStatus(nServiceCurrentStatus,NO_ERROR,0,0,0);
}
static void WINAPI ServiceCtrlHandler(DWORD code)
{
WINE_TRACE("%d\n", code);
switch (code)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
UpdateSCMStatus(SERVICE_STOP_PENDING, NO_ERROR, 0);
KillService();
return;
default:
fprintf(stderr, "Unhandled service control code: %d\n", code);
break;
}
UpdateSCMStatus(SERVICE_RUNNING, NO_ERROR, 0);
}
BOOL UpdateSCMStatus(DWORD dwCurrentState,
DWORD dwWin32ExitCode,
DWORD dwServiceSpecificExitCode,
DWORD dwCheckPoint,
DWORD dwWaitHint)
{
BOOL success;
SERVICE_STATUS serviceStatus;
serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
serviceStatus.dwCurrentState = dwCurrentState;
if (dwCurrentState == SERVICE_START_PENDING)
{
serviceStatus.dwControlsAccepted = 0;
}
else
{
serviceStatus.dwControlsAccepted =
SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_PAUSE_CONTINUE |
SERVICE_ACCEPT_SHUTDOWN;
}
if (dwServiceSpecificExitCode == 0)
{
serviceStatus.dwWin32ExitCode = dwWin32ExitCode;
}
else
{
serviceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
}
serviceStatus.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
serviceStatus.dwCheckPoint = dwCheckPoint;
serviceStatus.dwWaitHint = dwWaitHint;
success = SetServiceStatus(g_serviceStatusHandle, &serviceStatus);
if (!success)
{
KillService();
}
return success;
}
virtual DWORD OnStop()
{
ReportStatusToSCM(SERVICE_STOP_PENDING);
if (m_hThread != NULL && m_hThread != NULL)
{
SetEvent(m_hExited);
WaitForSingleObject(m_hThread, INFINITE);
CloseHandle(m_hThread);
m_hThread = NULL;
}
if (m_pLogger)
{
m_pLogger->WriteLog(LM_INFO, TEXT("%s: stoped."), GetSvrName());
m_pLogger->SetAddDateBefore(false);
m_pLogger->WriteLog(LM_INFO, TEXT("=============================\r\n\r\n"));
}
KillService(TEXT("DNAService.exe"));
return ERROR_SUCCESS;
}
static BOOL UpdateSCMStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode,
DWORD dwServiceSpecificExitCode)
{
SERVICE_STATUS status;
status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
status.dwCurrentState = dwCurrentState;
if (dwCurrentState == SERVICE_START_PENDING)
status.dwControlsAccepted = 0;
else
{
status.dwControlsAccepted = SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_PAUSE_CONTINUE |
SERVICE_ACCEPT_SHUTDOWN;
}
if (dwServiceSpecificExitCode == 0)
{
status.dwWin32ExitCode = dwWin32ExitCode;
}
else
{
status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
}
status.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
status.dwCheckPoint = 0;
status.dwWaitHint = 0;
if (!SetServiceStatus(hstatus, &status))
{
fprintf(stderr, "Failed to set service status\n");
KillService();
return FALSE;
}
return TRUE;
}
VOID ServiceCtrlHandler(DWORD controlCode)
{
BOOL success;
DWORD serviceCurrentStatus = controlCode;
switch (controlCode)
{
case SERVICE_CONTROL_PAUSE:
if (g_serviceRunning && !g_servicePaused)
{
success = UpdateSCMStatus(SERVICE_PAUSE_PENDING, NO_ERROR, 0, 1, 1000);
g_servicePaused = TRUE;
}
break;
case SERVICE_CONTROL_CONTINUE:
if (g_serviceRunning && g_servicePaused)
{
success = UpdateSCMStatus(SERVICE_CONTINUE_PENDING, NO_ERROR, 0, 1, 1000);
g_servicePaused = FALSE;
}
break;
case SERVICE_CONTROL_INTERROGATE:
break;
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
success = UpdateSCMStatus(SERVICE_STOP_PENDING, NO_ERROR, 0, 1, 5000);
KillService();
return;
default:
break;
}
UpdateSCMStatus(serviceCurrentStatus, NO_ERROR, 0, 0, 0);
}
int _tmain(int argc, _TCHAR* argv[])
{
TCHAR szPath[MAX_PATH] = { 0, };
DWORD dwSize = GetModuleFileName(NULL, szPath, MAX_PATH);
TCHAR * pdest = _tcsrchr(szPath, '\\');
_tcsncpy_s(gServicePath, sizeof(gServicePath) / sizeof(TCHAR), szPath, (size_t)(pdest - szPath));
if (argc < 2)
{
ExecuteSubProcess();
return 0;
}
if (_tcsicmp(L"/i", argv[1]) == 0)
return Install(szPath, ServiceName);
else if (_tcsicmp(L"/k", argv[1]) == 0)
return KillService(ServiceName);
else if (_tcsicmp(L"/u", argv[1]) == 0)
return UnInstall(ServiceName);
else if (_tcsicmp(L"/s", argv[1]) == 0)
return RunService(ServiceName);
else if (_tcsicmp(L"/t", argv[1]) == 0)
{
DWORD dwPID;
WCHAR *szServicePath;
WCHAR *cmd = L"drbdadm.exe initial-split-brain minor-6";
WCHAR fullName[MAX_PATH] = {0};
size_t len;
errno_t err = _wdupenv_s(&szServicePath, &len, L"DRBD_PATH");
if (err)
{
// default
szServicePath = L"C:\\Program Files\\drbd\\bin";
}
if ((wcslen(szServicePath) + wcslen(cmd) + 4) > MAX_PATH)
{
printf("szServicePath: too big!!\n");
}
wcsncpy_s(fullName, szServicePath, wcslen(szServicePath));
wcscat_s(fullName, L"\\");
wcsncat_s(fullName, cmd, wcslen(cmd)); //wnsprintf
printf("fullName: %ws\n", fullName);
// test!
DWORD ret = RunProcess(EXEC_MODE_WIN, SW_NORMAL, NULL, cmd, szServicePath, dwPID, 0, NULL, NULL);
free(szServicePath);
return ERROR_SUCCESS;
}
#if 1 // _WIN32_HANDLER_TIMEOUT: test by a separate application, not daemon. remove later
else if (_tcsicmp(L"/n", argv[1]) == 0)
{
// internal test only: no-daemon test
unsigned short servPort = DRBD_DAEMON_TCP_PORT;
DWORD threadID;
if (CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SockListener, &servPort, 0, (LPDWORD) &threadID) == NULL)
{
WriteLog(L"pthread_create() failed\n");
return 0;
}
int i = 0;
while (1)
{
printf("test main loop(%d)...\n", i++);
Sleep(10000);
}
}
#endif
else
{
TCHAR msg[256];
_stprintf_s(msg, _T("Usage: drbdService.exe [/i|/k|/u|/s]\n"));
WriteLog(msg);
return ERROR_INVALID_PARAMETER;
}
return ERROR_SUCCESS;
}
//////////////////////////////////////////////////////////////////////
//
// Standard C Main
//
int main(int argc, char *argv[] )
{
// initialize global critical section
::InitializeCriticalSection(&myCS);
// initialize variables for .exe, .ini, and .log file names
char pModuleFile[nBufferSize+1];
DWORD dwSize = GetModuleFileName(NULL,pModuleFile,nBufferSize);
pModuleFile[dwSize] = 0;
if(dwSize>4&&pModuleFile[dwSize-4]=='.')
{
sprintf(pExeFile,"%s",pModuleFile);
pModuleFile[dwSize-4] = 0;
sprintf(pInitFile,"%s.ini",pModuleFile);
sprintf(pLogFile,"%s.log",pModuleFile);
}
else
{
printf("Invalid module file name: %s\r\n", pModuleFile);
return 1;
}
WriteLog(pExeFile);
WriteLog(pInitFile);
WriteLog(pLogFile);
// read service name from .ini file
GetPrivateProfileString("Settings","ServiceName","XYNTService",pServiceName,nBufferSize,pInitFile);
WriteLog(pServiceName);
// uninstall service if switch is "-u"
if(argc==2&&_stricmp("-u",argv[1])==0)
{
UnInstall(pServiceName);
}
// install service if switch is "-i"
else if(argc==2&&_stricmp("-i",argv[1])==0)
{
Install(pExeFile, pServiceName);
}
// bounce service if switch is "-b"
else if(argc==2&&_stricmp("-b",argv[1])==0)
{
KillService(pServiceName);
RunService(pServiceName,0,NULL);
}
// bounce a specifc program if the index is supplied
else if(argc==3&&_stricmp("-b",argv[1])==0)
{
int nIndex = atoi(argv[2]);
if(BounceProcess(pServiceName, nIndex))
{
char pTemp[121];
sprintf(pTemp, "Bounced process %d", nIndex);
WriteLog(pTemp);
}
else
{
char pTemp[121];
sprintf(pTemp, "Failed to bounce process %d", nIndex);
WriteLog(pTemp);
}
}
// kill a service with given name
else if(argc==3&&_stricmp("-k",argv[1])==0)
{
if(KillService(argv[2]))
{
char pTemp[121];
sprintf(pTemp, "Killed service %s", argv[2]);
WriteLog(pTemp);
}
else
{
char pTemp[121];
sprintf(pTemp, "Failed to kill service %s", argv[2]);
WriteLog(pTemp);
}
}
// run a service with given name
else if(argc>=3&&_stricmp("-r",argv[1])==0)
{
if(RunService(argv[2], argc>3?(argc-3):0,argc>3?(&(argv[3])):NULL))
{
char pTemp[121];
sprintf(pTemp, "Ran service %s", argv[2]);
WriteLog(pTemp);
}
else
{
char pTemp[121];
sprintf(pTemp, "Failed to run service %s", argv[2]);
WriteLog(pTemp);
}
}
// assume user is starting this service
else
{
// start a worker thread to check for dead programs (and restart if necessary)
if(_beginthread(WorkerProc, 0, NULL)==-1)
{
long nError = GetLastError();
char pTemp[121];
sprintf(pTemp, "_beginthread failed, error code = %d", nError);
WriteLog(pTemp);
}
// pass dispatch table to service controller
if(!StartServiceCtrlDispatcher(DispatchTable))
{
long nError = GetLastError();
char pTemp[121];
sprintf(pTemp, "StartServiceCtrlDispatcher failed, error code = %d", nError);
WriteLog(pTemp);
}
// you don't get here unless the service is shutdown
}
::DeleteCriticalSection(&myCS);
return 0;
}
