windows-server-2003/com/svcdlls/trksvcs/common/svcctrl.cxx

// Copyright (c) 1996-1999 Microsoft Corporation

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  File:       svcctrl.cxx
//
//  Contents:   Class for service control interface.
//
//  Classes:
//
//  Functions:
//
//
//
//  History:    18-Nov-96  BillMo      Created.
//
//  Notes:
//
//  Codework:
//
//--------------------------------------------------------------------------

#include "pch.cxx"
#pragma hdrstop

#include "trklib.hxx"

#define THIS_FILE_NUMBER    SVCCTRL_CXX_FILE_NO


// This is static so that we can handle a PNP timing problem
// (see the comment in CSvcCtrlInterface::ServiceHandler).
BOOL CSvcCtrlInterface::_fStoppedOrStopping = TRUE;


//+----------------------------------------------------------------------------
//
//  CSvcCtrlInterface::Initialize
//
//  Register our service control handler with the control dispatcher, and set our state
//  to start-pending.
//
//+----------------------------------------------------------------------------

void
CSvcCtrlInterface::Initialize(const TCHAR *ptszServiceName, IServiceHandler *pServiceHandler)
{
    _fInitializeCalled = TRUE;
    _pServiceHandler = pServiceHandler;
    _fStoppedOrStopping = FALSE;
    _dwCheckPoint = 0;

    // Register with the control dispatcher.

    _ssh = RegisterServiceCtrlHandlerEx(ptszServiceName, ServiceHandler, this );
    if (_ssh == 0)
    {
        TrkReportInternalError( THIS_FILE_NUMBER, __LINE__, HRESULT_FROM_WIN32(GetLastError()),
                                ptszServiceName );
        TrkRaiseLastError();
    }

    // Go to the start-pending state.

    SetServiceStatus(SERVICE_START_PENDING, 0, NO_ERROR);

}



//+----------------------------------------------------------------------------
//
//  CSvcCtrlInterface::ServiceHandler
//
//  This method is called by the control dispatcher.  If we get a stop
//  or shutdown request, automatically send a stop-pending before calling
//  the service's handler.  Interrogate is handled automatically in
//  this routine without bothering to call the service.
//
//+----------------------------------------------------------------------------

DWORD   // static
CSvcCtrlInterface::ServiceHandler(DWORD dwControl,
                                  DWORD dwEventType,
                                  PVOID EventData,
                                  PVOID pData)
{
    //  NOTE:   In services.exe, this method is called on the one and only ServiceHandler
    //          thread.  So while we execute, no other service in this process can
    //          receive notifications.  Thus it is important that we do nothing
    //          blocking or time-consuming here.

    DWORD       dwRet = NO_ERROR;
    CSvcCtrlInterface *pThis = (CSvcCtrlInterface*)pData;

#if DBG
    if( SERVICE_CONTROL_STOP == dwControl )
        TrkLog(( TRKDBG_SVR|TRKDBG_WKS, TEXT("\n") ));
    TrkLog(( TRKDBG_SVR|TRKDBG_WKS,
             TEXT("ServiceHandler(%s)"),
             StringizeServiceControl(dwControl) ));
#endif

    // On a stop or shutdown, flag it (e.g. so we don't try to accept new
    // requests from clients) and tell the SCM that we're stopping.

    switch (dwControl)
    {
    case SERVICE_CONTROL_STOP:
    case SERVICE_CONTROL_SHUTDOWN:
        pThis->SetServiceStatus(SERVICE_STOP_PENDING, 0, NO_ERROR);
        _fStoppedOrStopping = TRUE;

        break;
    }

    // Check for PNP timing issues.  The problem is that during a stop
    // or shutdown, we unregister with PNP so that we don't get any more
    // notifications.  This is fine, except that between now and the time
    // we do that unregister, more PNP notifications might get queued.  So
    // when we get called to process those undesired notifications, we need
    // to ignore them here in the static function.
    //
    // As a quick fix, since only trkwks receives PNP notifications, we'll
    // just check to see if it's alive.  A better fix (raided) is to have
    // a static function for each service, so that only the trkwks has to
    // deal with it.

    if( SERVICE_CONTROL_DEVICEEVENT == dwControl && _fStoppedOrStopping )
    {
        TrkLog(( TRKDBG_WARNING, TEXT("Ignoring SERVICE_CONTROL_DEVICEEVENT; service is stopped") ));
        return dwRet;
    }


    // Call this service's service handler.  As a final safety measure,
    // catch any exceptions (there should be none).  We must be sure that we don't
    // kill this thread, since it's shared by everyone in services.exe.

    __try
    {
        dwRet = pThis->_pServiceHandler->ServiceHandler(dwControl, dwEventType, EventData, pData);

        switch (dwControl)
        {
        case SERVICE_CONTROL_STOP:
        case SERVICE_CONTROL_SHUTDOWN:
            break;
        case SERVICE_CONTROL_PAUSE:
            pThis->SetServiceStatus(SERVICE_PAUSED, pThis->_dwControlsAccepted, NO_ERROR);
            break;
        case SERVICE_CONTROL_CONTINUE:
            pThis->SetServiceStatus(SERVICE_RUNNING, pThis->_dwControlsAccepted, NO_ERROR);
            break;
        case SERVICE_CONTROL_INTERROGATE:
            pThis->SetServiceStatus(pThis->_dwState, pThis->_dwControlsAccepted, NO_ERROR);
            break;
        case SERVICE_CONTROL_DEVICEEVENT:
            break;
        }
    }
    __except( BREAK_THEN_RETURN( EXCEPTION_EXECUTE_HANDLER ))
    {
        TrkLog(( TRKDBG_ERROR,
                 TEXT("Unexpected exception in CSvcCtrlInterface::ServiceHandler (%08x)"),
                 GetExceptionCode() ));
        dwRet = ERROR_EXCEPTION_IN_SERVICE;
    }

    return dwRet;
}


//+----------------------------------------------------------------------------
//
//  CSvcCtrlInterface::SetServiceStatus
//
//  Send a SetServiceStatus to the SCM.  The checkpoint is automatically
//  maintained by this class.
//
//+----------------------------------------------------------------------------

void
CSvcCtrlInterface::SetServiceStatus(DWORD dwState, DWORD dwControlsAccepted, DWORD dwWin32ExitCode)
{
    SERVICE_STATUS ss;

    _dwState = dwState;
    _dwControlsAccepted = dwControlsAccepted;

    if( SERVICE_START_PENDING != dwState
        &&
        SERVICE_STOP_PENDING != dwState )
    {
        _dwCheckPoint = 0;
    }

    ss.dwServiceType = SERVICE_WIN32;   // XX_SC
    ss.dwCurrentState = _dwState;
    ss.dwControlsAccepted = _dwControlsAccepted;
    ss.dwWin32ExitCode = dwWin32ExitCode;
    ss.dwServiceSpecificExitCode = 0;
    ss.dwCheckPoint = _dwCheckPoint++;
    ss.dwWaitHint = DEFAULT_WAIT_HINT;

    if (_ssh != 0)
    {
        if( !::SetServiceStatus(_ssh, &ss) )
        {
            TrkLog(( TRKDBG_ERROR, TEXT("SetServiceStatus(%s) failed, gle=%lu"),
                     (const TCHAR*)CDebugString(SServiceState(dwState)), GetLastError() ));
        }
        else
        {
            TrkLog(( TRKDBG_MISC, TEXT("SetServiceStatus(%s)"),
                     (const TCHAR*)CDebugString(SServiceState(dwState)) ));
        }
    }
}


//+----------------------------------------------------------------------------
//
//  CSvcCtrlInterface::UpdateWaitHint
//
//  Send a non-default wait hint to the SCM.
//
//+----------------------------------------------------------------------------

void
CSvcCtrlInterface::UpdateWaitHint(DWORD dwMilliseconds)
{
    SERVICE_STATUS ss;

    ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    ss.dwCurrentState = _dwState;
    ss.dwControlsAccepted = _dwControlsAccepted;
    ss.dwWin32ExitCode = NO_ERROR;
    ss.dwServiceSpecificExitCode = 0;
    ss.dwCheckPoint = _dwCheckPoint++;
    ss.dwWaitHint = dwMilliseconds;

    if (_ssh != 0)
        ::SetServiceStatus(_ssh, &ss);
}



//+----------------------------------------------------------------------------
//
//  StringizeServiceControl (debug only)
//
//+----------------------------------------------------------------------------

#if DBG
TCHAR * StringizeServiceControl( DWORD dwControl )
{
    switch( dwControl )
    {
    case SERVICE_CONTROL_STOP:
        return TEXT("SERVICE_CONTROL_STOP");

    case SERVICE_CONTROL_PAUSE:
        return TEXT("SERVICE_CONTROL_PAUSE");

    case SERVICE_CONTROL_CONTINUE:
        return TEXT("SERVICE_CONTROL_CONTINUE");

    case SERVICE_CONTROL_INTERROGATE:
        return TEXT("SERVICE_CONTROL_INTERROGATE");

    case SERVICE_CONTROL_SHUTDOWN:
        return TEXT("SERVICE_CONTROL_SHUTDOWN");

    case SERVICE_CONTROL_PARAMCHANGE:
        return TEXT("SERVICE_CONTROL_PARAMCHANGE");

    case SERVICE_CONTROL_NETBINDADD:
        return TEXT("SERVICE_CONTROL_NETBINDADD");

    case SERVICE_CONTROL_NETBINDREMOVE:
        return TEXT("SERVICE_CONTROL_NETBINDREMOVE");

    case SERVICE_CONTROL_NETBINDENABLE:
        return TEXT("SERVICE_CONTROL_NETBINDENABLE");

    case SERVICE_CONTROL_NETBINDDISABLE:
        return TEXT("SERVICE_CONTROL_NETBINDDISABLE");

    case SERVICE_CONTROL_DEVICEEVENT:
        return TEXT("SERVICE_CONTROL_DEVICEEVENT");

    default:
        return TEXT("Unknown");
    }
}
#endif