windows-xp/Source/XPSP1/NT/base/cluster/resdll/spooler/splsvc/spooler.cxx

/*++

Copyright (c) 1996  Microsoft Corporation
All rights reserved.

Module Name:

    spooler.c

Abstract:

    Handle spooler interaction via RPC.

    Public functions from this module:

        SpoolerOnline
        SpoolerOffline
        SpoolerStart
        SpoolerStop
        SpoolerIsAlive
        SpoolerLooksAlive

    There is a little interface bleed here--this module is aware
    of the cluster SetResourceStatus callback.

Author:

    Albert Ting (AlbertT)  23-Sept-96

Revision History:
    Khaled Sedky (KhaledS) 1998-2001

--*/

#include "precomp.hxx"
#pragma hdrstop

#include "splsvc.hxx"
#include "clusinfo.hxx"
#include "spooler.hxx"
#include "winsprlp.h"

#define TERMINATETHREADONCHECK           \
if ( ClusWorkerCheckTerminate( Worker )) \
{                                        \
   goto Done;                            \
}


/********************************************************************

    Conditional compile defines:

    USE_ISALIVE_THREAD

        Causes the resource DLL to wait on a thread each time the
        IsAlive all is made.  This thread wait for ISALIVE_WAIT_TIME
        to see if the RPC call to the spooler successfully completes.
        If it does not, then we assume that the spooler is deadlocked.

        This is off because it kills the spooler if it's slow or
        being debugged.  There are no scenarios where we should
        be deadlocked (or hold the critical section while doing a
        slow operation like hitting the net).  During stress, however,
        we may appear deadlocked.

    USE_OFFLINE_HACK

        Causes an Offline call to terminate and restart the spooler.
        This will be turned on until we have clean shutdown code.

    USE_STUBS

        Causes us to use stubbed out winspool.drv calls.  Usefule if
        the new winspool.drv isn't available and you want to compile
        a DLL which simulates talking to the spooler.

********************************************************************/

//#define USE_ISALIVE_THREAD
//#define USE_OFFLINE_HACK
//#define USE_STUBS          

#define POLL_SLEEP_TIME 500         // Service control poll time.
#define STATUS_SLEEP_TIME 1500
#define ISALIVE_WAIT_TIME 2000      // Time before spooler is deadlocked.

LPCTSTR gszSpooler = TEXT( "Spooler" );
SC_HANDLE ghSpoolerService;
SC_HANDLE ghSC;


/********************************************************************

    Stubs

********************************************************************/

#ifdef USE_STUBS

BOOL
ClusterSplOpen(
    LPCTSTR pszServer,
    LPCTSTR pszResource,
    PHANDLE phSpooler,
    LPCTSTR pszName,
    LPCTSTR pszAddress
    )
{
    UNREFERENCED_PARAMETER( pszServer );
    UNREFERENCED_PARAMETER( pszResource );
    UNREFERENCED_PARAMETER( pszName );
    UNREFERENCED_PARAMETER( pszAddress );
    *phSpooler = (HANDLE)31;
    Sleep( 3200 );
    return TRUE;
}

BOOL
ClusterSplClose(
    HANDLE hSpooler
    )
{
    UNREFERENCED_PARAMETER( hSpooler );
    SPLASSERT( hSpooler==(HANDLE)31 );
    Sleep( 6000 );
    return TRUE;
}

BOOL
ClusterSplIsAlive(
    HANDLE hSpooler
    )
{
    UNREFERENCED_PARAMETER( hSpooler );
    Sleep( 500 );
    return TRUE;
}

#endif

/********************************************************************

    Utility functions

********************************************************************/

BOOL
QuerySpoolerState(
    OUT PDWORD pdwState
    )

/*++

Routine Description:

    Checks the current state of the spooler service.

Arguments:

    pdwState - Receives the state of the spooler.

Return Value:

    TRUE - success
    FALSE - failure.  *pdwState set to SERVICE_STOPPED


--*/

{
    SERVICE_STATUS ServiceStatus;

    SPLASSERT( ghSpoolerService );

    if( !QueryServiceStatus( ghSpoolerService,
                             &ServiceStatus)) {

        DBGMSG( DBG_WARN,
                ( "SpoolerStatus: QueryServiceStatus failed %d\n",
                  GetLastError() ));

        *pdwState = SERVICE_STOPPED;
        return FALSE;
    }

    *pdwState = ServiceStatus.dwCurrentState;

    return TRUE;
}

DWORD
WINAPI
SpoolerStatusReportThread(
    PCLUS_WORKER Worker,
    PVOID        pStatusThreadInfo
    )
{
    HANDLE hStatusEvent = ((STATUSTHREAD_INFO *)pStatusThreadInfo)->hStatusEvent;
    PSPOOLER_INFORMATION pSpoolerInfo = ((STATUSTHREAD_INFO *)pStatusThreadInfo)->pSpoolerInfo;
    PRESOURCE_STATUS pResourceStatus  = ((STATUSTHREAD_INFO *)pStatusThreadInfo)->pResourceStatus;

    while(WaitForSingleObject(hStatusEvent,STATUS_SLEEP_TIME) == WAIT_TIMEOUT)
    {
         pResourceStatus->CheckPoint++;
         (pSpoolerInfo->pfnSetResourceStatus)(pSpoolerInfo->ResourceHandle,
                                              pResourceStatus);
    }
    return (0);
}



/********************************************************************

    Worker threads for SpoolerOnline/Offline.

********************************************************************/

#ifdef USE_ISALIVE_THREAD

DWORD
WINAPI
SpoolerIsAliveThread(
    PVOID pSpoolerInfo_
    )

/*++

Routine Description:

    Async thread to online the resource instance.

    Assumes vAddRef has been called already; we will call vDecRef
    when we are done.

Arguments:

Return Value:

    ERRROR_SUCCESS - Spooler still alive.

    dwError - Spooler dead.

--*/

{
    PSPOOLER_INFORMATION pSpoolerInfo = (PSPOOLER_INFORMATION)pSpoolerInfo_;
    HANDLE hSpooler = pSpoolerInfo->hSpooler;
    BOOL bIsAlive;

    //
    // We've stored all the information we need from pSpoolerInfo;
    // decrement the refcount.
    //
    vDecRef( pSpoolerInfo );

    //
    // RPC to spooler.
    //
    SPLASSERT( hSpooler );

    bIsAlive = ClusterSplIsAlive( hSpooler );

    DBGMSG( DBG_TRACE,
            ( "SpoolerIsAliveThread: return status: h=%x s=%x,%d\n",
              hSpooler, bIsAlive, GetLastError() ));

    if( bIsAlive ){
        return ERROR_SUCCESS;
    }

    //
    // Spooler is dead--return some error code.
    //
    return ERROR_INVALID_PARAMETER;
}

#endif

DWORD
SpoolerOnlineThread(
    IN PCLUS_WORKER Worker,
    IN PVOID pSpoolerInfo_
    )
/*++

Routine Description:

    Async thread to online the resource instance.

    Assumes vAddRef has been called already; we will call vDecRef
    when we are done.

Arguments:

Return Value:

--*/

{
    DWORD  dwState;
    DWORD  dwStatus;
    BOOL   bStatus = FALSE;
    HANDLE hStatusEvent   = NULL;
    
    RESOURCE_STATUS    ResourceStatus;
    STATUSTHREAD_INFO  StatusThreadInfo;

    PSPOOLER_INFORMATION pSpoolerInfo = (PSPOOLER_INFORMATION)pSpoolerInfo_;

    ResUtilInitializeResourceStatus( &ResourceStatus );

    ResourceStatus.ResourceState = ClusterResourceOnlinePending;
    ResourceStatus.CheckPoint = 1;
    (pSpoolerInfo->pfnSetResourceStatus)( pSpoolerInfo->ResourceHandle,
                                          &ResourceStatus );

    TERMINATETHREADONCHECK

    //
    // Get needed information about net name and tcpip address.
    //
    if( !bGetClusterNameInfo( pSpoolerInfo->pszResource,
                              &pSpoolerInfo->pszName,
                              &pSpoolerInfo->pszAddress )){

        (pSpoolerInfo->pfnLogEvent)(
            pSpoolerInfo->ResourceHandle,
            LOG_ERROR,
            L"Unable to retrieve Name and TcpIp address.\n" );

        DBGMSG( DBG_ERROR, ( "SplSvcOpen: Couldn't retrieve name/tcpip addr\n" ));
        goto Done;
    }

    TERMINATETHREADONCHECK


    //
    // Ensure the spooler is started.
    //
    bStatus = SpoolerStart( pSpoolerInfo );

    if( !bStatus ){

        DBGMSG( DBG_WARN, ( "SpoolerOnlineThread: SpoolerStart failed\n" ));
        goto Done;
    }

    while (TRUE)  {

        if( !QuerySpoolerState( &dwState )){

            dwStatus = GetLastError();

            (pSpoolerInfo->pfnLogEvent)(
                pSpoolerInfo->ResourceHandle,
                LOG_ERROR,
                L"Query Service Status failed %1!u!.\n",
                dwStatus);

            goto Done;
        }



        if( dwState != SERVICE_START_PENDING ){
            break;
        }
        else
        {
            ResourceStatus.CheckPoint ++;
            (pSpoolerInfo->pfnSetResourceStatus)( pSpoolerInfo->ResourceHandle,
                                                  &ResourceStatus );
            TERMINATETHREADONCHECK
        }

        Sleep( POLL_SLEEP_TIME );
    }

    if( dwState != SERVICE_RUNNING) {

        (pSpoolerInfo->pfnLogEvent)(
            pSpoolerInfo->ResourceHandle,
            LOG_ERROR,
            L"Failed to start service. Error: %1!u!.\n",
            ERROR_SERVICE_NEVER_STARTED);

        dwStatus = ERROR_SERVICE_NEVER_STARTED;
        goto Done;
    }

    //
    // Since we have to report the status of being online pending
    // to the cluster everywhile in order not to be considered failing
    // and because ClusterSplOpen takes a while and it is a synchronous 
    // call , we hae to create this Status Thread which would keep 
    // reporting the status to the cluster in the back ground.
    //
    hStatusEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(hStatusEvent)
    {

        StatusThreadInfo.pResourceStatus = &ResourceStatus;
        StatusThreadInfo.hStatusEvent    = hStatusEvent;
        StatusThreadInfo.pSpoolerInfo    = pSpoolerInfo;

        dwStatus = ClusWorkerCreate(&pSpoolerInfo->OnLineStatusThread,
                                    SpoolerStatusReportThread,
                                    (PVOID)&StatusThreadInfo);

        if( dwStatus != ERROR_SUCCESS )
        {
            //
            // In this case we will unfortunatly fall out of the Reporting thread and 
            // behave the same as previously , which might cause the resource to fail
            // since it is not reporing the status properly (not likely to happen)
            //
            DBGMSG( DBG_WARN,
                    ( "SpoolerOnlineThread : ClusWorkerCreate(SpoolerStatusReportThread) failed %d\n", dwStatus ));
        }
    }
    else
    {
        //
        // In this case we will unfortunatly fall out of the Reporting thread and 
        // behave the same as previously , which might cause the resource to fail
        // since it is not reporing the status properly (not likely to happen)
        //
        DBGMSG( DBG_WARN,
                ( "SpoolerOnlineThread: Create StatusEvent failed %d\n", GetLastError() ));
    }

    //
    // RPC to spooler.
    //
    bStatus = ClusterSplOpen( NULL,
                              pSpoolerInfo->pszResource,
                              &pSpoolerInfo->hSpooler,
                              pSpoolerInfo->pszName,
                              pSpoolerInfo->pszAddress );

    if(hStatusEvent && pSpoolerInfo->OnLineStatusThread.hThread)
    {
        SetEvent(hStatusEvent);
    }


    SPLASSERT( bStatus || !pSpoolerInfo->hSpooler );

    DBGMSG( DBG_TRACE,
            ( "SpoolerOnlineThread: "TSTR" "TSTR" "TSTR" h=%x s=%x,d\n",
              DBGSTR( pSpoolerInfo->pszResource ),
              DBGSTR( pSpoolerInfo->pszName ),
              DBGSTR( pSpoolerInfo->pszAddress ),
              pSpoolerInfo->hSpooler,
              bStatus,
              GetLastError() ));

Done:

    //
    // If we are terminating, then we should not set any state
    // and avoid calling SetResourceStatus since clustering doesn't
    // think we are pending online anymore.
    //
    if( pSpoolerInfo->eState != kTerminate ){

        if( bStatus ){

            //
            // Spooler successfully onlined.
            //
            pSpoolerInfo->eState = kOnline;
            ResourceStatus.ResourceState = ClusterResourceOnline;
        }
        else
        {
           ResourceStatus.ResourceState = ClusterResourceFailed;
        }

        ResourceStatus.CheckPoint++;
        (pSpoolerInfo->pfnSetResourceStatus)( pSpoolerInfo->ResourceHandle,
                                              &ResourceStatus );
    }

    vDecRef( pSpoolerInfo );
    if(hStatusEvent)
    {
        CloseHandle(hStatusEvent);
    }

    ClusWorkerTerminate(&(pSpoolerInfo->OnLineStatusThread));

    return 0;
}

DWORD
SpoolerClose(
    PSPOOLER_INFORMATION pSpoolerInfo,
    EShutDownMethod ShutDownMethod
)
{
    CLUSTER_RESOURCE_STATE ClusterResourceState;
    STATUSTHREAD_INFO      StatusThreadInfo;
    RESOURCE_STATUS        ResourceStatus;
    BOOL                   bStatus      = TRUE;
    HANDLE                 hStatusEvent = NULL;
    HANDLE                 hSpooler     = NULL;
    DWORD                  dwStatus     = ERROR_SUCCESS;

    ResUtilInitializeResourceStatus( &ResourceStatus );

    ResourceStatus.CheckPoint = 1;
    ResourceStatus.ResourceState = ClusterResourceOfflinePending;
    (pSpoolerInfo->pfnSetResourceStatus)( pSpoolerInfo->ResourceHandle,
                                          &ResourceStatus );

    vEnterSem();
    {
        ClusterResourceState = pSpoolerInfo->ClusterResourceState;

        if( pSpoolerInfo->hSpooler )
        {
            hSpooler = pSpoolerInfo->hSpooler;
            pSpoolerInfo->hSpooler = NULL;
        }
    }
    vLeaveSem();
    
    if( hSpooler )
    {
         //
         // Since we have to report the status of being offline pending
         // to the cluster everywhile in order not to be considered failing
         // and because ClusterSplClose takes a while and it is a synchronous 
         // call , we have to create this Status Thread which would keep 
         // reporting the status to the cluster in the back ground.
         //
         hStatusEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
         if(hStatusEvent)
         {
     
             StatusThreadInfo.pResourceStatus = &ResourceStatus;
             StatusThreadInfo.hStatusEvent    = hStatusEvent;
             StatusThreadInfo.pSpoolerInfo    = pSpoolerInfo;
     
             dwStatus = ClusWorkerCreate((ShutDownMethod == kTerminateShutDown) ? 
                                         &pSpoolerInfo->TerminateStatusThread :
                                         &pSpoolerInfo->OffLineStatusThread,
                                         SpoolerStatusReportThread,
                                         (PVOID)&StatusThreadInfo);

             if( dwStatus != ERROR_SUCCESS )
             {
                 //
                 // In this case we will unfortunatly fall out of the Reporting thread and 
                 // behave the same as previously , which might cause the resource to fail
                 // since it is not reporing the status properly (not likely to happen)
                 //
                 DBGMSG( DBG_WARN,
                         ( "SpoolerClose : ClusWorkerCreate(SpoolerStatusReportThread) failed %d\n", dwStatus ));
                 dwStatus = ERROR_SUCCESS;
             }
         }
         else
         {
             //
             // In this case we will unfortunatly fall out of the Reporting thread and 
             // behave the same as previously , which might cause the resource to fail
             // since it is not reporing the status properly (not likely to happen)
             //
             dwStatus = GetLastError();
             DBGMSG( DBG_WARN,
                     ( "SpoolerClose: Create StatusEvent failed %d\n", GetLastError() ));
         }

         if(ShutDownMethod == kOffLineShutDown)
         {
             ClusWorkerTerminate(&(pSpoolerInfo->OnlineThread));
         }

         //
         // RPC to Terminate
         //
         bStatus = ClusterSplClose( hSpooler );

         if(hStatusEvent && 
            (ShutDownMethod == kTerminateShutDown) ? 
            pSpoolerInfo->TerminateStatusThread.hThread :
            pSpoolerInfo->OffLineStatusThread.hThread)
         {
             SetEvent(hStatusEvent);
         }

         DBGMSG( DBG_TRACE,
                 ( "SpoolerClose: h=%x, s=%x,%d\n",
                   hSpooler, bStatus, GetLastError() ));
    }

    if( bStatus ){

        ResourceStatus.ResourceState = ClusterResourceState;
        pSpoolerInfo->hSpooler = NULL;
    }
    else
    {
        ResourceStatus.ResourceState = ClusterResourceFailed;
        dwStatus = ERROR_FUNCTION_FAILED;
    }

    ClusWorkerTerminate((ShutDownMethod == kTerminateShutDown) ? 
                        &(pSpoolerInfo->TerminateStatusThread) :
                        &(pSpoolerInfo->OffLineStatusThread));
    //
    // If we are terminating, don't call SetResourceStatus since
    // clustering doesn't expect this after a terminate call.
    //
    if( pSpoolerInfo->eState != kTerminate )
    {
        ResourceStatus.CheckPoint++;
        (pSpoolerInfo->pfnSetResourceStatus)( pSpoolerInfo->ResourceHandle,
                                              &ResourceStatus );

        pSpoolerInfo->eState = kOffline;
    }

    if(hStatusEvent)
    {
        CloseHandle(hStatusEvent);
    }

    return dwStatus;
}


DWORD
WINAPI
SpoolerOfflineThread(
    IN PCLUS_WORKER Worker,
    IN PVOID pSpoolerInfo_
    )
{
    PSPOOLER_INFORMATION   pSpoolerInfo = (PSPOOLER_INFORMATION)pSpoolerInfo_;
    SpoolerClose(pSpoolerInfo,kOffLineShutDown);
    vDecRef( pSpoolerInfo );
    return 0;
}

DWORD
WINAPI
SpoolerTerminateSync(
    IN PSPOOLER_INFORMATION pSpoolerInfo
    )
{
    return SpoolerClose(pSpoolerInfo,kTerminateShutDown);
}



/********************************************************************

    Spooler routines.

********************************************************************/

BOOL
SpoolerOnline(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Put the spooler service online.  This call completes asynchronously;
    it will use the callback in pSpoolerInfo to update the status.

Arguments:


Return Value:


--*/

{
    DWORD  status=ERROR_SUCCESS;

    pSpoolerInfo->hSpooler = NULL;
    pSpoolerInfo->eState = kOnlinePending;

    vAddRef( pSpoolerInfo );

    //
    // Create a worker thread to start the spooler and poll.
    //
    status = ClusWorkerCreate(&pSpoolerInfo->OnlineThread,
                              SpoolerOnlineThread,
                              (PVOID)pSpoolerInfo
                             );

    if( status != ERROR_SUCCESS ){

        DBGMSG( DBG_WARN,
                ( "SpoolerOnline: ClusWorkerCreate failed %d\n", status ));

        vDecRef( pSpoolerInfo );

        return FALSE;
    }
    return TRUE;
}

DWORD
SpoolerOffline(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Put the spooler service offline.  This call completes asynchronously;
    it will use the callback in pSpoolerInfo to update the status.

Arguments:

Return Value:

--*/

{
    DWORD status = ERROR_SUCCESS;

    DBGMSG( DBG_WARN, ( ">>> SpoolerOffline: called %x\n", Resid ));

    vAddRef( pSpoolerInfo );

    pSpoolerInfo->eState = kOfflinePending;

    //
    // Create a worker thread to stop the spooler.
    //
    if((status = ClusWorkerCreate(&pSpoolerInfo->OfflineThread,
                                  SpoolerOfflineThread,
                                  (PVOID)pSpoolerInfo
                                  ))!=ERROR_SUCCESS)
    {
        DBGMSG( DBG_WARN,
                ( "SpoolerOffline: ClusWorkerCreate failed %d\n", status ));
        DBGMSG( DBG_ERROR, 
                ( "SpoolerOffline: Unable to offline spooler\n" ));
        SPLASSERT(status == ERROR_SUCCESS)
        vDecRef( pSpoolerInfo );
    }
    else
    {
        status = ERROR_IO_PENDING;
    }

    return status;
}

VOID
SpoolerTerminate(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Terminates the spooler process.  This call completes asynchronously;
    it will use the callback in pSpoolerInfo to update the status.

Arguments:

Return Value:

--*/

{
    DWORD status = ERROR_SUCCESS;

    DBGMSG( DBG_WARN, ( ">>> SpoolerTerminate: called %x\n", Resid ));

    vAddRef( pSpoolerInfo );
    {
        ClusWorkerTerminate(&(pSpoolerInfo->OnlineThread));
        ClusWorkerTerminate(&(pSpoolerInfo->OfflineThread));

        pSpoolerInfo->eState = kOfflinePending;

        //
        // Create a worker thread to stop the spooler.
        //

        if((status = SpoolerTerminateSync(pSpoolerInfo))!=ERROR_SUCCESS)
        {
            DBGMSG( DBG_WARN,
                    ( "SpoolerTerminate: ClusWorkerCreate failed %d\n", status ));
            DBGMSG( DBG_ERROR, 
                    ( "SpoolerTerminate: Unable to offline spooler\n" ));
            SPLASSERT(status == ERROR_SUCCESS)
        }
    }
    vDecRef( pSpoolerInfo );
}


BOOL
SpoolerStart(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Start the spooler.

Arguments:


Return Value:


--*/

{
    BOOL bStatus = TRUE;

    UNREFERENCED_PARAMETER( pSpoolerInfo );

    vEnterSem();

    if( !ghSC ){
        ghSC = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
    }

    if( ghSC ){

        if( !ghSpoolerService ){
            ghSpoolerService = OpenService( ghSC,
                                            gszSpooler,
                                            SERVICE_ALL_ACCESS );
        }

        if( !ghSpoolerService ){

            DBGMSG( DBG_WARN,
                    ( "SpoolerStart: Failed to open spooler service %d\n ",
                      GetLastError() ));

            bStatus = FALSE;
            goto Done;
        }

        if( !StartService( ghSpoolerService, 0, NULL )){

            DWORD dwStatus;
            dwStatus = GetLastError();

            if( dwStatus != ERROR_SERVICE_ALREADY_RUNNING ){

                DBGMSG( DBG_WARN,
                        ( "SpoolerStart: StartService failed %d\n",
                          dwStatus ));

                bStatus = FALSE;
            }
        }
    }

Done:

    vLeaveSem();

    return bStatus;
}

BOOL
SpoolerStop(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Stop the spooler.

Arguments:

Return Value:

--*/

{
    BOOL bStatus;
    SERVICE_STATUS ServiceStatus;

    vEnterSem();

    bStatus = ControlService( ghSpoolerService,
                              SERVICE_CONTROL_STOP,
                              &ServiceStatus );

    if( !bStatus ){

        DBGMSG( DBG_WARN,
                ( "SpoolerStop: ControlService failed %d\n", GetLastError() ));

        (pSpoolerInfo->pfnLogEvent)(
            pSpoolerInfo->ResourceHandle,
            LOG_ERROR,
            L"Stop service failed, Error %1!u!.\n",
            GetLastError() );
    }

    CloseServiceHandle( ghSpoolerService );
    ghSpoolerService = NULL;

    vLeaveSem();

    return TRUE;
}

BOOL
SpoolerIsAlive(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Expensive check to see if the spooler is still alive.

Arguments:

Return Value:

    TRUE - Spooler is alive, and critical section successfully acquired.
    FALSE - Spooler is dead.

--*/

{
#ifdef USE_ISALIVE_THREAD

    HANDLE hThread;
    DWORD dwThreadId;
    DWORD dwExitCode;

    //
    // RPC to spooler.
    //
    SPLASSERT( pSpoolerInfo->hSpooler );

    vAddRef( pSpoolerInfo );

    //
    // Create a worker thread to start the spooler and poll.
    //
    hThread = CreateThread( NULL,
                            0,
                            SpoolerIsAliveThread,
                            (PVOID)pSpoolerInfo,
                            0,
                            &dwThreadId );
    if( !hThread ){

        DBGMSG( DBG_WARN,
                ( "SpoolerOnline: CreateThread failed %d\n", GetLastError() ));

        vDecRef( pSpoolerInfo );

        return FALSE;
    }

    WaitForSingleObject( hThread, ISALIVE_WAIT_TIME );
    if( !GetExitCodeThread( hThread, &dwExitCode )){
        dwExitCode = GetLastError();
    }

    CloseHandle( hThread );

    DBGMSG( DBG_TRACE,
            ( "SpoolerIsAlive: h=%x s=%d\n",
              pSpoolerInfo->hSpooler, dwExitCode ));

    return dwExitCode == ERROR_SUCCESS;

#else // Don't use thread.

    BOOL bIsAlive;

    //
    // RPC to spooler.
    //
    SPLASSERT( pSpoolerInfo->hSpooler );

    bIsAlive = ClusterSplIsAlive( pSpoolerInfo->hSpooler );

    DBGMSG( DBG_TRACE,
            ( "SpoolerIsAlive: h=%x s=%x,%d\n",
              pSpoolerInfo->hSpooler, bIsAlive, GetLastError() ));

    return bIsAlive;

#endif
}

BOOL
SpoolerLooksAlive(
    PSPOOLER_INFORMATION pSpoolerInfo
    )

/*++

Routine Description:

    Quick check to see if the spooler is still alive.

Arguments:

Return Value:

    TRUE - Looks alive.
    FALSE - Looks dead.

--*/

{
    DWORD dwState;

    if( !QuerySpoolerState( &dwState )){

        DBGMSG( DBG_WARN,
                ( "SpoolerLooksAlive: SpoolerStatus failed %d\n",
                  GetLastError() ));

        (pSpoolerInfo->pfnLogEvent)(
            pSpoolerInfo->ResourceHandle,
            LOG_ERROR,
            L"Query Service Status failed %1!u!.\n",
            GetLastError());

        return FALSE;
    }

    //
    // Now check the status of the service
    //

    if(( dwState != SERVICE_RUNNING ) &&
       ( dwState != SERVICE_START_PENDING )){

        DBGMSG( DBG_WARN,
                ( "SpoolerLooksAlive: QueryServiceStatus bad state %d\n",
                  dwState ));

        (pSpoolerInfo->pfnLogEvent)(
            pSpoolerInfo->ResourceHandle,
            LOG_ERROR,
            L"Failed the IsAlive test.  Current State is %1!u!.\n",
            dwState );

        return FALSE;
    }

    return TRUE;
}

/*++

Routine Name

    SpoolerWriteClusterUpgradedKey
 
Routine Description:

    After the first reboot following an upgrade of a node, the cluster
    service informs the resdll that a version change occured. At this
    time out spooler resource may be running on  another node or may 
    not be actie at all. Thus we write a value in the local registry.
    When the cluster spooler resource fails over on this machine it
    will query for that value to know if it needs to preform post
    upgrade operations, like upgrading the printer drivers.

Arguments:

    pszResourceID - string representation of the GUID of the resoruce

Return Value:

    Win32 error code

--*/
DWORD
SpoolerWriteClusterUpgradedKey(
    IN LPCWSTR pszResourceID
    )
{
    DWORD dwError     = ERROR_INVALID_PARAMETER;
    HKEY  hRootKey    = NULL;     
    HKEY  hUpgradeKey = NULL;

    if (pszResourceID &&
        (dwError = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                                  SPLREG_CLUSTER_LOCAL_ROOT_KEY,
                                  0,
                                  NULL,
                                  0,
                                  KEY_WRITE,
                                  NULL,
                                  &hRootKey,
                                  NULL)) == ERROR_SUCCESS &&
        (dwError = RegCreateKeyEx(hRootKey,
                                  SPLREG_CLUSTER_UPGRADE_KEY,
                                  0,
                                  NULL,
                                  0,
                                  KEY_WRITE,
                                  NULL,
                                  &hUpgradeKey,
                                  NULL)) == ERROR_SUCCESS)
    {
        DWORD dwValue = 1;
    
        dwError = RegSetValueEx(hUpgradeKey, pszResourceID, 0, REG_DWORD, (LPBYTE)&dwValue, sizeof(dwValue));
    }
        
    if (hUpgradeKey) RegCloseKey(hUpgradeKey);        
    if (hRootKey)    RegCloseKey(hRootKey);        
    
    return dwError;
}

/*++

Routine Name

    WipeDirectory

Routine Description:

    Remove a directory tree.

Arguments:

    pszDir - directory to remove

Return Value:

    None

--*/
VOID
WipeDirectory(
    IN LPCWSTR pszDir
    )
{
    WCHAR           szBuf[MAX_PATH];
    WIN32_FIND_DATA FindData;
    HANDLE          hFind;
    LPCWSTR         pszAllFiles = L"\\*.*";

    if (pszDir && *pszDir)
    {
        //
        // Sanity check. The string that we are going to construct must 
        // fit in the buffer.
        //
        if (wcslen(pszDir) + wcslen(pszAllFiles) + 1 <= MAX_PATH) 
        {
            wcscpy(szBuf, pszDir);
            wcscat(szBuf, L"\\*.*");
    
            //
            // Find first file that meets the criteria
            //
            if ((hFind = FindFirstFile(szBuf, &FindData)) != INVALID_HANDLE_VALUE)
            {
                do 
                {
                    //
                    // Sanity check to prevent buffer overrun
                    // length(pszdir) + "\" + length(cFileName) + NULL <= MAX_PATH
                    //
                    if (wcslen(pszDir) + 1 + wcslen(FindData.cFileName) + 1 <= MAX_PATH)
                    {
                        wcscpy(szBuf, pszDir);
                        wcscat(szBuf, L"\\");
                        wcscat(szBuf, FindData.cFileName);
            
                        //
                        // Search for the rest of the files. We are interested in files 
                        // which are not directories
                        //
                        if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
                        {
                            if (FindData.cFileName[0] != L'.') 
                            {
                                WipeDirectory(szBuf);
                            }
                        }
                        else
                        {
                            DeleteFile(szBuf);
                        }
                    }
        
                } while (FindNextFile(hFind, &FindData));
        
                FindClose(hFind);        
            }
        }
    
        RemoveDirectory(pszDir);
    }
}

/*++

Routine Name

    SpoolerCleanDriverDirectory

Routine Description:

    Thie routine is called when the spooler resource is deleted.
    It will remove from the cluster disk the directory where the 
    spooler keeps the pirnter drivers.

Arguments:

    hKey - handle to the Parameters key of the spooler resource

Return Value:

    Win32 error code

--*/
DWORD
SpoolerCleanDriverDirectory(
    IN HKEY hKey
    )
{
    DWORD dwError;
    DWORD dwType;
    DWORD cbNeeded = 0;

    //
    // We read the string value (private property) that was written 
    // by the spooler. This is the directory to delete.
    // Note that ClusterRegQueryValue has a bizzare behaviour. If
    // you pass NULL for the buffer and the value exists, then it
    // doesn't return ERROR_MORE_DATA, but ERROR_SUCCESS
    // Should the reg type not be reg_Sz, then we can't do anything 
    // in this function.
    //
    if ((dwError = ClusterRegQueryValue(hKey,
                                        SPLREG_CLUSTER_DRIVER_DIRECTORY,
                                        &dwType,
                                        NULL,
                                        &cbNeeded)) == ERROR_SUCCESS &&
        dwType == REG_SZ) 
    {
        LPWSTR pszDir;
           
        if (pszDir = (LPWSTR)LocalAlloc(LMEM_FIXED, cbNeeded)) 
        {
            if ((dwError = ClusterRegQueryValue(hKey,
                                                SPLREG_CLUSTER_DRIVER_DIRECTORY,
                                                &dwType,
                                                (LPBYTE)pszDir,
                                                &cbNeeded)) == ERROR_SUCCESS)
            {
                //
                // Remove the directory
                //
                WipeDirectory(pszDir);
            }
    
            LocalFree(pszDir);
        }   
        else
        {
            dwError = GetLastError();
        }        
    }
    
    return dwError;
}