windows-server-2003/inetsrv/query/fsci/dll/service.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1994 - 2000.
//
//  File:       service.cxx
//
//  Contents:   CI service
//
//  History:    17-Sep-96   dlee   Created
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <dbt.h>
#include <initguid.h>   // so we know the value of GUIDs
#include <ioevent.h>
#include <cievtmsg.h>
#include <cisvcex.hxx>
#include <eventlog.hxx>
#include <ciregkey.hxx>
#include <regacc.hxx>
#include <drvnotif.hxx>
#include <notifary.hxx>

//
// HRESULTTOWIN32() maps an HRESULT to a Win32 error. If the facility code
// of the HRESULT is FACILITY_WIN32, then the code portion (i.e. the
// original Win32 error) is returned. Otherwise, the original HRESULT is
// returned unchagned.
//

#define HRESULT_CODE(hr)     ((hr) & 0xFFFF)
#define HRESULTTOWIN32(hres) ((HRESULT_FACILITY(hres) == FACILITY_WIN32) ? HRESULT_CODE(hres) : (hres))

static const DWORD dwServiceWaitHint = 60000;   // 60 seconds

SERVICE_STATUS_HANDLE g_hTheCiSvc = 0;
static DWORD dwCiSvcStatus = SERVICE_START_PENDING;

#define DEB_CI_MOUNT DEB_ITRACE

// 1: 324666 is fixed
// 0: 324666 is not fixed and we need an extra thread to work around it

#define SYNC_REGISTER 1

BOOL g_fSCMThreadIsGone = FALSE;

//+----------------------------------------------------------------------------
//
//  Function:   UpdateServiceStatus
//
//  Synopsis:   Does a SetServiceStatus() to the service manager.
//
//  History:    06-Jun-94   DwightKr    Created
//
//-----------------------------------------------------------------------------

void UpdateServiceStatus( DWORD dwWin32ExitCode )
{
    // note to accept power events, "OR" SERVICE_ACCEPT_POWER_EVENTS here
    static SERVICE_STATUS CiSvcStatus =
    {
        SERVICE_WIN32_OWN_PROCESS |         // dwServiceType
          SERVICE_INTERACTIVE_PROCESS,      // add this line for interactive
        0,                                  // dwCurrentState
        SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE |
        SERVICE_ACCEPT_SHUTDOWN,
        NO_ERROR,                           // dwWin32ExitCode
        0,                                  // dwServiceSpecificExitCode
        0,                                  // dwCheckPoint
        0                                   // dwWaitHint
    };

    CiSvcStatus.dwCurrentState  = dwCiSvcStatus;

    CiSvcStatus.dwWin32ExitCode = dwWin32ExitCode;

    if ( dwCiSvcStatus == SERVICE_START_PENDING ||
         dwCiSvcStatus == SERVICE_STOP_PENDING )
    {
        CiSvcStatus.dwCheckPoint++;
        CiSvcStatus.dwWaitHint = dwServiceWaitHint;
    }
    else // SERVICE_RUNNING, SERVICE_STOPPED, SERVICE_PAUSED, ...
    {
        CiSvcStatus.dwCheckPoint = 0;
        CiSvcStatus.dwWaitHint   = 0;
    }

    ciDebugOut(( DEB_ITRACE, "service status: %d\n", dwCiSvcStatus ));

    BOOL fOK = SetServiceStatus(g_hTheCiSvc, &CiSvcStatus);

#if CIDBG == 1
    if ( !fOK )
        ciDebugOut(( DEB_ITRACE, "Ci Service: Error from SetServiceStatus = 0x%x\n", GetLastError() ));
#endif
} //UpdateServerStatus

//+-------------------------------------------------------------------------
//
//  Function:   ProcessCustomEvent
//
//  Synopsis:   This is a helper for HandleDevNotification. It processes
//              the device custom events
//
//  Arguments:  [pEventData] -- a PDEV_BROADCAST_HDR object
//              [pContext]   -- a CDrvNotifArray * object.
//
//  Return:     error code from the StartCatalogOnVol/StopCatalogsOnVol
//              proceudres
//
//  History:    18-May-98       kitmanh        Created
//              12-Aug-98       kitmanh        Added return value
//
//--------------------------------------------------------------------------

SCODE ProcessCustomEvent( PVOID pEventData, PVOID pContext )
{
    SCODE sc = S_OK;
    DEV_BROADCAST_HDR UNALIGNED *pBroadcastHdr = (PDEV_BROADCAST_HDR) pEventData;

    ciDebugOut(( DEB_CI_MOUNT, "What is the device type? (%#x)\n", 
                 pBroadcastHdr->dbch_devicetype ));

    // is this a handled event?
    if ( DBT_DEVTYP_HANDLE != pBroadcastHdr->dbch_devicetype)
        return ERROR_CALL_NOT_IMPLEMENTED;

    DEV_BROADCAST_HANDLE UNALIGNED *pDevBroadcastHandle = (PDEV_BROADCAST_HANDLE) pBroadcastHdr;

    ciDebugOut(( DEB_CI_MOUNT, "It is a handled type, handle %#x\n",
                 pDevBroadcastHandle->dbch_hdevnotify ));

    CDrvNotifArray * pDrvNotifArray = (CDrvNotifArray *)pContext;

    CDrvNotificationInfo * pDriveInfo = pDrvNotifArray->FindDriveNotificationByHandle(
                                        (HDEVNOTIFY) pDevBroadcastHandle->dbch_hdevnotify);

    if ( 0 != pDriveInfo )
    {
        if ( GUID_IO_VOLUME_LOCK == pDevBroadcastHandle->dbch_eventguid ) 
        {
            // a volume lock occurred
            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_LOCK for volume %wc\n", 
                         pDriveInfo->GetDrvLetter() ));
                        
            if ( eVolReady == pDriveInfo->GetVolState() ) 
            {
                ciDebugOut(( DEB_CI_MOUNT, "About to stop catalogs on Vol\n" ));
                sc = StopCiSvcWork( eLockVol, pDriveInfo->GetDrvLetter() );   //stop catalog on volume
                ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done stopping the catalogs\n" ));

                pDriveInfo->SetVolState( eVolLocked ); 
            }
                        
            ciDebugOut(( DEB_CI_MOUNT, "Increment Lock Attempts\n" ));
            pDriveInfo->IncLockAttempts();
            ciDebugOut(( DEB_CI_MOUNT, "_cLockAttempts is %d\n", pDriveInfo->GetLockAttempts() ));
        }
        else if ( GUID_IO_MEDIA_REMOVAL == pDevBroadcastHandle->dbch_eventguid ) 
        {
            // CD-ROMs aren't giving dismount/unlock notifies,
            // so key off of this instead.  This is "by design" apparently.
            // A media removal occurred.  If we have a CD-ROM catalog
            // open, close it.

            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_MEDIA_REMOVAL for volume %wc\n", 
                         pDriveInfo->GetDrvLetter() ));

            WCHAR awc[4];
            wcscpy( awc, L"C:\\" );
            awc[0] = pDriveInfo->GetDrvLetter();

            if ( DRIVE_CDROM == GetDriveType( awc ) )
            {
                if ( eVolReady == pDriveInfo->GetVolState() ) 
                {
                    ciDebugOut(( DEB_CI_MOUNT, "About to stop catalogs on Vol\n" ));
                    sc = StopCiSvcWork( eLockVol, pDriveInfo->GetDrvLetter() );   //stop catalog on volume
                    ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done stopping the catalogs\n" ));
                }
            }
        }
        else if ( GUID_IO_VOLUME_UNLOCK == pDevBroadcastHandle->dbch_eventguid )
        {
            // This assert is not always true for CD-ROMs.  I don't know why

            //Win4Assert( eVolLocked == pDriveInfo->GetVolState() );

            if ( eVolLocked == pDriveInfo->GetVolState() )
            {
                // a volume was unlocked

                ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_UNLOCK for volume %wc, removable %s, automount %s\n", 
                             pDriveInfo->GetDrvLetter(),
                             pDriveInfo->IsRemovable() ? "yes" : "no",
                             pDriveInfo->IsAutoMount() ? "yes" : "no" ));
    
                pDriveInfo->ResetLockAttempts();
                
                // Unregister since the _hVol is obsolete
    
                pDriveInfo->UnregisterNotification();
    
                //
                // We can open catalogs on fixed volumes on the unlock, but not on
                // removable volumes, since we get an unlock once the volume is
                // ejected.  For removable volumes, open the catalog on the mount,
                // except for the case of chkdsk where the volume will be mountable
                // immediately and we won't get the mount notification
                // For Fixed volumes, don't wait for the mount since it may be a
                // long time until the mount happens.
                //
    
                if ( pDriveInfo->Touch() )
                {
                    ciDebugOut(( DEB_CI_MOUNT, "About to start catalogs on Vol %wc\n",
                                 pDriveInfo->GetDrvLetter() ));
                    sc = StopCiSvcWork( eUnLockVol, pDriveInfo->GetDrvLetter() );
                    ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done starting the catalogs\n" ));
                }
    
                //
                // Asynchronously redo RegisterDeviceNotification with a new
                //  volume handle.
                // If we don't unregister/reregister on Jaz volumes we never get a
                // mount notify.  But on fixed volumes if we unregister/reregister
                // we miss the mount since it happens before the register succeeds
                // on an operation like chkdsk.
                //
    
#if SYNC_REGISTER
                pDriveInfo->RegisterNotification();
#else
                pDrvNotifArray->RegisterDormantEntries();
#endif
    
                pDriveInfo->SetVolState( eVolReady );
            }
        }
        else if ( GUID_IO_VOLUME_LOCK_FAILED == pDevBroadcastHandle->dbch_eventguid )
        {
            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_LOCK_FAILED for volume %wc\n",
                         pDriveInfo->GetDrvLetter() ));

            if ( pDriveInfo->GetLockAttempts() > 0 )
            { 
                ciDebugOut(( DEB_CI_MOUNT, "Decrement _cLockAttempts\n" ));
                pDriveInfo->DecLockAttempts();
            }
            else
            {
                Win4Assert( eVolReady == pDriveInfo->GetVolState() );
            }

            ciDebugOut(( DEB_CI_MOUNT, "_cLockAttempts is %d\n", pDriveInfo->GetLockAttempts() ));
                                
            if ( ( 0 == pDriveInfo->GetLockAttempts() ) && 
                 ( eVolLocked == pDriveInfo->GetVolState() ) ) 
            {
                // unlock the volume, since all attemps to lock the volume have failed.

                pDriveInfo->UnregisterNotification();

                ciDebugOut(( DEB_CI_MOUNT, "About to start(lock_failed) catalogs on Vol %wc\n", pDriveInfo->GetDrvLetter() ));
                sc = StopCiSvcWork( eUnLockVol, pDriveInfo->GetDrvLetter() );
                ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done starting the catalogs\n" ));

                // redo RegisterDeviceNotification with a new volume handle
#if SYNC_REGISTER
                pDriveInfo->RegisterNotification();
#else
                pDrvNotifArray->RegisterDormantEntries();
#endif
                pDriveInfo->SetVolState( eVolReady );   
                ciDebugOut(( DEB_CI_MOUNT, "Done Unlocking for lock_failed\n" ));
            }
        }
        else if ( GUID_IO_VOLUME_DISMOUNT == pDevBroadcastHandle->dbch_eventguid &&
                  eVolReady == pDriveInfo->GetVolState() )
        {
            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_DISMOUNT for volume %wc, removable %s, automount %s\n",
                         pDriveInfo->GetDrvLetter(),
                         pDriveInfo->IsRemovable() ? "yes" : "no",
                         pDriveInfo->IsAutoMount() ? "yes" : "no" ));

            ciDebugOut(( DEB_CI_MOUNT, "About to stop catalogs on Vol %wc\n", pDriveInfo->GetDrvLetter() ));
            sc = StopCiSvcWork( eLockVol, pDriveInfo->GetDrvLetter() );   //stop catalog on volume
            ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done stopping the catalogs on Vol %wc\n", pDriveInfo->GetDrvLetter() ));

            pDriveInfo->SetVolState( eVolLocked );
        }
        else if ( GUID_IO_VOLUME_DISMOUNT_FAILED == pDevBroadcastHandle->dbch_eventguid &&
                  eVolReady != pDriveInfo->GetVolState() )
        {
            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_DISMOUNT_FAILED for volume %wc\n",
                         pDriveInfo->GetDrvLetter() ));
            
            pDriveInfo->UnregisterNotification();

            ciDebugOut(( DEB_CI_MOUNT, "About to start(dimount_failed) catalogs on Vol %wc\n", pDriveInfo->GetDrvLetter() ));
            sc = StopCiSvcWork( eUnLockVol, pDriveInfo->GetDrvLetter() );
            ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done starting the catalogs\n" ));

            // redo RegisterDeviceNotification with a new volume handle
#if SYNC_REGISTER
            pDriveInfo->RegisterNotification();
#else
            pDrvNotifArray->RegisterDormantEntries();
#endif
            pDriveInfo->SetVolState( eVolReady );
        }
        else if ( GUID_IO_VOLUME_MOUNT == pDevBroadcastHandle->dbch_eventguid )
        {
            ciDebugOut(( DEB_CI_MOUNT, "GUID_IO_VOLUME_MOUNT for volume %wc, removable %s, automount %s\n",
                         pDriveInfo->GetDrvLetter(),
                         pDriveInfo->IsRemovable() ? "yes" : "no",
                         pDriveInfo->IsAutoMount() ? "yes" : "no" ));

            //
            // Mount notifications come at the oddest times -- even after an
            // eject of a removable volume!  Make sure the volume really is
            // valid by touching it before trying to open a catalog on the
            // volume.  Only start catalogs on mount for removable drives.
            // Start catalogs for fixed drives on Unlock.  This is because
            // we have to asynchronously re-register for notifications after
            // an unlock, and by the time we register we've missed the mount.
            // Lovely piece of design work by the pnp guys.  Note: this is
            // partially fixed in current builds.  If we don't re-register
            // we get everything but mount notifications on removable
            // drives.
            //

            BOOL fOK = pDriveInfo->Touch();

            ciDebugOut(( DEB_CI_MOUNT, "drive %wc appears healthy? %d\n",
                         pDriveInfo->GetDrvLetter(),
                         fOK ));

            if ( fOK && pDriveInfo->IsRemovable() )
            {
                ciDebugOut(( DEB_CI_MOUNT, "About to start catalogs on Vol\n" ));
                sc = StopCiSvcWork( eUnLockVol, pDriveInfo->GetDrvLetter() );
                ciDebugOut(( DEB_CI_MOUNT, "Ci Service: Done starting the catalogs\n" ));
            }
        }
        else
        {
            ciDebugOut(( DEB_CI_MOUNT, "UNHANDLED but device object was recognized\n" ));

            if ( GUID_IO_VOLUME_LOCK_FAILED   == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_LOCK_FAILED\n" ));
            else if ( GUID_IO_VOLUME_DISMOUNT_FAILED == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_DISMOUNT_FAILED\n" ));
            else if ( GUID_IO_VOLUME_LOCK     == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_LOCK\n" ));
            else if ( GUID_IO_VOLUME_UNLOCK   == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_UNLOCK\n" ));
            else if ( GUID_IO_VOLUME_DISMOUNT == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_DISMOUNT\n" ));
            else if ( GUID_IO_VOLUME_MOUNT    == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_VOLUME_MOUNT\n" ));
            else if ( GUID_IO_MEDIA_ARRIVAL   == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_MEDIA_ARRIVAL\n" ));
            else if ( GUID_IO_MEDIA_REMOVAL   == pDevBroadcastHandle->dbch_eventguid )
                ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_MEDIA_REMOVAL\n" ));
            else
                ciDebugOut(( DEB_CI_MOUNT, "   eventguid: {%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
                             pDevBroadcastHandle->dbch_eventguid.Data1,
                             pDevBroadcastHandle->dbch_eventguid.Data2,
                             pDevBroadcastHandle->dbch_eventguid.Data3,
                             pDevBroadcastHandle->dbch_eventguid.Data4[0], pDevBroadcastHandle->dbch_eventguid.Data4[1],
                             pDevBroadcastHandle->dbch_eventguid.Data4[2], pDevBroadcastHandle->dbch_eventguid.Data4[3],
                             pDevBroadcastHandle->dbch_eventguid.Data4[4], pDevBroadcastHandle->dbch_eventguid.Data4[5],
                             pDevBroadcastHandle->dbch_eventguid.Data4[6], pDevBroadcastHandle->dbch_eventguid.Data4[7] ));
        }
    }
    else
    {
        ciDebugOut(( DEB_CI_MOUNT, "   handle: %#x\n", pDevBroadcastHandle->dbch_handle ));
        ciDebugOut(( DEB_CI_MOUNT, "   hdev_notify: %#x\n", pDevBroadcastHandle->dbch_hdevnotify ));
        ciDebugOut(( DEB_CI_MOUNT, "   nameoffset: %#x\n", pDevBroadcastHandle->dbch_nameoffset ));

        if ( GUID_IO_VOLUME_LOCK_FAILED == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_LOCK_FAILED\n" ));
        else if ( GUID_IO_VOLUME_DISMOUNT_FAILED == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_DISMOUNT_FAILED\n" ));
        else if ( GUID_IO_VOLUME_LOCK == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_LOCK\n" ));
        else if ( GUID_IO_VOLUME_UNLOCK == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_UNLOCK\n" ));
        else if ( GUID_IO_VOLUME_DISMOUNT == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_DISMOUNT\n" ));
        else if ( GUID_IO_VOLUME_MOUNT == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "    GUID_IO_VOLUME_MOUNT\n" ));
        else if ( GUID_IO_MEDIA_ARRIVAL == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_MEDIA_ARRIVAL\n" ));
        else if ( GUID_IO_MEDIA_REMOVAL == pDevBroadcastHandle->dbch_eventguid )
            ciDebugOut(( DEB_CI_MOUNT, "   GUID_IO_MEDIA_REMOVAL\n" ));
        else
            ciDebugOut(( DEB_CI_MOUNT, "   eventguid: {%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
                         pDevBroadcastHandle->dbch_eventguid.Data1,
                         pDevBroadcastHandle->dbch_eventguid.Data2,
                         pDevBroadcastHandle->dbch_eventguid.Data3,
                         pDevBroadcastHandle->dbch_eventguid.Data4[0], pDevBroadcastHandle->dbch_eventguid.Data4[1],
                         pDevBroadcastHandle->dbch_eventguid.Data4[2], pDevBroadcastHandle->dbch_eventguid.Data4[3],
                         pDevBroadcastHandle->dbch_eventguid.Data4[4], pDevBroadcastHandle->dbch_eventguid.Data4[5],
                         pDevBroadcastHandle->dbch_eventguid.Data4[6], pDevBroadcastHandle->dbch_eventguid.Data4[7] ));
    }

    return sc;
} //ProcessCustomEvent

//+----------------------------------------------------------------------------
//
//  Function:   CiSvcMsgProc
//
//  Synopsis:   Message handler for Ci service
//
//  Arguments:  [dwControl] - the message.
//
//  Returns:    Nothing
//
//  History:    06-Jun-94   DwightKr    Created
//              06-23-98    KitmanH     Updated for RegisterServiceCtrlHandlerEx
//              07-30-98    KitmanH     Return appropriate errors
//
//  Notes:      We need to keep the status between calls to this routine
//              since the service control manager may query the current
//              status at any time.
//
//-----------------------------------------------------------------------------

DWORD WINAPI CiSvcMsgProc( DWORD dwControl, 
                           DWORD dwEventType, 
                           PVOID pEventData, 
                           PVOID pContext )
{
    ciDebugOut(( DEB_ITRACE,
                 "Ci 0Service: Executing service control command 0x%x\n",
                 dwControl ));
    
    Win4Assert( pContext );

    BOOL fShutdown = FALSE;
    DWORD dwError = NO_ERROR;
    
    TRY
    {
        switch (dwControl)
        {
        case SERVICE_CONTROL_STOP:
        case SERVICE_CONTROL_SHUTDOWN:
            UpdateServiceStatus( NO_ERROR );

            if ( SERVICE_STOP_PENDING != dwCiSvcStatus )
            {
                ciDebugOut(( DEB_ITRACE, "About to stop\n" ));
                dwCiSvcStatus = SERVICE_STOP_PENDING;

                if ( ! g_fSCMThreadIsGone )
                    StopCiSvcWork( eNetStop );
            }
            ciDebugOut( (DEB_ITRACE, "Ci Service: Done shutting down service\n" ));

            //
            // Calling UpdateServiceStatus() after doing the shutdown is
            // causing the service to hang. Not calling solved the problem
            // and so I am preventing it from being called.
            //
            fShutdown = TRUE;
            break;

        case SERVICE_CONTROL_PAUSE:
            if ( SERVICE_PAUSED != dwCiSvcStatus &&
                 SERVICE_STOP_PENDING != dwCiSvcStatus )
            {
                ciDebugOut(( DEB_ITRACE, "About to pause\n" ));
                if ( ! g_fSCMThreadIsGone )
                    StopCiSvcWork( eNetPause );
                dwCiSvcStatus = SERVICE_PAUSED;
                ciDebugOut(( DEB_ITRACE, "Ci Service: Done pausing the service\n" ));
            }
            break;

        case SERVICE_CONTROL_CONTINUE:
            if ( SERVICE_PAUSED == dwCiSvcStatus &&
                 SERVICE_STOP_PENDING != dwCiSvcStatus )
            {
                ciDebugOut(( DEB_ITRACE, "About to continue\n" ));
                if ( ! g_fSCMThreadIsGone )
                    StopCiSvcWork( eNetContinue );
                dwCiSvcStatus = SERVICE_RUNNING;
            }
            ciDebugOut(( DEB_ITRACE, "Ci Service: Done continuing the service\n" ));
            break;

        case SERVICE_CONTROL_DEVICEEVENT:
            // a dismount or remount may have occurred

            ciDebugOut(( DEB_ITRACE, "SERVICE_CONTROL_DEVICEEVENT received, event = %#x\n",
                         dwEventType ));

            {
                SCODE sc = S_OK;

                if ( DBT_CUSTOMEVENT == dwEventType )
                {
                    ciDebugOut(( DEB_ITRACE, "It is a custom event\n" ));
                    if ( ! g_fSCMThreadIsGone )
                        sc = ProcessCustomEvent( pEventData, pContext );
                    ciDebugOut(( DEB_ITRACE, "Done processing custom event\n" ));
                }

                // convert sc into a WIN32 error and return it
                ciDebugOut(( DEB_ITRACE, "Process Custom Event returned sc = %#x\n", sc ));
                    
                dwError = HRESULTTOWIN32(sc);
            }
            break;

        case SERVICE_CONTROL_INTERROGATE:
            break;

        default:
            ciDebugOut(( DEB_CI_MOUNT, "service control not implemented %d\n", dwControl ));
            dwError = ERROR_CALL_NOT_IMPLEMENTED;
            break;
        }

        UpdateServiceStatus( NO_ERROR );
    }
    CATCH (CException, e)
    {
        ciDebugOut(( DEB_ITRACE, "Ci Service: Error from callback = 0x%x\n", e.GetErrorCode() ));
    }
    END_CATCH

    ciDebugOut(( DEB_ITRACE, "Getting out of CiSvcMsgProc\n" ));
   
    return dwError;
} //CiSvcMsgProc

//+-------------------------------------------------------------------------
//
//  Function:   CiServiceMain, public
//
//  Purpose:    Service entry point
//
//  Arguments:  [dwNumServiceArgs] - number of arguments passed
//              [awcsServiceArgs]  - arguments
//
//  History:    06-Jun-94   DwightKr    Created
//
//--------------------------------------------------------------------------

extern CEventSem * g_pevtPauseContinue;

void CiSvcMain(
    DWORD    dwNumServiceArgs,
    LPWSTR * awcsServiceArgs )
{
    // The service control manager crofted up this thread, so we have to
    // establish the exception state, etc.

    CTranslateSystemExceptions translate;
    TRY
    {
        CDrvNotifArray DrvNotifArray;

        ciDebugOut( (DEB_ITRACE, "Ci Service: Attempting to register service\n" ));

        // Register service handler with service controller

        g_hTheCiSvc = RegisterServiceCtrlHandlerEx( wcsCiSvcName,
                                                    CiSvcMsgProc,
                                                    &DrvNotifArray );
        if (0 == g_hTheCiSvc)
        {
            ciDebugOut(( DEB_ERROR, "Unable to register ci service\n" ));
            THROW( CException( E_FAIL ) );
        }

        CEventSem evtPauseContinue;
        g_pevtPauseContinue = &evtPauseContinue;

        UpdateServiceStatus( NO_ERROR );

        CRegAccess reg( RTL_REGISTRY_CONTROL, wcsRegAdmin );

        if ( 1 != reg.Read( wcsPreventCisvcParam, (ULONG) 0 ) )
        {
            dwCiSvcStatus = SERVICE_RUNNING;
            UpdateServiceStatus( NO_ERROR );

            #if CIDBG == 1
                BOOL fRun = TRUE;   // FALSE --> Stop

                TRY
                {
                    ULONG ulVal = reg.Read( L"StopCiSvcOnStartup", (ULONG)0 );

                    if ( 1 == ulVal )
                        fRun = FALSE;
                }
                CATCH( CException, e )
                {
                }
                END_CATCH;

                unsigned long OldWin4AssertLevel = SetWin4AssertLevel(ASSRT_MESSAGE | ASSRT_POPUP);

                Win4Assert( fRun );

                SetWin4AssertLevel( OldWin4AssertLevel );
            #endif // CIDBG

            // Register for pnp notifications on drives used by catalogs

            DrvNotifArray.RegisterCatForNotifInRegistry();

            //
            // Register for pnp notifications on removable drives not yet
            // registered if the registry flag says it's appropriate.
            //

            if ( 0 != reg.Read( wcsMountRemovableCatalogs,
                                CI_AUTO_MOUNT_CATALOGS_DEFAULT ) )
                DrvNotifArray.RegisterRemovableDrives();

            StartCiSvcWork( DrvNotifArray );

            DrvNotifArray.UnregisterDeviceNotifications();

            ciDebugOut(( DEB_ITRACE, "service_stopped from CiSvcMain\n" ));
        }
        else
        {
            CEventLog eventLog( NULL, wcsCiEventSource );
            CEventItem item( EVENTLOG_INFORMATION_TYPE,
                             CI_SERVICE_CATEGORY,
                             MSG_CI_SERVICE_SUPPRESSED,
                             0 );
            eventLog.ReportEvent( item );
        }

        dwCiSvcStatus = SERVICE_STOPPED;
        UpdateServiceStatus( NO_ERROR );
        ciDebugOut(( DEB_ITRACE, "Shutdown is done\n" ));

        CoFreeUnusedLibraries();

        ciDebugOut( (DEB_ITRACE, "Ci Service: Leaving CiSvcMain()\n" ));
    }
    CATCH (CException, e)
    {
        ciDebugOut( (DEB_ITRACE, "Ci Service: Detected error 0x%x\n", e.GetErrorCode() ));
    }
    END_CATCH

    g_pevtPauseContinue = 0;
    g_fSCMThreadIsGone = TRUE;
} //CiSvcMain

//+----------------------------------------------------------------------------
//
//  Function:   SvcEntry_CiSvc
//
//  Synopsis:   Entry from services.exe
//
//              This is currently broken since services doesn't unload
//              query.dll when the service is stopped, and our global
//              variables don't expect to be used again when the service
//              is restarted.  It's probably a week of work to fix this!
//              We don't do this anyway so it doesn't matter.
//
//  History:    05-Jan-97   dlee    Created
//
//-----------------------------------------------------------------------------

void SvcEntry_CiSvc(
    DWORD    NumArgs,
    LPWSTR * ArgsArray,
    void *   pSvcsGlobalData,
    HANDLE   SvcRefHandle )
{
    CiSvcMain( NumArgs, ArgsArray );
} //SvcEntry_CiSvc