VOID WINAPI ServiceCtrlHandler(DWORD fdwControl) { switch (fdwControl) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: status.dwCurrentState = SERVICE_STOPPED; break; default: break; } if (SetServiceStatus(hStatus, &status) == 0) { printf("Cannot set service status (0x%08x)\n", GetLastError()); exit(1); } return; }
void lutil_ReportShutdownComplete( ) { if ( is_NT_Service ) { /* stop sending SERVICE_STOP_PENDING messages to the Service Control Manager */ ldap_pvt_thread_cond_signal( &stopped_event ); ldap_pvt_thread_cond_destroy( &stopped_event ); /* wait for the thread sending the SERVICE_STOP_PENDING messages to the Service Control Manager to die. * if the wait fails then put ourselves to sleep for half the Service Control Manager update interval */ if (ldap_pvt_thread_join( stop_status_tid, (void *) NULL ) == -1) ldap_pvt_thread_sleep( SCM_NOTIFICATION_INTERVAL / 2 ); lutil_ServiceStatus.dwCurrentState = SERVICE_STOPPED; lutil_ServiceStatus.dwCheckPoint++; lutil_ServiceStatus.dwWaitHint = SCM_NOTIFICATION_INTERVAL; SetServiceStatus(hlutil_ServiceStatus, &lutil_ServiceStatus); } }
BOOL sendStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwCheckPoint, DWORD dwWaitHint) { BOOL result; if (dwCurrentState == SERVICE_START_PENDING) serviceStatus.dwControlsAccepted = 0; else serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE; serviceStatus.dwCurrentState = dwCurrentState; serviceStatus.dwWin32ExitCode = dwWin32ExitCode; serviceStatus.dwCheckPoint = dwCheckPoint; serviceStatus.dwWaitHint = dwWaitHint; if (!(result = SetServiceStatus(serviceStatusHandle, &serviceStatus))) { logServiceMessage(_T("SetServiceStatus"), EVENTLOG_ERROR_TYPE); } return result; }
/* Service control callback */ void __stdcall service_handler(DWORD fdwControl) { switch(fdwControl){ case SERVICE_CONTROL_CONTINUE: /* Continue from Paused state. */ break; case SERVICE_CONTROL_PAUSE: /* Pause service. */ break; case SERVICE_CONTROL_SHUTDOWN: /* System is shutting down. */ case SERVICE_CONTROL_STOP: /* Service should stop. */ service_status.dwCurrentState = SERVICE_STOP_PENDING; SetServiceStatus(service_handle, &service_status); run = 0; break; } }
void CServiceModule::Run() { HRESULT hr; _Module.dwThreadID = GetCurrentThreadId(); // If you are running on NT 4.0 or higher you can use the following call // to make your service free threaded. // This means that calls come in on a random RPC thread hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); // Otherwise, for single threaded use // hr = CoInitialize(NULL); ATLASSERT(SUCCEEDED(hr)); // In NT 4.0 and higher where DCOM is supported you may wish to initialize // the security layer. The following code will give you a DCOM service which // would allow ALL users access to objects CSecurityDescriptor sd; sd.InitializeFromThreadToken(); hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IDENTIFY, NULL, EOAC_NONE, NULL); ATLASSERT(SUCCEEDED(hr)); // If you wish to have your object creatable remotely using DCOM use the following hr = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER, REGCLS_MULTIPLEUSE); // Otherwise, only local activation // hr = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE); ATLASSERT(SUCCEEDED(hr)); LogEvent(_T("Service started")); SetServiceStatus(SERVICE_RUNNING); MSG msg; while (GetMessage(&msg, 0, 0, 0)) DispatchMessage(&msg); _Module.RevokeClassObjects(); CoUninitialize(); }
static DWORD WINAPI ServiceControlHandler(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext) { DPRINT1("ServiceControlHandler() called\n"); switch (dwControl) { case SERVICE_CONTROL_STOP: DPRINT1(" SERVICE_CONTROL_STOP received\n"); SetEvent(ShutdownEvent); UpdateServiceStatus(SERVICE_STOP_PENDING); return ERROR_SUCCESS; case SERVICE_CONTROL_PAUSE: DPRINT1(" SERVICE_CONTROL_PAUSE received\n"); UpdateServiceStatus(SERVICE_PAUSED); return ERROR_SUCCESS; case SERVICE_CONTROL_CONTINUE: DPRINT1(" SERVICE_CONTROL_CONTINUE received\n"); UpdateServiceStatus(SERVICE_RUNNING); return ERROR_SUCCESS; case SERVICE_CONTROL_INTERROGATE: DPRINT1(" SERVICE_CONTROL_INTERROGATE received\n"); SetServiceStatus(ServiceStatusHandle, &ServiceStatus); return ERROR_SUCCESS; case SERVICE_CONTROL_SHUTDOWN: DPRINT1(" SERVICE_CONTROL_SHUTDOWN received\n"); SetEvent(ShutdownEvent); UpdateServiceStatus(SERVICE_STOP_PENDING); return ERROR_SUCCESS; default : DPRINT1(" Control %lu received\n"); return ERROR_CALL_NOT_IMPLEMENTED; } }
/** VOID WINAPI OssecServiceCtrlHandler (DWORD dwOpcode) * "Signal" handler */ VOID WINAPI OssecServiceCtrlHandler(DWORD dwOpcode) { switch(dwOpcode) { case SERVICE_CONTROL_STOP: ossecServiceStatus.dwCurrentState = SERVICE_STOPPED; ossecServiceStatus.dwWin32ExitCode = 0; ossecServiceStatus.dwCheckPoint = 0; ossecServiceStatus.dwWaitHint = 0; verbose("%s: Received exit signal.", ARGV0); SetServiceStatus (ossecServiceStatusHandle, &ossecServiceStatus); verbose("%s: Exiting...", ARGV0); return; default: break; } return; }
static void WINAPI service_ctrl_handler(DWORD control_code) { switch (control_code) { case SERVICE_CONTROL_INTERROGATE: break; case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: svc_status.dwCurrentState = SERVICE_STOP_PENDING; svc_status.dwWaitHint = 2000; eloop_terminate(); SetEvent(kill_svc); break; } if (!SetServiceStatus(svc_status_handle, &svc_status)) { printf("SetServiceStatus() failed: %d\n", (int) GetLastError()); } }
VOID WINAPI ServerCtrlHandler(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext) { PSERVICEINFO pServInfo = (PSERVICEINFO)lpContext; switch (dwControl) { case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: LogEvent(L"\nSetting the service to SERVICE_STOP_PENDING", 0, 0, LOG_FILE); InterlockedExchange((LONG *)&bShutdown, TRUE); pServInfo->servStatus.dwWin32ExitCode = 0; pServInfo->servStatus.dwWaitHint = 5000; UpdateStatus(pServInfo, SERVICE_STOP_PENDING, 1); break; case SERVICE_CONTROL_PAUSE: /* not yet implemented */ LogEvent(L"Setting the service to SERVICE_PAUSED", 0, 0, LOG_FILE); InterlockedExchange((LONG *)&bPause, TRUE); UpdateStatus(pServInfo, SERVICE_PAUSED, 0); break; case SERVICE_CONTROL_CONTINUE: LogEvent(L"Setting the service to SERVICE_RUNNING", 0, 0, LOG_FILE); InterlockedExchange((LONG *)&bPause, FALSE); UpdateStatus(pServInfo, SERVICE_RUNNING, 0); break; case SERVICE_CONTROL_INTERROGATE: SetServiceStatus(pServInfo->hStatus, &pServInfo->servStatus); break; default: if (dwControl > 127 && dwControl < 256) /* user defined */ LogEvent(L"User defined control code", 0, 0, LOG_FILE); else LogEvent(L"ERROR: Bad control code", 0, 0, LOG_FILE); break; } }
void CServiceModule::Run() { _Module.dwThreadID = GetCurrentThreadId(); HRESULT hr = CoInitialize(NULL); // If you are running on NT 4.0 or higher you can use the following call // instead to make the EXE free threaded. // This means that calls come in on a random RPC thread // HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); _ASSERTE(SUCCEEDED(hr)); // This provides a NULL DACL which will allow access to everyone. CSecurityDescriptor sd; sd.InitializeFromThreadToken(); hr = CoInitializeSecurity(sd, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); _ASSERTE(SUCCEEDED(hr)); hr = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER, REGCLS_MULTIPLEUSE); _ASSERTE(SUCCEEDED(hr)); LogEvent(_T("Service started")); if (m_bService) SetServiceStatus(SERVICE_RUNNING); try { _ppool = new CDBConnectionPool (); } catch (...) { goto end; } MSG msg; while (GetMessage(&msg, 0, 0, 0)) DispatchMessage(&msg); end: _Module.RevokeClassObjects(); CoUninitialize(); }
// Start service VOID WINAPI CmdStart (DWORD, LPTSTR* ) { DWORD status = 0; DWORD specificError = 0; ServiceStatus.dwServiceType = SERVICE_WIN32; ServiceStatus.dwCurrentState = SERVICE_START_PENDING; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE; ServiceStatus.dwWin32ExitCode = 0; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; ServiceStatusHandle = RegisterServiceCtrlHandler( SERVICENAME, CmdCtrlHandler ); if (ServiceStatusHandle == (SERVICE_STATUS_HANDLE)0) return; // Initialization complete - report running status. ServiceStatus.dwCurrentState = SERVICE_RUNNING; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; if (!SetServiceStatus (ServiceStatusHandle, &ServiceStatus)) status = GetLastError(); else { //we do all things in the thread of _ServiceMain, wo also could do things here //while(true) //{ //} // Start the main thread g_hServiceEvents[0] = CreateEvent( NULL, FALSE, FALSE, NULL ); g_hServiceEvents[1] = CreateEvent( NULL, FALSE, FALSE, NULL ); g_hServiceEvents[2] = CreateEvent( NULL, FALSE, FALSE, NULL ); _beginthread( _ServiceMain, 0, NULL ); } return; }
VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv) { DWORD status = 0; DWORD specificError = 0xfffffff; ServiceStatus.dwServiceType = SERVICE_WIN32; ServiceStatus.dwCurrentState = SERVICE_START_PENDING; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE; ServiceStatus.dwWin32ExitCode = 0; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; hServiceStatusHandle = RegisterServiceCtrlHandler(pServiceName, ServiceHandler); if (hServiceStatusHandle==0) { long nError = GetLastError(); char pTemp[121]; sprintf_s(pTemp, "RegisterServiceCtrlHandler failed, error code = %d\n", nError); WriteLog(pLogFile, pTemp); return; } // Initialization complete - report running status ServiceStatus.dwCurrentState = SERVICE_RUNNING; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; if(!SetServiceStatus(hServiceStatusHandle, &ServiceStatus)) { long nError = GetLastError(); char pTemp[121]; sprintf_s(pTemp, "SetServiceStatus failed, error code = %d\n", nError); WriteLog(pLogFile, pTemp); } AttachProcessNames(); for(int iLoop = 0; iLoop < MAX_NUM_OF_PROCESS; iLoop++) { pProcInfo[iLoop].hProcess = 0; StartProcess(iLoop); } }
void ServiceMain(int argc, char** argv) { HSP sp; memset(&sp,0,sizeof(sp)); sp.configFile = ""; sp.pidFile = ""; ServiceStatus.dwServiceType = SERVICE_WIN32; ServiceStatus.dwCurrentState = SERVICE_START_PENDING; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; ServiceStatus.dwWin32ExitCode = 0; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; if(!debug){ hStatus = RegisterServiceCtrlHandler( "hsflowd", (LPHANDLER_FUNCTION)ControlHandler); if (hStatus == (SERVICE_STATUS_HANDLE)0) { // Registering Control Handler failed return; } } // report the running status to SCM. ServiceStatus.dwCurrentState = SERVICE_RUNNING; SetServiceStatus (hStatus, &ServiceStatus); readInterfaces(&sp); HSPReadConfig(&sp); initAgent(&sp); // main loop while (ServiceStatus.dwCurrentState == SERVICE_RUNNING) { sfl_agent_tick(sp.sFlow->agent, time(NULL)); Sleep(SLEEP_TIME); } return; }
/// 回报服务状态 bool win_svc_base::ReportStatus(unsigned long dwCurrentState, unsigned long dwExitCode , unsigned long dwCheckPoint, unsigned long dwWaitHint) { if (dwCurrentState == SERVICE_START_PENDING) m_pWinStructImpl->m_ssStatus.dwControlsAccepted = 0; else m_pWinStructImpl->m_ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; // Initialize ss structure. m_pWinStructImpl->m_ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; m_pWinStructImpl->m_ssStatus.dwServiceSpecificExitCode = 0; m_pWinStructImpl->m_ssStatus.dwCurrentState = dwCurrentState; m_pWinStructImpl->m_ssStatus.dwWin32ExitCode = dwExitCode; m_pWinStructImpl->m_ssStatus.dwCheckPoint = dwCheckPoint; m_pWinStructImpl->m_ssStatus.dwWaitHint = dwWaitHint; bool bRet = (SetServiceStatus(m_pWinStructImpl->m_ssh, &m_pWinStructImpl->m_ssStatus) ? true : false); //LOG << "call ReportStatus dwCurrentState=" << dwCurrentState << " ret=" << bRet << std::endl; return bRet; }
//! 服务程序的事件响应入口 VOID WINAPI ServiceControl::ControlHandler(DWORD request) { switch (request) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: ServiceSCC::GetInstance().CloseExec(); ServiceSCC::GetInstance().Relese(); c_ServiceStatus.dwCurrentState = SERVICE_STOPPED; SetServiceStatus(c_hStatus, &c_ServiceStatus); break; case SERVICE_CONTROL_PAUSE: break; case SERVICE_CONTROL_CONTINUE: break; case SERVICE_CONTROL_INTERROGATE: break; } }
void ReportServiceStatus( DWORD dwCurrentState, DWORD dwCheckPoint, DWORD dwWaitHint ) { SERVICE_STATUS ServiceStatus; if( !bService ) return; if( hService ) { memset( &ServiceStatus, 0, sizeof(ServiceStatus) ); ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; ServiceStatus.dwCurrentState = dwCurrentState; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; ServiceStatus.dwWin32ExitCode = NO_ERROR; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = dwCheckPoint; ServiceStatus.dwWaitHint = dwWaitHint; SetServiceStatus( hService, &ServiceStatus ); } }
static BOOL send_status(DWORD current_state, DWORD exit_code, DWORD wait_hint, DWORD id) { static DWORD dwCheckPoint = 1; BOOL ret_val; if (not_service) return TRUE; ssStatus.dwCurrentState = current_state; ssStatus.dwWin32ExitCode = exit_code; ssStatus.dwWaitHint = wait_hint; ssStatus.dwControlsAccepted = (current_state == SERVICE_START_PENDING) ? 0 : SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; ssStatus.dwCheckPoint = ((current_state == SERVICE_RUNNING) || (current_state == SERVICE_STOPPED)) ? 0 : dwCheckPoint++; if (!(ret_val = SetServiceStatus(sshStatusHandle, &ssStatus))) event_log(id, "SetServiceStatus failed"); return ret_val; } /* send_status */
void WINAPI ServiceControlHandler(DWORD dwCtrlCode) { switch(dwCtrlCode) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: lprintf(LOG_NOTICE,"Received termination control signal: %d", dwCtrlCode); svc_status.dwWaitHint=NTSVC_TIMEOUT_SHUTDOWN; svc_status.dwCurrentState=SERVICE_STOP_PENDING; SetServiceStatus(svc_status_handle, &svc_status); terminated=TRUE; // SetEvent(service_event); break; case SERVICE_CONTROL_INTERROGATE: lprintf(LOG_DEBUG,"Ignoring service control signal: SERVICE_CONTROL_INTERROGATE"); break; default: lprintf(LOG_WARNING,"Received unsupported service control signal: %d", dwCtrlCode); break; } }
VOID ReportSvcStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint) { static DWORD dwCheckPoint = 1; gSvcStatus.dwCurrentState = dwCurrentState; gSvcStatus.dwWin32ExitCode = dwWin32ExitCode; gSvcStatus.dwWaitHint = dwWaitHint; if (dwCurrentState == SERVICE_START_PENDING) gSvcStatus.dwControlsAccepted = 0; else gSvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP; if ((dwCurrentState == SERVICE_RUNNING) || (dwCurrentState == SERVICE_STOPPED)) gSvcStatus.dwCheckPoint = 0; else gSvcStatus.dwCheckPoint = dwCheckPoint++; // Report the status of the service to the SCM. SetServiceStatus(gSvcStatusHandle, &gSvcStatus); }
static aug_result setstatus_(DWORD state) { SERVICE_STATUS status; status.dwServiceType = SERVICE_WIN32_OWN_PROCESS; status.dwCurrentState = state; status.dwControlsAccepted = state == SERVICE_START_PENDING ? 0 : SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; status.dwWin32ExitCode = 0; status.dwServiceSpecificExitCode = 0; status.dwCheckPoint = 0; status.dwWaitHint = 0; if (!SetServiceStatus(ssh_, &status)) { aug_setwin32error(aug_tlx, __FILE__, __LINE__, GetLastError()); return -1; } return 0; }
DWORD WINAPI service_ctrl_handler(DWORD ctrl, DWORD type, LPVOID data, LPVOID ctx) { DWORD ret = NO_ERROR; GAService *service = &ga_state->service; switch (ctrl) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: quit_handler(SIGTERM); service->status.dwCurrentState = SERVICE_STOP_PENDING; SetServiceStatus(service->status_handle, &service->status); break; default: ret = ERROR_CALL_NOT_IMPLEMENTED; } return ret; }
inline void CServiceModule::Handler(DWORD dwOpcode) { switch (dwOpcode) { case SERVICE_CONTROL_STOP: SetServiceStatus(SERVICE_STOP_PENDING); PostThreadMessage(dwThreadID, WM_QUIT, 0, 0); break; case SERVICE_CONTROL_PAUSE: break; case SERVICE_CONTROL_CONTINUE: break; case SERVICE_CONTROL_INTERROGATE: break; case SERVICE_CONTROL_SHUTDOWN: break; default: LogEvent(EVENTLOG_ERROR_TYPE, LE_BadServiceReq); } }
void co_winnt_sc_report_status(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint) { static DWORD dwCheckPoint = 1; if (dwCurrentState == SERVICE_START_PENDING) ssStatus.dwControlsAccepted = 0; else ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; ssStatus.dwCurrentState = dwCurrentState; ssStatus.dwWin32ExitCode = dwWin32ExitCode; ssStatus.dwWaitHint = dwWaitHint; if ((dwCurrentState == SERVICE_RUNNING) || (dwCurrentState == SERVICE_STOPPED)) ssStatus.dwCheckPoint = 0; else ssStatus.dwCheckPoint = dwCheckPoint++; SetServiceStatus(sshStatusHandle, &ssStatus); }
/** Reports our current status to the SCM. */ static BOOL vgsvcWinSetStatus(DWORD dwStatus, DWORD dwCheckPoint) { if (g_hWinServiceStatus == NULL) /* Program could be in testing mode, so no service environment available. */ return FALSE; VGSvcVerbose(2, "Setting service status to: %ld\n", dwStatus); g_dwWinServiceLastStatus = dwStatus; SERVICE_STATUS ss; RT_ZERO(ss); ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS; ss.dwCurrentState = dwStatus; /* Don't accept controls when in start pending state. */ if (ss.dwCurrentState != SERVICE_START_PENDING) { ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; /* Don't use SERVICE_ACCEPT_SESSIONCHANGE on Windows 2000 or earlier. This makes SCM angry. */ char szOSVersion[32]; int rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szOSVersion, sizeof(szOSVersion)); if (RT_SUCCESS(rc)) { if (RTStrVersionCompare(szOSVersion, "5.1") >= 0) ss.dwControlsAccepted |= SERVICE_ACCEPT_SESSIONCHANGE; } else VGSvcError("Error determining OS version, rc=%Rrc\n", rc); } ss.dwWin32ExitCode = NO_ERROR; ss.dwServiceSpecificExitCode = 0; /* Not used */ ss.dwCheckPoint = dwCheckPoint; ss.dwWaitHint = 3000; BOOL fStatusSet = SetServiceStatus(g_hWinServiceStatus, &ss); if (!fStatusSet) VGSvcError("Error reporting service status=%ld (controls=%x, checkpoint=%ld) to SCM: %ld\n", dwStatus, ss.dwControlsAccepted, dwCheckPoint, GetLastError()); return fStatusSet; }
STATIC NET_API_STATUS AlUpdateStatus( VOID ) /*++ Routine Description: This routine updates the Alerter service status with the Service Controller. Arguments: None. Return Value: NET_API_STATUS - NERR_Success or reason for failure. --*/ { NET_API_STATUS status = NERR_Success; if (AlGlobalData.StatusHandle == (SERVICE_STATUS_HANDLE) NULL) { NetpKdPrint(( "[Alerter] Cannot call SetServiceStatus, no status handle.\n" )); return ERROR_INVALID_HANDLE; } if (! SetServiceStatus(AlGlobalData.StatusHandle, &AlGlobalData.Status)) { status = GetLastError(); IF_DEBUG(MAIN) { NetpKdPrint(("[Alerter] SetServiceStatus error %lu\n", status)); } }
/* {{{ proto bool win32_set_service_status(int status, [int checkpoint]) Update the service status */ static PHP_FUNCTION(win32_set_service_status) { long status; long checkpoint = 0; if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &status, &checkpoint)) { RETURN_FALSE; } SVCG(st.dwCurrentState) = status; /* CheckPoints are only valid for the SERVICE_*_PENDING statuses. */ if ((status == SERVICE_CONTINUE_PENDING) || (status == SERVICE_PAUSE_PENDING) || (status == SERVICE_START_PENDING) || (status == SERVICE_STOP_PENDING)) { SVCG(st.dwCheckPoint) = checkpoint; } if (!SetServiceStatus(SVCG(sh), &SVCG(st))) { RETURN_LONG(GetLastError()) } else { RETURN_TRUE; } }
static VOID UpdateServiceStatus(DWORD dwState) { ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; ServiceStatus.dwCurrentState = dwState; ServiceStatus.dwControlsAccepted = 0; ServiceStatus.dwWin32ExitCode = 0; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = 0; if (dwState == SERVICE_START_PENDING || dwState == SERVICE_STOP_PENDING || dwState == SERVICE_PAUSE_PENDING || dwState == SERVICE_CONTINUE_PENDING) ServiceStatus.dwWaitHint = 10000; else ServiceStatus.dwWaitHint = 0; SetServiceStatus(ServiceStatusHandle, &ServiceStatus); }
static void WINAPI handler(DWORD sigint) { switch(sigint) { case 128: // control::request("reload"); return; case 129: // control::request("snapshot"); case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: status.dwCurrentState = SERVICE_STOP_PENDING; status.dwWin32ExitCode = 0; status.dwCheckPoint = 0; status.dwWaitHint = 6000; SetServiceStatus(hStatus, &status); // control::request("down"); break; default: break; } }
void c_service_wrapper::service_main(long unsigned int argc, wchar_t **argv) { m_service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS; m_service_status.dwCurrentState = SERVICE_RUNNING; // TODO rm? m_service_status.dwControlsAccepted = SERVICE_ACCEPT_STOP; m_service_status.dwWin32ExitCode = NO_ERROR; m_service_status.dwServiceSpecificExitCode = 0; m_service_status.dwCheckPoint = 0; m_service_status.dwWaitHint = 0; m_handle_status = RegisterServiceCtrlHandler(L"galaxy42_service", reinterpret_cast<LPHANDLER_FUNCTION>(&c_service_wrapper::control_handler)); if (m_handle_status == 0) return; // ERROR m_service_status.dwCurrentState = SERVICE_RUNNING; SetServiceStatus(m_handle_status, &m_service_status); while (m_service_status.dwCurrentState == SERVICE_RUNNING) { run_child_process(); WaitForSingleObject(m_process_info.hProcess, INFINITE); CloseHandle(m_process_info.hProcess); CloseHandle(m_process_info.hThread); } }
/* Handler function for service start/stop from the service */ void WINAPI ServiceCtrlHandler(DWORD control) { switch (control) { case SERVICE_CONTROL_SHUTDOWN: case SERVICE_CONTROL_STOP: /* Shutdown freeswitch */ switch_core_destroy(); /* set service status values */ status.dwCurrentState = SERVICE_STOPPED; status.dwWin32ExitCode = 0; status.dwCheckPoint = 0; status.dwWaitHint = 0; break; case SERVICE_CONTROL_INTERROGATE: /* we already set the service status every time it changes. */ /* if there are other times we change it and don't update, we should do so here */ break; } SetServiceStatus(hStatus, &status); }