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();
return;
}
if (!StartServiceThread())
{
KillService();
return;
}
UpdateSCMStatus(SERVICE_RUNNING, NO_ERROR, 0);
WaitForSingleObject(kill_event, INFINITE);
KillService();
}
static void WINAPI vgsvcWinMain(DWORD argc, LPTSTR *argv)
{
RT_NOREF2(argc, argv);
VGSvcVerbose(2, "Registering service control handler ...\n");
if (g_pfnRegisterServiceCtrlHandlerExA)
g_hWinServiceStatus = g_pfnRegisterServiceCtrlHandlerExA(VBOXSERVICE_NAME, vgsvcWinCtrlHandlerNt5Plus, NULL);
else
g_hWinServiceStatus = RegisterServiceCtrlHandlerA(VBOXSERVICE_NAME, vgsvcWinCtrlHandlerNt4);
if (g_hWinServiceStatus != NULL)
{
VGSvcVerbose(2, "Service control handler registered.\n");
vgsvcWinStart();
}
else
{
DWORD dwErr = GetLastError();
switch (dwErr)
{
case ERROR_INVALID_NAME:
VGSvcError("Invalid service name!\n");
break;
case ERROR_SERVICE_DOES_NOT_EXIST:
VGSvcError("Service does not exist!\n");
break;
default:
VGSvcError("Could not register service control handle! Error: %ld\n", dwErr);
break;
}
}
}
static void WINAPI ServiceDispatch( DWORD numArgs, char **args )
{
(void)numArgs;
(void)args;
intf_thread_t *p_intf = (intf_thread_t *)p_global_intf;
intf_sys_t *p_sys = p_intf->p_sys;
char *psz_modules, *psz_parser;
/* We have to initialize the service-specific stuff */
memset( &p_sys->status, 0, sizeof(SERVICE_STATUS) );
p_sys->status.dwServiceType = SERVICE_WIN32;
p_sys->status.dwCurrentState = SERVICE_START_PENDING;
p_sys->status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
p_sys->hStatus =
RegisterServiceCtrlHandlerA( p_sys->psz_service, &ServiceCtrlHandler );
if( p_sys->hStatus == (SERVICE_STATUS_HANDLE)0 )
{
msg_Err( p_intf, "failed to register service control handler" );
return;
}
/*
* Load background interfaces
*/
psz_modules = var_InheritString( p_intf, "ntservice-extraintf" );
psz_parser = psz_modules;
while( psz_parser && *psz_parser )
{
char *psz_module, *psz_temp;
psz_module = psz_parser;
psz_parser = strchr( psz_module, ',' );
if( psz_parser )
{
*psz_parser = '\0';
psz_parser++;
}
if( asprintf( &psz_temp, "%s,none", psz_module ) != -1 )
{
/* Try to create the interface */
if( intf_Create( pl_Get(p_intf), psz_temp ) )
{
msg_Err( p_intf, "interface \"%s\" initialization failed",
psz_temp );
free( psz_temp );
continue;
}
free( psz_temp );
}
}
free( psz_modules );
/* Initialization complete - report running status */
p_sys->status.dwCurrentState = SERVICE_RUNNING;
p_sys->status.dwCheckPoint = 0;
p_sys->status.dwWaitHint = 0;
SetServiceStatus( p_sys->hStatus, &p_sys->status );
}
void ServiceMain(DWORD dwArgc, LPSTR *lpszArgv) {
SERVICE_STATUS_HANDLE ssh = RegisterServiceCtrlHandlerA(SERVICE_NAME, &Handler);
SERVICE_STATUS ss;
if(ssh == (SERVICE_STATUS_HANDLE)0)
return;
ss.dwCheckPoint = 0;
ss.dwControlsAccepted = 0;
ss.dwCurrentState = SERVICE_RUNNING;
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
ss.dwWaitHint = 0;
ss.dwWin32ExitCode = NO_ERROR;
SetServiceStatus(ssh, &ss);
EntryPoint();
ss.dwCheckPoint = 0;
ss.dwControlsAccepted = 0;
ss.dwCurrentState = SERVICE_STOPPED;
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
ss.dwWaitHint = 0;
ss.dwWin32ExitCode = NO_ERROR;
SetServiceStatus(ssh, &ss);
}
static void WINAPI ServiceMain(void) {
ss.dwServiceType = SERVICE_WIN32;
ss.dwCurrentState = SERVICE_RUNNING;
ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
hStatus = RegisterServiceCtrlHandlerA(server_name, ControlHandler);
SetServiceStatus(hStatus, &ss);
while (ss.dwCurrentState == SERVICE_RUNNING) {
mg_sleep(1000);
}
mg_stop(ctx);
ss.dwCurrentState = SERVICE_STOPPED;
ss.dwWin32ExitCode = (DWORD) -1;
SetServiceStatus(hStatus, &ss);
}
/*
* CNTService::ServiceMain
* Function that provides the entry point for the actual service code.
*/
void CNTService::ServiceMain (DWORD dwArgc, LPTSTR * lpszArgv) {
Log("Entering CNTService::ServiceMain\n");
CNTService *pService = m_pThis;
dwArgc;
lpszArgv;
pService->m_Status.dwCurrentState = SERVICE_START_PENDING;
pService->m_hServiceStatus = RegisterServiceCtrlHandlerA ((LPCSTR) pService->m_szServiceName, Handler);
if (pService->m_hServiceStatus != NULL) {
if (pService->Initialize()) {
pService->m_bIsRunning = TRUE;
pService->m_Status.dwWin32ExitCode = 0;
pService->m_Status.dwCheckPoint = 0;
pService->m_Status.dwWaitHint = 0;
pService->Run();
}
pService->SetStatus (SERVICE_STOPPED);
}
Log("Exiting CNTService::ServiceMain\n");
}
//
// FUNCTION: service_main
//
// PURPOSE: To perform actual initialization of the service
//
// PARAMETERS:
// dwArgc - number of command line arguments
// lpszArgv - array of command line arguments
//
// RETURN VALUE:
// none
//
// COMMENTS:
// This routine performs the service initialization and then calls
// the user defined ServiceStart() routine to perform majority
// of the work.
//
void CNTService::SServiceMain(DWORD dwArgc, LPTSTR *lpszArgv) {
// register our service control handler:
m_ServiceStatusHandle = RegisterServiceCtrlHandlerA( m_ServiceName.GetBuffer(), ServiceCtrl);
if (m_ServiceStatusHandle) {
m_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
m_ServiceStatus.dwServiceSpecificExitCode = 0;
// report the status to the service control manager.
if (ReportStatusToSCMgr(
SERVICE_START_PENDING, // service state
NO_ERROR, // exit code
3000)) {// wait hint
ServiceStart();
}
}
// try to report the stopped status to the service control manager.
if (m_ServiceStatusHandle)
ReportStatusToSCMgr(SERVICE_STOPPED, 0, 0);
}
inline void CServiceModule::ServiceMain(DWORD /* dwArgc */, LPSTR* /* lpszArgv */)
{
// Register the control request handler
m_status.dwCurrentState = SERVICE_START_PENDING;
m_hServiceStatus = RegisterServiceCtrlHandlerA(m_szServiceName, _Handler);
if (m_hServiceStatus == NULL)
{
LogEvent(EVENTLOG_ERROR_TYPE, LE_NoServiceHandler);
return;
}
SetServiceStatus(SERVICE_START_PENDING);
m_status.dwWin32ExitCode = S_OK;
m_status.dwCheckPoint = 0;
m_status.dwWaitHint = 0;
// When the Run function returns, the service has stopped.
Run();
SetServiceStatus(SERVICE_STOPPED);
LogEvent(EVENTLOG_INFORMATION_TYPE, LE_ServiceStopped);
}
void WINAPI CServiceModule::ServiceMain(
DWORD dwArgc,
LPSTR *lpszArgv)
{
HRESULT hr;
g.ssh = RegisterServiceCtrlHandlerA(c_szSvcName, ServiceControl);
if (!g.ssh)
{
SetSvcStatus(SERVICE_STOPPED, GetLastError());
return;
}
SetSvcStatus(SERVICE_START_PENDING, NO_ERROR);
hr = FedSrv_Init();
if (SUCCEEDED(hr))
SetSvcStatus(SERVICE_RUNNING, NO_ERROR);
else
SetSvcStatus(SERVICE_STOPPED, GetLastError());
}
