602 строки
17 KiB
C
602 строки
17 KiB
C
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
// PARTICULAR PURPOSE.
|
|
//
|
|
// Copyright (C) 1993-1997 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// MODULE: service.c
|
|
//
|
|
// PURPOSE: Implements functions required by all services
|
|
// windows.
|
|
//
|
|
// FUNCTIONS:
|
|
// main(int argc, char **argv);
|
|
// service_ctrl(DWORD dwCtrlCode);
|
|
// service_main(DWORD dwArgc, LPTSTR *lpszArgv);
|
|
// CmdInstallService();
|
|
// CmdRemoveService();
|
|
// ControlHandler ( DWORD dwCtrlType );
|
|
// GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize );
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
// AUTHOR: Craig Link - Microsoft Developer Support
|
|
//
|
|
|
|
/*
|
|
* modified Mar.07, 2002 by Feng Qin <fqin@ncsa.uiuc.edu>
|
|
* Mar.15, 2002
|
|
*
|
|
* removed some functions we don't use at all
|
|
* add code to start the service immediately after service is installed
|
|
*
|
|
* $Id: service.c,v 1.1.1.1 2004/05/18 01:50:44 kgibbs Exp $
|
|
*/
|
|
|
|
#ifdef WIN32
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <process.h>
|
|
#include <tchar.h>
|
|
|
|
#include "service.h"
|
|
|
|
|
|
|
|
// internal variables
|
|
SERVICE_STATUS ssStatus; // current status of the service
|
|
SERVICE_STATUS_HANDLE sshStatusHandle;
|
|
DWORD dwErr = 0;
|
|
TCHAR szErr[256];
|
|
|
|
//
|
|
// 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 WINAPI service_main(DWORD dwArgc, LPTSTR *lpszArgv) {
|
|
// register our service control handler:
|
|
//
|
|
sshStatusHandle = RegisterServiceCtrlHandler( TEXT(SZSERVICENAME), service_ctrl);
|
|
|
|
if ( !sshStatusHandle )
|
|
goto clean;
|
|
|
|
// SERVICE_STATUS members that don't change in example
|
|
//
|
|
ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
|
|
ssStatus.dwServiceSpecificExitCode = 0;
|
|
|
|
// report the status to the service control manager.
|
|
//
|
|
if ( !ReportStatusToSCMgr(
|
|
SERVICE_START_PENDING, // service state
|
|
NO_ERROR, // exit code
|
|
3000) ) // wait hint
|
|
goto clean;
|
|
|
|
|
|
ServiceStart( dwArgc, lpszArgv );
|
|
|
|
clean:
|
|
|
|
// try to report the stopped status to the service control manager.
|
|
//
|
|
if ( sshStatusHandle )
|
|
(VOID)ReportStatusToSCMgr(
|
|
SERVICE_STOPPED,
|
|
dwErr,
|
|
0);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: service_ctrl
|
|
//
|
|
// PURPOSE: This function is called by the SCM whenever
|
|
// ControlService() is called on this service.
|
|
//
|
|
// PARAMETERS:
|
|
// dwCtrlCode - type of control requested
|
|
//
|
|
// RETURN VALUE:
|
|
// none
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
VOID WINAPI service_ctrl(DWORD dwCtrlCode) {
|
|
// Handle the requested control code.
|
|
//
|
|
switch ( dwCtrlCode ) {
|
|
// Stop the service.
|
|
//
|
|
// SERVICE_STOP_PENDING should be reported before
|
|
// setting the Stop Event - hServerStopEvent - in
|
|
// ServiceStop(). This avoids a race condition
|
|
// which may result in a 1053 - The Service did not respond...
|
|
// error.
|
|
case SERVICE_CONTROL_STOP:
|
|
ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0);
|
|
ServiceStop();
|
|
|
|
return;
|
|
|
|
// Update the service status.
|
|
//
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
break;
|
|
|
|
// invalid control code
|
|
//
|
|
default:
|
|
break;
|
|
|
|
}
|
|
ReportStatusToSCMgr(SERVICE_STOPPED, NO_ERROR, 0);
|
|
// ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: ReportStatusToSCMgr()
|
|
//
|
|
// PURPOSE: Sets the current status of the service and
|
|
// reports it to the Service Control Manager
|
|
//
|
|
// PARAMETERS:
|
|
// dwCurrentState - the state of the service
|
|
// dwWin32ExitCode - error code to report
|
|
// dwWaitHint - worst case estimate to next checkpoint
|
|
//
|
|
// RETURN VALUE:
|
|
// TRUE - success
|
|
// FALSE - failure
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
BOOL ReportStatusToSCMgr(DWORD dwCurrentState,
|
|
DWORD dwWin32ExitCode,
|
|
DWORD dwWaitHint) {
|
|
static DWORD dwCheckPoint = 1;
|
|
BOOL fResult = TRUE;
|
|
|
|
|
|
if ( dwCurrentState == SERVICE_START_PENDING )
|
|
ssStatus.dwControlsAccepted = 0;
|
|
else
|
|
ssStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
|
|
|
|
ssStatus.dwCurrentState = dwCurrentState;
|
|
ssStatus.dwWin32ExitCode = dwWin32ExitCode;
|
|
ssStatus.dwWaitHint = dwWaitHint;
|
|
|
|
if ( ( dwCurrentState == SERVICE_RUNNING ) ||
|
|
( dwCurrentState == SERVICE_STOPPED ) )
|
|
ssStatus.dwCheckPoint = 0;
|
|
else
|
|
ssStatus.dwCheckPoint = dwCheckPoint++;
|
|
|
|
|
|
// Report the status of the service to the service control manager.
|
|
//
|
|
if ( !(fResult = SetServiceStatus( sshStatusHandle, &ssStatus)) ) {
|
|
AddToMessageLog(TEXT("SetServiceStatus"));
|
|
}
|
|
return fResult;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: AddToMessageLog(LPTSTR lpszMsg)
|
|
//
|
|
// PURPOSE: Allows any thread to log an error message
|
|
//
|
|
// PARAMETERS:
|
|
// lpszMsg - text for message
|
|
//
|
|
// RETURN VALUE:
|
|
// none
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
VOID AddToMessageLog(LPTSTR lpszMsg) {
|
|
TCHAR szMsg[256];
|
|
HANDLE hEventSource;
|
|
LPTSTR lpszStrings[2];
|
|
|
|
|
|
dwErr = GetLastError();
|
|
|
|
// Use event logging to log the error.
|
|
//
|
|
hEventSource = RegisterEventSource(NULL, TEXT(SZSERVICENAME));
|
|
|
|
printf(lpszMsg);
|
|
|
|
_stprintf(szMsg, TEXT("%s error: %d"), TEXT(SZSERVICENAME), dwErr);
|
|
lpszStrings[0] = szMsg;
|
|
lpszStrings[1] = lpszMsg;
|
|
|
|
if ( hEventSource != NULL ) {
|
|
ReportEvent(hEventSource, // handle of event source
|
|
EVENTLOG_ERROR_TYPE, // event type
|
|
0, // event category
|
|
0, // event ID
|
|
NULL, // current user's SID
|
|
2, // strings in lpszStrings
|
|
0, // no bytes of raw data
|
|
lpszStrings, // array of error strings
|
|
NULL); // no raw data
|
|
|
|
(VOID) DeregisterEventSource(hEventSource);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
//
|
|
// The following code handles service installation and removal
|
|
//
|
|
//
|
|
// FUNCTION: CmdInstallService()
|
|
//
|
|
// PURPOSE: Installs the service and Starts it
|
|
//
|
|
// PARAMETERS:
|
|
// argc: number of arguments
|
|
// argv: all of the arguments including the program's name
|
|
//
|
|
// RETURN VALUE:
|
|
// none
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
void CmdInstallService(int argc, char **argv) {
|
|
SC_HANDLE schService;
|
|
SC_HANDLE schSCManager;
|
|
|
|
TCHAR szPath[512];
|
|
|
|
if ( GetModuleFileName( NULL, szPath, 512 ) == 0 ) {
|
|
_tprintf(TEXT("Unable to install %s - %s\n"), TEXT(SZSERVICEDISPLAYNAME), GetLastErrorText(szErr, 256));
|
|
return;
|
|
}
|
|
|
|
schSCManager = OpenSCManager(
|
|
NULL, // machine (NULL == local)
|
|
NULL, // database (NULL == default)
|
|
SC_MANAGER_ALL_ACCESS // access required
|
|
);
|
|
if ( schSCManager ) {
|
|
schService = OpenService(schSCManager, TEXT(SZSERVICENAME), SERVICE_ALL_ACCESS);
|
|
if ( !schService ) {
|
|
schService = CreateService(
|
|
schSCManager, // SCManager database
|
|
TEXT(SZSERVICENAME), // name of service
|
|
TEXT(SZSERVICEDISPLAYNAME), // name to display
|
|
SERVICE_ALL_ACCESS, // desired access
|
|
SERVICE_WIN32_OWN_PROCESS, // service type
|
|
SERVICE_DEMAND_START, // start type
|
|
SERVICE_ERROR_NORMAL, // error control type
|
|
szPath, // service's binary
|
|
NULL, // no load ordering group
|
|
NULL, // no tag identifier
|
|
TEXT(SZDEPENDENCIES), // dependencies
|
|
NULL, // LocalSystem account
|
|
NULL); // no password
|
|
} else {
|
|
_tprintf(TEXT("%s already installed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
}
|
|
if ( schService ) {
|
|
if ( QueryServiceStatus( schService, &ssStatus ) ) {
|
|
int rc;
|
|
if ( ssStatus.dwCurrentState == SERVICE_STOPPED ) {
|
|
rc = StartService(schService, argc-1, argv+1);
|
|
}
|
|
|
|
|
|
if ( rc != 0 )
|
|
_tprintf(TEXT("%s started.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
}
|
|
|
|
CloseServiceHandle(schService);
|
|
} else {
|
|
_tprintf(TEXT("CreateService failed - %s\n"), GetLastErrorText(szErr, 256));
|
|
}
|
|
|
|
CloseServiceHandle(schSCManager);
|
|
} else
|
|
_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: CmdRemoveService()
|
|
//
|
|
// PURPOSE: Stops and removes the service
|
|
//
|
|
// PARAMETERS:
|
|
// none
|
|
//
|
|
// RETURN VALUE:
|
|
// TRUE: service exists and is removed
|
|
// FALSE: service doesn't exist
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
BOOL CmdRemoveService() {
|
|
BOOL isExist = FALSE;
|
|
SC_HANDLE schService;
|
|
SC_HANDLE schSCManager;
|
|
|
|
schSCManager = OpenSCManager(
|
|
NULL, // machine (NULL == local)
|
|
NULL, // database (NULL == default)
|
|
SC_MANAGER_ALL_ACCESS // access required
|
|
);
|
|
if ( schSCManager ) {
|
|
schService = OpenService(schSCManager, TEXT(SZSERVICENAME), SERVICE_ALL_ACCESS);
|
|
|
|
if ( schService ) {
|
|
isExist = TRUE;
|
|
// try to stop the service
|
|
if ( ControlService( schService, SERVICE_CONTROL_STOP, &ssStatus ) ) {
|
|
_tprintf(TEXT("Stopping %s."), TEXT(SZSERVICEDISPLAYNAME));
|
|
Sleep( 1000 );
|
|
|
|
while ( QueryServiceStatus( schService, &ssStatus ) ) {
|
|
if ( ssStatus.dwCurrentState == SERVICE_STOP_PENDING ) {
|
|
_tprintf(TEXT("."));
|
|
Sleep( 1000 );
|
|
} else
|
|
break;
|
|
}
|
|
|
|
if ( ssStatus.dwCurrentState == SERVICE_STOPPED )
|
|
_tprintf(TEXT("\n%s stopped.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
else
|
|
_tprintf(TEXT("\n%s failed to stop.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
|
|
}
|
|
|
|
// now remove the service
|
|
if ( DeleteService(schService) )
|
|
_tprintf(TEXT("%s removed.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
else
|
|
_tprintf(TEXT("DeleteService failed - %s\n"), GetLastErrorText(szErr,256));
|
|
|
|
|
|
CloseServiceHandle(schService);
|
|
}
|
|
|
|
CloseServiceHandle(schSCManager);
|
|
} else
|
|
_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
|
|
|
|
return isExist;
|
|
}
|
|
|
|
//
|
|
// FUNCTION: CmdStartService()
|
|
//
|
|
// PURPOSE: Start service if it exists
|
|
//
|
|
// PARAMETERS:
|
|
// argc: number of arguments
|
|
// argv: arguments including program's name
|
|
//
|
|
// RETURN VALUE:
|
|
// TRUE: service exists and is started
|
|
// FALSE: service doesn't exist
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
BOOL CmdStartService(int argc, char **argv) {
|
|
BOOL isExist = FALSE;
|
|
SC_HANDLE schService;
|
|
SC_HANDLE schSCManager;
|
|
|
|
schSCManager = OpenSCManager(
|
|
NULL, // machine (NULL == local)
|
|
NULL, // database (NULL == default)
|
|
SC_MANAGER_ALL_ACCESS // access required
|
|
);
|
|
if ( schSCManager ) {
|
|
schService = OpenService(schSCManager, TEXT(SZSERVICENAME), SERVICE_ALL_ACCESS);
|
|
|
|
if ( schService ) {
|
|
isExist = TRUE;
|
|
if ( QueryServiceStatus( schService, &ssStatus ) ) {
|
|
int rc;
|
|
if ( ssStatus.dwCurrentState == SERVICE_STOPPED ) {
|
|
rc = StartService(schService, argc-1, argv+1);
|
|
}
|
|
|
|
|
|
if ( rc != 0 )
|
|
_tprintf(TEXT("%s started.\n"), TEXT(SZSERVICEDISPLAYNAME) );
|
|
}
|
|
CloseServiceHandle(schService);
|
|
}
|
|
CloseServiceHandle(schSCManager);
|
|
} else
|
|
_tprintf(TEXT("OpenSCManager failed - %s\n"), GetLastErrorText(szErr,256));
|
|
|
|
return isExist;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// FUNCTION: GetLastErrorText
|
|
//
|
|
// PURPOSE: copies error message text to string
|
|
//
|
|
// PARAMETERS:
|
|
// lpszBuf - destination buffer
|
|
// dwSize - size of buffer
|
|
//
|
|
// RETURN VALUE:
|
|
// destination buffer
|
|
//
|
|
// COMMENTS:
|
|
//
|
|
LPTSTR GetLastErrorText( LPTSTR lpszBuf, DWORD dwSize ) {
|
|
DWORD dwRet;
|
|
LPTSTR lpszTemp = NULL;
|
|
|
|
dwRet = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
NULL,
|
|
GetLastError(),
|
|
LANG_NEUTRAL,
|
|
(LPTSTR)&lpszTemp,
|
|
0,
|
|
NULL );
|
|
|
|
// supplied buffer is not long enough
|
|
if ( !dwRet || ( (long)dwSize < (long)dwRet+14 ) )
|
|
lpszBuf[0] = TEXT('\0');
|
|
else {
|
|
lpszTemp[lstrlen(lpszTemp)-2] = TEXT('\0'); //remove cr and newline character
|
|
_stprintf( lpszBuf, TEXT("%s (0x%x)"), lpszTemp, GetLastError() );
|
|
}
|
|
|
|
if ( lpszTemp )
|
|
LocalFree((HLOCAL) lpszTemp );
|
|
|
|
return lpszBuf;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------
|
|
* ServiceStart
|
|
*
|
|
* each time starting the service, this is the entry point of the service.
|
|
* Start the service, certainly it is on server-mode
|
|
*
|
|
*-------------------------------------------------------------------- */
|
|
VOID ServiceStart (DWORD dwArgc, LPTSTR *lpszArgv) {
|
|
|
|
// report the status to the service control manager.
|
|
//
|
|
if ( !ReportStatusToSCMgr(
|
|
SERVICE_START_PENDING, // service state
|
|
NO_ERROR, // exit code
|
|
3000) ) // wait hint
|
|
goto clean;
|
|
|
|
thread_Settings* ext_gSettings = new thread_Settings;
|
|
|
|
// Initialize settings to defaults
|
|
Settings_Initialize( ext_gSettings );
|
|
// read settings from environment variables
|
|
Settings_ParseEnvironment( ext_gSettings );
|
|
// read settings from command-line parameters
|
|
Settings_ParseCommandLine( dwArgc, lpszArgv, ext_gSettings );
|
|
|
|
// report the status to the service control manager.
|
|
//
|
|
if ( !ReportStatusToSCMgr(
|
|
SERVICE_START_PENDING, // service state
|
|
NO_ERROR, // exit code
|
|
3000) ) // wait hint
|
|
goto clean;
|
|
|
|
// if needed, redirect the output into a specified file
|
|
if ( !isSTDOUT( ext_gSettings ) ) {
|
|
redirect( ext_gSettings->mOutputFileName );
|
|
}
|
|
|
|
// report the status to the service control manager.
|
|
//
|
|
if ( !ReportStatusToSCMgr(
|
|
SERVICE_START_PENDING, // service state
|
|
NO_ERROR, // exit code
|
|
3000) ) // wait hint
|
|
goto clean;
|
|
|
|
// initialize client(s)
|
|
if ( ext_gSettings->mThreadMode == kMode_Client ) {
|
|
client_init( ext_gSettings );
|
|
}
|
|
|
|
// start up the reporter and client(s) or listener
|
|
{
|
|
thread_Settings *into = NULL;
|
|
#ifdef HAVE_THREAD
|
|
Settings_Copy( ext_gSettings, &into );
|
|
into->mThreadMode = kMode_Reporter;
|
|
into->runNow = ext_gSettings;
|
|
#else
|
|
into = ext_gSettings;
|
|
#endif
|
|
thread_start( into );
|
|
}
|
|
|
|
// report the status to the service control manager.
|
|
//
|
|
if ( !ReportStatusToSCMgr(
|
|
SERVICE_RUNNING, // service state
|
|
NO_ERROR, // exit code
|
|
0) ) // wait hint
|
|
goto clean;
|
|
|
|
clean:
|
|
// wait for other (client, server) threads to complete
|
|
thread_joinall();
|
|
}
|
|
|
|
|
|
//
|
|
// FUNCTION: ServiceStop
|
|
//
|
|
// PURPOSE: Stops the service
|
|
//
|
|
// PARAMETERS:
|
|
// none
|
|
//
|
|
// RETURN VALUE:
|
|
// none
|
|
//
|
|
// COMMENTS:
|
|
// If a ServiceStop procedure is going to
|
|
// take longer than 3 seconds to execute,
|
|
// it should spawn a thread to execute the
|
|
// stop code, and return. Otherwise, the
|
|
// ServiceControlManager will believe that
|
|
// the service has stopped responding.
|
|
//
|
|
VOID ServiceStop() {
|
|
#ifdef HAVE_THREAD
|
|
Sig_Interupt( 1 );
|
|
#else
|
|
sig_exit(1);
|
|
#endif
|
|
}
|
|
|
|
#endif
|