/*++
Copyright (c) 1997 Microsoft Corporation
Module Name :
svcinfo.cpp
Abstract:
This module contains the common code for the sti services which involves the
Service Controller dispatch functions.
Author:
Vlad Sadovsky (vlads) 22-Sep-1997
Environment:
User Mode - Win32
Revision History:
22-Sep-1997 VladS created
--*/
//
// Include Headers
//
#include "cplusinc.h"
#include "sticomm.h"
#include <svcinfo.h>
BOOL g_fIgnoreSC = TRUE;
SVC_INFO::SVC_INFO(
IN LPCTSTR lpszServiceName,
IN TCHAR * lpszModuleName,
IN PFN_SERVICE_SPECIFIC_INITIALIZE pfnInitialize,
IN PFN_SERVICE_SPECIFIC_CLEANUP pfnCleanup,
IN PFN_SERVICE_SPECIFIC_PNPPWRHANDLER pfnPnpPower
)
/*++
Desrcription:
Contructor for SVC_INFO class.
This constructs a new service info object for the service specified.
Arguments:
lpszServiceName
name of the service to be created.
lpszModuleName
name of the module for loading string resources.
pfnInitialize
pointer to function to be called for initialization of
service specific data
pfnCleanup
pointer to function to be called for cleanup of service
specific data
--*/
{
ASSERT( pfnInitialize != NULL && pfnCleanup != NULL && pfnPnpPower!=NULL);
m_sServiceName.Copy(lpszServiceName) ;
m_sModuleName.Copy(lpszModuleName);
//
// Initialize the service status structure.
//
m_svcStatus.dwServiceType = SERVICE_WIN32_SHARE_PROCESS;
m_svcStatus.dwCurrentState = SERVICE_STOPPED;
m_svcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_PAUSE_CONTINUE
| SERVICE_ACCEPT_SHUTDOWN;
m_svcStatus.dwWin32ExitCode = NO_ERROR;
m_svcStatus.dwServiceSpecificExitCode = NO_ERROR;
m_svcStatus.dwCheckPoint = 0;
m_svcStatus.dwWaitHint = 0;
//
// Initialize Call back functions
//
m_pfnInitialize = pfnInitialize;
m_pfnCleanup = pfnCleanup;
m_pfnPnpPower = pfnPnpPower;
m_dwSignature = SIGNATURE_SVC;
m_hShutdownEvent= NULL;
return;
} // SVC_INFO::SVC_INFO()
SVC_INFO::~SVC_INFO( VOID)
/*++
Description:
Cleanup the SvcInfo object. If the service is not already
terminated, it terminates the service before cleanup.
Arguments:
None
Returns:
None
--*/
{
if ( m_hShutdownEvent != NULL) {
::CloseHandle( m_hShutdownEvent);
}
m_dwSignature = SIGNATURE_SVC_FREE;
} // SVC_INFO::~SVC_INFO()
DWORD
SVC_INFO::StartServiceOperation(
IN PFN_SERVICE_CTRL_HANDLER pfnCtrlHandler
)
/*++
Description:
Starts the operation of service instantiated in the given
Service Info Object.
Arguments:
pfnCtrlHandler
pointer to a callback function for handling dispatch of
service controller requests. A separate function is required
since Service Controller call back function does not send
context information.
Returns:
NO_ERROR on success and Win32 error code if any failure.
--*/
{
DWORD err;
DWORD cbBuffer;
BOOL fInitCalled = FALSE;
if ( !IsValid()) {
//
// Not successfully initialized.
//
return ( ERROR_INVALID_FUNCTION);
}
if ( !g_fIgnoreSC ) {
m_hsvcStatus = RegisterServiceCtrlHandler(
QueryServiceName(),
pfnCtrlHandler
);
//
// Register the Control Handler routine.
//
if( m_hsvcStatus == NULL_SERVICE_STATUS_HANDLE ) {
err = GetLastError();
goto Cleanup;
}
} else {
m_hsvcStatus = NULL_SERVICE_STATUS_HANDLE;
}
//
// Update the service status.
//
err = UpdateServiceStatus( SERVICE_START_PENDING,
NO_ERROR,
1,
SERVICE_START_WAIT_HINT );
if( err != NO_ERROR ) {
goto Cleanup;
}
//
// Initialize the service common components
//
#ifdef BUGBUG
if ( !InitializeNTSecurity()) {
err = GetLastError();
goto Cleanup;
}
#endif
//
// Initialize the various service specific components.
//
err = ( *m_pfnInitialize)( this);
fInitCalled = TRUE;
if( err != NO_ERROR ) {
goto Cleanup;
}
//
// Create shutdown event.
//
m_hShutdownEvent = CreateEvent( NULL, // lpsaSecurity
TRUE, // fManualReset
FALSE, // fInitialState
NULL ); // lpszEventName
if( m_hShutdownEvent == NULL )
{
err = GetLastError();
goto Cleanup;
}
//
// Update the service status.
//
err = UpdateServiceStatus( SERVICE_RUNNING,
NO_ERROR,
0,
0 );
if( err != NO_ERROR ) {
goto Cleanup;
}
//
// Wait for the shutdown event.
//
err = WaitForSingleObject( m_hShutdownEvent,
INFINITE );
if ( err != WAIT_OBJECT_0) {
//
// Error. Unable to wait for single object.
//
}
//
// Stop time. Tell the Service Controller that we're stopping,
// then terminate the various service components.
//
UpdateServiceStatus( SERVICE_STOP_PENDING,
0,
1,
SERVICE_STOP_WAIT_HINT );
//
// Destroy the shutdown event.
//
if( m_hShutdownEvent != NULL ) {
if ( ! CloseHandle( m_hShutdownEvent ) ) {
err = GetLastError();
}
m_hShutdownEvent = NULL;
}
//
// Update the service status.
//
//
// Log successful start
err = UpdateServiceStatus( SERVICE_RUNNING,
NO_ERROR,
0,
0 );
if( err != NO_ERROR )
{
goto Cleanup;
}
return TRUE;
Cleanup:
if ( fInitCalled) {
//
// Cleanup partially initialized modules
//
DWORD err1 = ( *m_pfnCleanup)( this);
if ( err1 != NO_ERROR) {
//
// Compound errors possible
//
if ( err != NO_ERROR) {
}
}
}
//
// If we managed to actually connect to the Service Controller,
// then tell it that we're stopped.
//
if ( m_hsvcStatus != NULL_SERVICE_STATUS_HANDLE )
{
UpdateServiceStatus( SERVICE_STOPPED,
err,
0,
0 );
}
return ( err);
} // SVC_INFO::StartServiceOperation()
DWORD
SVC_INFO::UpdateServiceStatus(
IN DWORD dwState,
IN DWORD dwWin32ExitCode,
IN DWORD dwCheckPoint,
IN DWORD dwWaitHint )
/*++
Description:
Updates the local copy status of service controller status
and reports it to the service controller.
Arguments:
dwState - New service state.
dwWin32ExitCode - Service exit code.
dwCheckPoint - Check point for lengthy state transitions.
dwWaitHint - Wait hint for lengthy state transitions.
Returns:
NO_ERROR on success and returns Win32 error if failure.
On success the status is reported to service controller.
--*/
{
m_svcStatus.dwCurrentState = dwState;
m_svcStatus.dwWin32ExitCode = dwWin32ExitCode;
m_svcStatus.dwCheckPoint = dwCheckPoint;
m_svcStatus.dwWaitHint = dwWaitHint;
if ( !g_fIgnoreSC ) {
return ReportServiceStatus();
} else {
return ( NO_ERROR);
}
} // SVC_INFO::UpdateServiceStatus()
DWORD
SVC_INFO::ReportServiceStatus( VOID)
/*++
Description:
Wraps the call to SetServiceStatus() function.
Prints the service status data if need be
Arguments:
None
Returns:
NO_ERROR if successful. other Win32 error code on failure.
If successfull the new status has been reported to the service
controller.
--*/
{
DWORD err = NO_ERROR;
if ( !g_fIgnoreSC ) {
if( !SetServiceStatus( m_hsvcStatus, &m_svcStatus ) ) {
err = GetLastError();
}
} else {
err = NO_ERROR;
}
return err;
} // SVC_INFO::ReportServiceStatus()
VOID
SVC_INFO::ServiceCtrlHandler ( IN DWORD dwOpCode)
/*++
Description:
This function received control requests from the service controller.
It runs in the context of service controller's dispatcher thread and
performs the requested function.
( Note: Avoid time consuming operations in this function.)
Arguments:
dwOpCode
indicates the requested operation. This should be
one of the SERVICE_CONTROL_* manifests.
Returns:
None. If successful, then the state of the service might be changed.
Note:
if an operation ( especially SERVICE_CONTROL_STOP) is very lengthy,
then this routine should report a STOP_PENDING status and create
a worker thread to do the dirty work. The worker thread would then
perform the necessary work and for reporting timely wait hints and
final SERVICE_STOPPED status.
--*/
{
//
// Interpret the opcode.
//
switch( dwOpCode )
{
case SERVICE_CONTROL_INTERROGATE :
InterrogateService();
break;
case SERVICE_CONTROL_STOP :
StopService();
break;
case SERVICE_CONTROL_PAUSE :
PauseService();
break;
case SERVICE_CONTROL_CONTINUE :
ContinueService();
break;
case SERVICE_CONTROL_SHUTDOWN :
ShutdownService();
break;
default :
ASSERTSZ(FALSE,TEXT("Unrecognized Service Opcode"));
break;
}
//
// Report the current service status back to the Service
// Controller. The workers called to implement the OpCodes
// should set the m_svcStatus.dwCurrentState field if
// the service status changed.
//
ReportServiceStatus();
} // SVC_INFO::ServiceCtrlHandler()
VOID
SVC_INFO::InterrogateService( VOID )
/*++
Description:
This function interrogates with the service status.
Actually, nothing needs to be done here; the
status is always updated after a service control.
We have this function here to provide useful
debug info.
--*/
{
return;
} // SVC_INFO::InterrogateService()
VOID
SVC_INFO::StopService( VOID )
/*++
Description:
Stops the service. If the stop cannot be performed in a
timely manner, a worker thread needs to be created to do the
original cleanup work.
Returns:
None. If successful, then the service will be stopped.
The final action of this function is signal the handle for
shutdown event. This will release the main thread which does
necessary cleanup work.
--*/
{
m_svcStatus.dwCurrentState = SERVICE_STOP_PENDING;
m_svcStatus.dwCheckPoint = 0;
SetEvent( m_hShutdownEvent);
return;
} // SVC_INFO::StopService()
VOID
SVC_INFO::PauseService( VOID )
/*++
Description:
This function pauses the service. When the service is paused,
no new user sessions are to be accepted, but existing connections
are not effected.
This function must update the SERVICE_STATUS::dwCurrentState
field before returning.
Returns:
None. If successful the service is paused.
--*/
{
m_svcStatus.dwCurrentState = SERVICE_PAUSED;
return;
} // SVC_INFO::PauseService()
VOID
SVC_INFO::ContinueService( VOID )
/*++
Description:
This function restarts ( continues) a paused service. This
will return the service to the running state.
This function must update the m_svcStatus.dwCurrentState
field to running mode before returning.
Returns:
None. If successful then the service is running.
--*/
{
m_svcStatus.dwCurrentState = SERVICE_RUNNING;
return;
} // SVC_INFO::ContinueService()
VOID
SVC_INFO::ShutdownService( VOID )
/*++
Description:
This function performs the shutdown on a service.
This is called during system shutdown.
This function is time constrained. The service controller gives a
maximum of 20 seconds for shutdown for all active services.
Only timely operations should be performed in this function.
Returns:
None. If successful, the service is shutdown.
--*/
{
DWORD dwCurrentState;
//
// Verify state of the service
//
dwCurrentState = QueryCurrentServiceState();
if ((dwCurrentState !=SERVICE_PAUSED) &&
(dwCurrentState !=SERVICE_RUNNING) ) {
ASSERT( FALSE);
return;
}
m_svcStatus.dwCurrentState = SERVICE_STOP_PENDING;
m_svcStatus.dwCheckPoint = 0;
SetEvent( m_hShutdownEvent);
//
// Stop time. Tell the Service Controller that we're stopping,
// then terminate the various service components.
//
UpdateServiceStatus( SERVICE_STOP_PENDING,
0,
1,
SERVICE_STOP_WAIT_HINT );
DWORD err = ( *m_pfnCleanup)( this);
UpdateServiceStatus( SERVICE_STOPPED,
err,
0,
0 );
return;
} // SVC_INFO::ShutdownService()
//
// IUnknown methods. Used only for reference counting
//
STDMETHODIMP
SVC_INFO::QueryInterface( REFIID riid, LPVOID * ppvObj)
{
return E_FAIL;
}
STDMETHODIMP_(ULONG)
SVC_INFO::AddRef( void)
{
::InterlockedIncrement(&m_cRef);
return m_cRef;
}
STDMETHODIMP_(ULONG)
SVC_INFO::Release( void)
{
LONG cNew;
if(!(cNew = ::InterlockedDecrement(&m_cRef))) {
delete this;
}
return cNew;
}
/************************ End of File ***********************/