windows-server-2003/drivers/storage/volsnap/vss/server/modules/vswriter/vswrtimp.cpp

/*++

Copyright (c) 1999  Microsoft Corporation

Abstract:

    @doc
    @module VsWrtImp.cpp | Implementation of Writer
    @end

Author:

    Adi Oltean  [aoltean]  02/02/2000

TBD:

    Add comments.

    Remove the C++ exception-handler related code.

Revision History:

    Name        Date        Comments
    aoltean     02/02/2000  Created
    brianb      03/25/2000  modified to include additional events
    brianb      03/28/2000  modified to include timeouts and sync for OnPrepareBackup
    brianb      03/28/2000  renamed to vswrtimp.cpp to separate internal state from external interface
    brianb      04/19/2000  added security checks
    brianb      05/03/2000  new security model
    brianb      05/09/2000  fix problem with autolocks

--*/


#include <stdafx.hxx>
#include <eventsys.h>

#include "vs_inc.hxx"
#include "vs_sec.hxx"
#include "vs_idl.hxx"
#include "vs_reg.hxx"

#include "vscoordint.h"
#include "comadmin.hxx"
#include "vsevent.h"
#include "vswriter.h"
#include "vsbackup.h"
#include "vssmsg.h"

#include "vswrtimp.h"


// xml support
#include "vs_wmxml.hxx"
#include "vs_cmxml.hxx"



#include "rpcdce.h"

////////////////////////////////////////////////////////////////////////
//  Standard foo for file name aliasing.  This code block must be after
//  all includes of VSS header files.
//
#ifdef VSS_FILE_ALIAS
#undef VSS_FILE_ALIAS
#endif
#define VSS_FILE_ALIAS "WRTWRTIC"
//
////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////
// Constants


const WCHAR g_wszPublisherID[]          = L"VSS Publisher";

// event names
const WCHAR g_wszRequestInfoMethodName[]        = L"RequestWriterInfo";
const WCHAR g_wszPrepareForBackupMethodName[]   = L"PrepareForBackup";
const WCHAR g_wszBackupCompleteMethodName[]     = L"BackupComplete";

const WCHAR g_wszPrepareForSnapshotMethodName[] = L"PrepareForSnapshot";
const WCHAR g_wszFreezeMethodName[]             = L"Freeze";
const WCHAR g_wszThawMethodName[]               = L"Thaw";
const WCHAR g_wszPostSnapshotMethodName[]       = L"PostSnapshot";
const WCHAR g_wszAbortMethodName[]              = L"Abort";

const WCHAR g_wszPreRestoreMethodName[]         = L"PreRestore";
const WCHAR g_wszPostRestoreMethodName[]        = L"PostRestore";
const WCHAR g_wszBackupShutdownName[]                 = L"BackupShutdown";

// List of received volumes is in the following formatDate
// <Volume Name 1>;<Volume Name 2>: ... :<Volume Name N>
const WCHAR VSS_VOLUME_DELIMITERS[] = L";";

// class describing state machine for writer
class CVssWriterImplStateMachine
    {
private:
    // disable default and copy constructors
    CVssWriterImplStateMachine();

public:
    CVssWriterImplStateMachine
        (
        VSS_WRITER_STATE previousState,
        VSS_WRITER_STATE successfulExitState,
        VSS_WRITER_STATE failureExitState,
        bool bBeginningState,
        bool bSuccessiveState,
        bool bResetSequenceOnLeave
        ) :
        m_previousState(previousState),
        m_successfulExitState(successfulExitState),
        m_failureExitState(failureExitState),
        m_bBeginningState(bBeginningState),
        m_bSuccessiveState(bSuccessiveState),
        m_bResetSequenceOnLeave(bResetSequenceOnLeave)
        {
        }

    // previous state writer must be in to enter the current
    // state unless this is the first state of a sequence
    VSS_WRITER_STATE m_previousState;

    // state we are in if the operation is successful
    VSS_WRITER_STATE m_successfulExitState;

    // state we are in if the operation is uncessful
    VSS_WRITER_STATE m_failureExitState;

    // is this state a possible state for the beginning of the sequence
    bool m_bBeginningState;

    // is this a possible non-beginning state in a sequence
    bool m_bSuccessiveState;

    // should the sequence be reset on successful exit of the state
    bool m_bResetSequenceOnLeave;
    };


// definition of state machine
static CVssWriterImplStateMachine s_rgWriterStates[] =
    {
    // OnPrepareBackup
    CVssWriterImplStateMachine
        (
        VSS_WS_STABLE,                      // previous state
        VSS_WS_STABLE,                      // next state if successful
        VSS_WS_FAILED_AT_PREPARE_BACKUP,    // next state if failure
        true,                               // this can be a first state
        false,                              // this must be a first state
        false                               // do not reset sequence on leaving this state
        ),

    // OnPrepareSnapshot
    CVssWriterImplStateMachine
        (
        VSS_WS_STABLE,                      // previous state
        VSS_WS_WAITING_FOR_FREEZE,          // next state if successful
        VSS_WS_FAILED_AT_PREPARE_SNAPSHOT,  // next state if failure
        true,                               // this can be a first state
        true,                               // this can be a follow on state
        false                               // do not reset sequence on leaving this state
        ),


    // OnFreeze
    CVssWriterImplStateMachine
        (
        VSS_WS_WAITING_FOR_FREEZE,          // previous state
        VSS_WS_WAITING_FOR_THAW,            // next state if successful
        VSS_WS_FAILED_AT_FREEZE,            // next state if unsuccessful
        false,                              // this may not be a first state
        true,                               // this must be a follow on state
        false                               // do not reset sequence on leaving this state
        ),

    // OnThaw
    CVssWriterImplStateMachine
        (
        VSS_WS_WAITING_FOR_THAW,            // previous state
        VSS_WS_WAITING_FOR_POST_SNAPSHOT,   // next state if successful
        VSS_WS_FAILED_AT_THAW,              // next state if unsuccessful
        false,                              // this may not be a first state
        true,                               // this must be a follow on state
        false                               // reset sequence on leaving this state
        ),

    // OnPostSnapshot
    CVssWriterImplStateMachine
        (
        VSS_WS_WAITING_FOR_POST_SNAPSHOT,   // previous state
        VSS_WS_WAITING_FOR_BACKUP_COMPLETE, // next state if successful
        VSS_WS_FAILED_AT_POST_SNAPSHOT,     // next state if unsuccessful
        false,                              // this may not be a first state
        true,                               // this must be a follow on state
        true                                // reset sequence on leaving this state
        )


    };

// state ids
static const unsigned s_ivwsmPrepareForBackup = 0;
static const unsigned s_ivwsmPrepareForSnapshot = 1;
static const unsigned s_ivwsmFreeze = 2;
static const unsigned s_ivwsmThaw = 3;
static const unsigned s_ivwsmPostSnapshot = 4;



/////////////////////////////////////////////////////////////////////////////
// CVssWriterImpl constructors/destructors


// constructor
CVssWriterImpl::CVssWriterImpl():
    m_bInitialized(false),
    m_writerstate(m_diag),
    m_WriterID(GUID_NULL),
    m_InstanceID(GUID_NULL),
    m_usage(VSS_UT_UNDEFINED),
    m_source(VSS_ST_UNDEFINED),
    m_nLevel(VSS_APP_FRONT_END),
    m_dwTimeoutFreeze(VSS_TIMEOUT_FREEZE),
    m_CurrentSnapshotSetId(GUID_NULL),
    m_lContext(VSS_CTX_BACKUP),
    m_nVolumesCount(0),
    m_ppwszVolumesArray(NULL),
    m_pwszLocalVolumeNameList(NULL),
    m_dwEventMask(0),
    m_wszWriterName(NULL),
    m_hevtTimerThread(NULL),
    m_hmtxTimerThread(NULL),
    m_hThreadTimerThread(NULL),
    m_bLocked(false),
    m_bLockCreated(false),
    m_command(VSS_TC_UNDEFINED),
    m_cbstrSubscriptionId(0),
    m_bOnAbortPermitted(false),
    m_bSequenceInProgress(false),
    m_pWriter(NULL),
    m_bBootableSystemStateBackup(false),
    m_bComponentsSelected(false),
    m_backupType(VSS_BT_UNDEFINED),
    m_restoreType(VSS_RTYPE_UNDEFINED),
    m_bPartialFileSupport(false),
    m_bInSafeMode(false),
    m_bInSetup(false)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::CVssWriterImpl");
    ft.Trace( VSSDBG_WRITER, L"*** Constructing object %p", this);
    }

// destructor
CVssWriterImpl::~CVssWriterImpl()
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::~CVssWriterImpl");
    ft.Trace( VSSDBG_WRITER, L"*** Destructing object %p", this);
    Uninitialize();
    }

void CVssWriterImpl::Uninitialize()
    {

    if (!m_bInitialized) 
        return;
    
    // terminate timer thread if it is still running
    if (m_bLockCreated)
        {
        if (m_bstrSubscriptionName.Length() > 0)
            {
            try
                {
                Unsubscribe();
                }
            catch(...)
                {
                }
            }

        Lock();
        TerminateTimerThread();
        Unlock();
        m_cs.Uninit();
        m_bLockCreated = false;
        }

    // delete volume array
    delete[] m_ppwszVolumesArray;
    m_ppwszVolumesArray = NULL;

    // delete volume list string
    ::VssFreeString(m_pwszLocalVolumeNameList);

    // delete writer name
    free(m_wszWriterName);
    m_wszWriterName = NULL;


    if (m_hevtTimerThread)
        {
        CloseHandle(m_hevtTimerThread);
        m_hevtTimerThread = NULL;
        }

    if (m_hmtxTimerThread)
        {
        CloseHandle(m_hmtxTimerThread);
        m_hmtxTimerThread = NULL;
        }
    }

    // get the snapshot device name for a particular volume
HRESULT CVssWriterImpl::GetSnapshotDeviceName
        (
        LPCWSTR wszOriginalVolume,
        LPCWSTR* ppwszSnapshotDevice
        ) const
    	{
    	UNREFERENCED_PARAMETER(wszOriginalVolume);
	UNREFERENCED_PARAMETER(ppwszSnapshotDevice);

	return E_NOTIMPL;
    	}
	
// create an event
void CVssWriterImpl::SetupEvent(IN HANDLE *phevt)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImple::SetupEvent");

    BS_ASSERT(phevt);
    // setup events as enabled and manual reset
    *phevt = CreateEvent(NULL, TRUE, TRUE, NULL);
    if (*phevt == NULL)
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Failure to create event object due to error %d.",
            GetLastError()
            );
    }


// initialize writer object
// This function returns S_FALSE when the writer is inactive (setup or safe mode)
void CVssWriterImpl::Initialize
    (
    IN VSS_ID WriterID,             // writer class id
    IN LPCWSTR wszWriterName,       // friendly name of writer
    IN VSS_USAGE_TYPE usage,        // usage type
    IN VSS_SOURCE_TYPE source,      // data source type
    IN VSS_APPLICATION_LEVEL nLevel, // which freeze event this writer handles
    IN DWORD dwTimeoutFreeze         // timeout between freeze and thaw
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::Initialize");

    // validate that the writer is initialized
    if (m_bInitialized)
        ft.Throw
            (
            VSSDBG_WRITER,
            VSS_E_BAD_STATE,
            L"You cannot initialize the writer twice"
            );

    // determine if we are in setup.  If we are then reject the
    // initialize call and log an error in the application log
    m_bInSetup = CVssMachineInformation::IsDuringSetup();
    if (m_bInSetup)
    {
        ft.LogError(VSS_ERROR_SETUP_WRITER, VSSDBG_WRITER << wszWriterName << WriterID );
        ft.Throw(VSSDBG_WRITER, S_FALSE, L"Calling Initialize during setup");
    }

    // determine if we are in safe mode.  If we are then reject the
    // initialize call and log an error in the application log
    m_bInSafeMode = CVssMachineInformation::IsDuringSafeMode();
    if (m_bInSafeMode)
    {
        ft.LogError(VSS_ERROR_SAFE_MODE_WRITER, VSSDBG_WRITER << wszWriterName << WriterID );
        ft.Throw(VSSDBG_WRITER, S_FALSE, L"Calling Initialize during safe mode");
    }

    // Initialize the list of possible SIDs from registry
    m_SidCollection.Initialize();

    // Check if the writer runs under a proper user
    if (!m_SidCollection.IsProcessValidWriter())
    {
        ft.LogError(VSS_ERROR_NON_PRIVILEGED_WRITER, VSSDBG_WRITER << wszWriterName << WriterID );
        ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"Writer is not privileged");
    }

    // Testing arguments validity
    if (wszWriterName == NULL)
        ft.Throw
            (
            VSSDBG_WRITER,
            E_INVALIDARG,
            L"NULL writer name"
            );

    switch(nLevel) {
    case VSS_APP_SYSTEM:
    case VSS_APP_BACK_END:
    case VSS_APP_FRONT_END:
        break;
    default:
        ft.Throw
            (
            VSSDBG_WRITER,
            E_INVALIDARG,
            L"Invalid app level %d", nLevel
            );
    }

    m_cs.Init();  // Warning - may throw NT exceptions...
    m_bLockCreated = true;

    // initialize writer state
    m_writerstate.Initialize();

    // save writer class id
    m_WriterID = WriterID;

    // save writer name
    m_wszWriterName = _wcsdup(wszWriterName);
    if (m_wszWriterName == NULL)
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Cannot allocate writer name"
            );

    // save usage type
    m_usage = usage;

    // save source type
    m_source = source;

    // create guid for this instance
    ft.hr = ::CoCreateGuid(&m_InstanceID);
    ft.CheckForError(VSSDBG_WRITER, L"CoCreateGuid");
    ft.Trace
        (
        VSSDBG_WRITER,
        L"     InstanceId for Writer %s is" WSTR_GUID_FMT,
        m_wszWriterName,
        GUID_PRINTF_ARG(m_InstanceID)
        );

    // save app level
    m_nLevel = nLevel;

    // save timeout
    m_dwTimeoutFreeze = dwTimeoutFreeze;

    // setup thread mutex
    m_hmtxTimerThread = CreateMutex(NULL, FALSE, NULL);
    if (m_hmtxTimerThread == NULL)
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Failure to create mutex object due to error %d.",
            GetLastError()
            );

    // setup event used to control the timer thread
    SetupEvent(&m_hevtTimerThread);

    // Initialize the diagnose tool
    m_diag.Initialize(m_wszWriterName);

    // Mark the writer as initialized
    m_bInitialized = true;
    }

// start a sequence
// critical section (m_cs) must be locked upone entry to this routine
void CVssWriterImpl::BeginSequence
    (
    IN CVssID &SnapshotSetId
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::BeginSequence");

    AssertLocked();

    // terminate timer thread if it is still operating
    TerminateTimerThread();

    // setup current snapshot set id
    m_CurrentSnapshotSetId = SnapshotSetId;

    BS_ASSERT(m_bOnAbortPermitted == false);

    // initialize writer state for this snapshot set
    m_writerstate.InitializeCurrentState(SnapshotSetId);

    // indicate we are currently in a snapshot sequence.
    m_bSequenceInProgress = true;
    }





//  Reset the sequence-related data members
// critical section must be locked prior to entering this state
void CVssWriterImpl::ResetSequence(bool bCalledFromTimerThread)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::ResetSequence");

    AssertLocked();

    // save current state to stack of previous snapshot set states
    m_writerstate.PushCurrentState();

    // indicate we are no longer within a sequence
    m_bSequenceInProgress = false;

    // abort is no longer permitted
    m_bOnAbortPermitted = false;

    // reset volumes array
    m_nVolumesCount = 0;
    delete[] m_ppwszVolumesArray;
    m_ppwszVolumesArray = NULL;

    ::VssFreeString(m_pwszLocalVolumeNameList);

    m_CurrentSnapshotSetId = GUID_NULL;

    // if bCalledFromTimerThread is true, this means that the timer
    // thread is causing the sequence to be reset.  We are in the timer
    // thread already and it will terminate upon completion of this call
    // so we shouldn't try causing it to terminate again.
    if (!bCalledFromTimerThread)
        TerminateTimerThread();

    }

// indicate why the writer failed
HRESULT CVssWriterImpl::SetWriterFailure(HRESULT hr)
    {
    // validate failure is one that is allowed
    if (hr != VSS_E_WRITERERROR_TIMEOUT &&
        hr != VSS_E_WRITERERROR_RETRYABLE &&
        hr != VSS_E_WRITERERROR_NONRETRYABLE &&
        hr != VSS_E_WRITERERROR_OUTOFRESOURCES &&
        hr != VSS_E_WRITERERROR_INCONSISTENTSNAPSHOT)
        return E_INVALIDARG;

    // set failure
    m_writerstate.SetCurrentFailure(hr);
    return S_OK;
    }



// determine if path specified is on one of the volumes that is snapshot
bool CVssWriterImpl::IsPathAffected
    (
    IN  LPCWSTR wszPath
    ) const
    {
    // Test the status
    if (!m_bSequenceInProgress)
        return false;

    // check for empty volume count
    if (m_nVolumesCount == 0)
        return false;

    // Get the volume mount point
    WCHAR wszVolumeMP[MAX_PATH];
    BOOL bRes = ::GetVolumePathNameW(wszPath, wszVolumeMP, MAX_PATH);
    if (!bRes)
        return false;

    // Get the volume name
    WCHAR wszVolumeName[MAX_PATH];
    bRes = ::GetVolumeNameForVolumeMountPointW(wszVolumeMP, wszVolumeName, MAX_PATH);
    if (!bRes)
        return false;

    // Search to see if that volume is within snapshotted volumes
    for (int nIndex = 0; nIndex < m_nVolumesCount; nIndex++)
        {
        BS_ASSERT(m_ppwszVolumesArray[nIndex]);
        if (::wcscmp(wszVolumeName, m_ppwszVolumesArray[nIndex]) == 0)
            return true;
        }

    return false;
    }


// obtain IVssWriterCallback from IDispatch pointer
// caller is responsible for releasing interface that is returned
void CVssWriterImpl::GetCallback
    (
    IN IDispatch *pWriterCallback,
    OUT IVssWriterCallback **ppCallback,
    IN BOOL bAllowImpersonate
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::GetCallback");

    // check that pointer is supplied
    BS_ASSERT(pWriterCallback != NULL);

    // try QueryInterface for IVssWriterCallback interface
    ft.hr = pWriterCallback->SafeQI(IVssWriterCallback, ppCallback);
    if (FAILED(ft.hr))
    {
        // If this is a RPC error then the 
        // requestor might died in the meantime (bug 526472)
        if (ft.HrInFacility(FACILITY_RPC))
        {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);

            ft.LogError(VSS_ERROR_RPC_IVSSWRITERCALLBACK, VSSDBG_WRITER << ft.hr);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Error querying for IVssWriterCallback interface.  hr = 0x%08lx",
                ft.hr
                );
        }   
        else // this is a different failure
        {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

            ft.LogError(VSS_ERROR_QI_IVSSWRITERCALLBACK, VSSDBG_WRITER << ft.hr);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Error querying for IVssWriterCallback interface.  hr = 0x%08lx",
                ft.hr
                );
        }
    }

    if ( !bAllowImpersonate )
    {
        ft.hr = CoSetProxyBlanket
                    (
                    *ppCallback,
                    RPC_C_AUTHN_DEFAULT,
                    RPC_C_AUTHZ_DEFAULT,
                    NULL,
                    RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
                    RPC_C_IMP_LEVEL_IDENTIFY,
                    NULL,
                    EOAC_NONE
                    );

        // note E_NOINTERFACE means that the pWriterCallback is a in-proc callback
        // and there is no proxy
        if (FAILED(ft.hr) && ft.hr != E_NOINTERFACE)
            {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

            ft.LogError(VSS_ERROR_BLANKET_FAILED, VSSDBG_WRITER << ft.hr);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Call to CoSetProxyBlanket failed.  hr = 0x%08lx", ft.hr
                );
            }
        }
    }

// create basic writer metadata for OnIdentify method
CVssCreateWriterMetadata *CVssWriterImpl::CreateBasicWriterMetadata()
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::CreateBasicWriterMetadata");

    // create object supporting IVssCreateMetadata interface
    CVssCreateWriterMetadata *pMetadata = new CVssCreateWriterMetadata;
    if (pMetadata == NULL)
        {
        // indicate we failed due to an out of resources failure
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Cannot create CVssCreateWriterMetadata due to allocation failure."
            );
        }


    // call initialize to create IDENTIFICATION section
    ft.hr = pMetadata->Initialize
                    (
                    m_InstanceID,
                    m_WriterID,
                    m_wszWriterName,
                    m_usage,
                    m_source
                    );

    if (ft.HrFailed())
        {
        // indicate that we failed due to an out of resources failure
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
        delete pMetadata;
        ft.Throw
            (
            VSSDBG_WRITER,
            ft.hr,
            L"CVssCreateWriterMetadata::Initialize failed. hr = 0x%08lx",
            ft.hr
            );
        }


    // return object
    return pMetadata;
    }

static LPCWSTR x_wszElementRoot = L"root";
static LPCWSTR x_wszElementWriterComponents = L"WRITER_COMPONENTS";

// get writer components for OnPrepareBackup, OnBackupComplete, and OnPostRestore
// methods
void CVssWriterImpl::InternalGetWriterComponents
    (
    IN IVssWriterCallback *pCallback,
    OUT IVssWriterComponentsInt **ppWriter,
    IN bool bWriteable,
    IN bool bInRestore
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::InternalGetWriterComponents");

    BS_ASSERT(pCallback);
    BS_ASSERT(ppWriter);

    *ppWriter = NULL;

    // call GetContent callback method on the backup application
    CComBSTR bstrId(bInRestore ? m_WriterID : m_InstanceID);
    if (!bstrId)
        {
        // indicate we failed due to an out of resources failure
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Cannot allocate instance Id string"
            );
        }

    ft.hr = pCallback->GetBackupState
        (
        &m_bBootableSystemStateBackup,
        &m_bComponentsSelected,
        &m_backupType,
        &m_bPartialFileSupport,
        &m_lContext
        );

    if (ft.HrFailed())
        {
        // if GetBackupState failed assumed that it might work if the
        // backup is retried.
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
        ft.Throw
            (
            VSSDBG_WRITER,
            ft.hr,
            L"IVssWriterCallback::GetBackupState failed.  hr = 0x%08lx",
            ft.hr
            );
        }
	
	ft.hr = pCallback->GetRestoreState
	   (
	   &m_restoreType
	   );

    if (ft.HrFailed())
        {
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
        ft.Throw
            (
            VSSDBG_WRITER,
            ft.hr,
            L"IVssWriterCallback::GetRestoreState failed.  hr = 0x%08lx",
            ft.hr
            );
        }


    CComBSTR bstrWriterComponentsDoc;
    ft.hr = pCallback->GetContent(bstrId, &bstrWriterComponentsDoc);

    if (ft.HrFailed())
        {
        // if GetContent failed assume that the backup might work if
        // the backup was retried
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
        ft.Throw
            (
            VSSDBG_WRITER,
            ft.hr,
            L"Cannot get WRITER_COMPONENTS document.  hr = 0x%08lx",
            ft.hr
            );
        }

    if (ft.hr == S_FALSE)
        {
        // reset status code
        ft.hr = S_OK;
        *ppWriter = (IVssWriterComponentsInt *) new CVssNULLWriterComponents
                                (
                                m_InstanceID,
                                m_WriterID
                                );

        if (*ppWriter == NULL)
            {
            // indicate that the writer failed due to an out of resources condition
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.Throw (VSSDBG_WRITER, E_OUTOFMEMORY, L"Can't allocate CVssWriterComponents object");
            }

        (*ppWriter)->AddRef();
        }

    else
        {
        CXMLDocument doc;
        if (!doc.LoadFromXML(bstrWriterComponentsDoc) ||
            !doc.FindElement(x_wszElementRoot, true))
            {
            // if the XML document is not valid then assume that the backup
            // application is broken.  The backup should not be retried.

            
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);
            ft.LogError(VSS_ERROR_WRITER_COMPONENTS_CORRUPT, VSSDBG_WRITER);
            ft.Throw
                (
                VSSDBG_WRITER,
                VSS_E_CORRUPT_XML_DOCUMENT,
                L"Internally transferred WRITER_COMPONENTS document is invalid"
                );
            }

        doc.SetToplevel();

        *ppWriter = (IVssWriterComponentsInt *)
                        new CVssWriterComponents
                            (
                            doc.GetCurrentNode(),
                            doc.GetInterface(),
                            bWriteable,
                            false,
                            m_writerstate.IsInRestore()
                            );

        if (*ppWriter == NULL)
            {
            // indicate that the writer failed due to an out of resources condition
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.Throw (VSSDBG_WRITER, E_OUTOFMEMORY, L"Can't allocate CVssWriterComponents object");
            }

        (*ppWriter)->AddRef();
        ft.hr = (*ppWriter)->Initialize(true);
        if (ft.HrFailed())
            {
            // if Initialize failed, assume that the failure is due to an
            // out of resources conditition.
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            (*ppWriter)->Release();
            *ppWriter = NULL;
            ft.Throw
                (
                VSSDBG_WRITER,
                ft.hr,
                L"Failed to initialize WRITER_COMPONENTS document.  hr = 0x%08lx",
                ft.hr
                );
            }
        }
    }


// called when entering a state to verify whether this state can be
// validly entered and generate appropriate error if not.
// this routine always obtains the critical section.  If this routine
// is called then LeaveState must also be called in order to free the
// critical section.
bool CVssWriterImpl::EnterState
    (
    IN const CVssWriterImplStateMachine &vwsm,
    IN BSTR bstrSnapshotSetId
    ) throw(HRESULT)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::EnterState");

    CVssID id;

    // obtain lock just in case next call throws
    // no matter how this routine exits, the critical section must be locked
    Lock();

    // initialize id to snapshot set id
    id.Initialize(ft, (LPWSTR)bstrSnapshotSetId, E_OUTOFMEMORY);

    // Note:
    // 1. There is no check for fail-at-identify because if the writer failed at Identify,
    // then the writer won't get anymore events from the requestor object that sent the identify
    // 2. Other backup sequences should not be disturbed by a writer failing at identify
    // for another requestor

    if (!m_bSequenceInProgress)
        {
        if (!vwsm.m_bBeginningState)
            // not a beginning state.  Sequence must have been
            // interrupted.
            return false;
        else
            {
            // BUG 219757 - PrepareForSnapshot, etc. cannot be
            // called for the same Snapshot Set if PrepareForBackup failed
            // Also we assume here that each new sequence have an UNIQUE SSID.

            // This check is needed since the PrepareForBackup phase is optional
            // and can be skipped sometimes. Therefore we need to distinguish between
            // the case when PrepareForBackup was skipped and the case when PrepareForBackup
            // was called and failed.

            // Search for a previous sequence with the same Snapshot Set ID.
            // If found (this means that a PrepareForBackup was called),
            // then reject the call.
            if (m_writerstate.IsSnapshotSetIdValid(id))
                return false;

            // it is a beginning state, start the sequence
            BeginSequence(id);
            return true;
            }
        }
    else
        {
        if (vwsm.m_bSuccessiveState)
            {
            // it is a valid non-beginning state in the sequence
            if (id != m_CurrentSnapshotSetId)
                {
                // if snapshot set id doesn't match and this is not
                // a beginning state, then the event must be ignored.
                // We must have aborted the sequence it references.
                if (!vwsm.m_bBeginningState)
                    return false;
                }
            else
                {
                // make sure current state matches previous state
                // of state we are about to enter
                return m_writerstate.GetCurrentState() == vwsm.m_previousState;
                }
            }
        }

    // We are trying to start a new sequence.
    // This means that the previous sequence was not properly
    // terminated.  Abort the previous sequence and then
    // start a new one.
    ft.Trace(VSSDBG_WRITER,
        L"*** Warning ***: Writer %s with ID "WSTR_GUID_FMT
        L"attempts to reset the previous sequence with Snapshot Set ID "WSTR_GUID_FMT
        L". Current state = %d",
        m_wszWriterName, GUID_PRINTF_ARG(m_InstanceID), GUID_PRINTF_ARG(m_CurrentSnapshotSetId), (INT)m_writerstate.GetCurrentState());

    DoAbort(false);
    BeginSequence(id);
    return true;
    }

// do abort on failure of the sequence
// critical section must be locked prior to entering this state
void CVssWriterImpl::DoAbort
    (
    IN bool bCalledFromTimerThread,
    IN  BSTR    bstrSnapshotSetId
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::DoAbort");

    AssertLocked();
    // do nothing if in a sequence
    if (!m_bSequenceInProgress)
        return;

    BS_ASSERT(m_pWriter);

    // catch any exceptions so that we properly reset the
    // sequence
    try
        {
        // if the snapshot set doesn't match, don't allow an abort
	   if (bstrSnapshotSetId)	
	   	{
	   	CVssID id;
	   	id.Initialize(ft, bstrSnapshotSetId, E_OUTOFMEMORY);
	   	if (id != m_writerstate.GetCurrentSnapshotSet())
	   		return;
	   	}
	   
        // call writer's abort function (depending on the state)
        switch(m_writerstate.GetCurrentState())
            {
            default:
                // Unhandled state?
                BS_ASSERT(false);
                break;
                
            case VSS_WS_FAILED_AT_BACKUP_COMPLETE:
            case VSS_WS_FAILED_AT_PRE_RESTORE:
            case VSS_WS_FAILED_AT_POST_RESTORE:
                // Abort not permitted on these states
                BS_ASSERT(m_bOnAbortPermitted == false);
                break;
                
            case VSS_WS_STABLE:
                // This is possible since you may get an Abort
                // in (or after) PrepareForBackup (BUG # 301686)
                BS_ASSERT(m_bOnAbortPermitted == true);
                break;

            case VSS_WS_WAITING_FOR_POST_SNAPSHOT:
            case VSS_WS_FAILED_AT_POST_SNAPSHOT:
            case VSS_WS_WAITING_FOR_FREEZE:
            case VSS_WS_WAITING_FOR_THAW:
            case VSS_WS_WAITING_FOR_BACKUP_COMPLETE:
            case VSS_WS_FAILED_AT_THAW:
            case VSS_WS_FAILED_AT_PREPARE_BACKUP:
            case VSS_WS_FAILED_AT_PREPARE_SNAPSHOT:
            case VSS_WS_FAILED_AT_FREEZE:
                
                // Fixing bug 225936
                if (m_bOnAbortPermitted)
                    m_pWriter->OnAbort();
                else
                    ft.Trace(VSSDBG_WRITER, L"Abort skipped in state %d", m_writerstate.GetCurrentState());
                m_bOnAbortPermitted = false;
                break;
            }
        }
    VSS_STANDARD_CATCH(ft)

    if (ft.HrFailed())
        ft.Trace
            (
            VSSDBG_WRITER,
            L"OnAbort failed. hr = 0x%08lx",
            ft.hr
            );

    // set appropriate failure state
    switch(m_writerstate.GetCurrentState())
        {
        default:
            m_writerstate.SetCurrentState(VSS_WS_UNKNOWN);
            BS_ASSERT(false);
            break;

        case VSS_WS_FAILED_AT_PREPARE_BACKUP:
        case VSS_WS_FAILED_AT_PREPARE_SNAPSHOT:
        case VSS_WS_FAILED_AT_FREEZE:
        case VSS_WS_FAILED_AT_THAW:
        case VSS_WS_FAILED_AT_POST_SNAPSHOT:
        case VSS_WS_FAILED_AT_BACKUP_COMPLETE:
        case VSS_WS_FAILED_AT_PRE_RESTORE:
        case VSS_WS_FAILED_AT_POST_RESTORE:
            // don't change state if already in a failure state
            break;

        case VSS_WS_STABLE:
            // if current state is STABLE then it means
            // we were in PrepareBackup
            m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_PREPARE_BACKUP);
            break;

        case VSS_WS_WAITING_FOR_FREEZE:
            // if we were waiting for freeze then we failed
            // between PrepareSync and Freeze
            m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_PREPARE_SNAPSHOT);
            break;

        case VSS_WS_WAITING_FOR_THAW:
            // if we were waiting for thaw then we failed
            // between freeze and thaw
            m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_FREEZE);
            break;

        case VSS_WS_WAITING_FOR_POST_SNAPSHOT:
            // if we were waiting for completion then
            // we failed after thaw.
            m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_THAW);
            break;
            
        case VSS_WS_WAITING_FOR_BACKUP_COMPLETE:
            // if we were waiting for completion then
            // we failed after thaw.
            m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_POST_SNAPSHOT);
            break;

        }

    if (bCalledFromTimerThread && m_writerstate.GetCurrentFailure() == S_OK)
        m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_TIMEOUT);

    // reset sequence
    ResetSequence(bCalledFromTimerThread);
    }

// exit a state.  This routine must be called with the critical
// section acquired.  For a state, EnterState is called first, then work is
// done, then LeaveState is called.  This routine will set the state upon
// exit and possibly reset the snapshot sequence if we are at the end of the
// sequence or the sequence is aborted.
void CVssWriterImpl::LeaveState
    (
    IN const CVssWriterImplStateMachine &vwsm,  // current state
    IN bool bSucceeded                          // did operation succeed
    )
    {
    AssertLocked();

    m_writerstate.ExitOperation();

    // don't change state or call abort if we are not in a sequence
    if (m_bSequenceInProgress)
        {
        m_writerstate.SetCurrentState
            (bSucceeded ? vwsm.m_successfulExitState
                        : vwsm.m_failureExitState);

        // call abort on failure when we are not in the exit state
        if ((!bSucceeded || m_writerstate.GetCurrentFailure() == VSS_E_WRITER_NOT_RESPONDING) &&
            !vwsm.m_bResetSequenceOnLeave)
            DoAbort(false);
        else if (vwsm.m_bResetSequenceOnLeave)
            // if sequence ends at this state (THAW) then
            // reset variables
            ResetSequence(false);
        }

    Unlock();
    }



// arguments to timer function
class CVssTimerArgs
    {
private:
    CVssTimerArgs();

public:
    CVssTimerArgs(CVssWriterImpl *pWriter, VSS_ID id) :
        m_snapshotSetId(id),
        m_pWriter(pWriter)
        {
        }

    // snapshot set that we are monitoring
    VSS_ID m_snapshotSetId;

    // pointer to writer
    CVssWriterImpl *m_pWriter;
    };


// timer thread startup routine
DWORD CVssWriterImpl::StartTimerThread(void *pv)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::StartTimerThread");
    CVssTimerArgs *pArgs = (CVssTimerArgs *) pv;
    BS_ASSERT(pArgs);
    BS_ASSERT(pArgs->m_pWriter);

    bool bCoInitializeSucceeded = false;
    try
        {
        // coinitialize thread

        ft.hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
        if (ft.HrFailed())
            {
            pArgs->m_pWriter->m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.TranslateError
                (
                VSSDBG_WRITER,
                ft.hr,
                L"CoInitializeEx"
                );
            }

        bCoInitializeSucceeded = true;
        // call timer func
        pArgs->m_pWriter->TimerFunc(pArgs->m_snapshotSetId);
        }
    VSS_STANDARD_CATCH(ft)

    if (bCoInitializeSucceeded)
        CoUninitialize();

    // delete timer arguments
    delete pArgs;
    return 0;
    }



// function implementing timer functionality
void CVssWriterImpl::TimerFunc(VSS_ID snapshotSetId)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::TimerFunc");

    // wait on event to insure that only one timer is active at
    // any point in time
    if (WaitForSingleObject(m_hmtxTimerThread, INFINITE) == WAIT_FAILED)
        {
        DWORD dwErr = GetLastError();
        ft.Trace(VSSDBG_WRITER, L"WaitForSingleObject failed with error %d", dwErr);
        BS_ASSERT(FALSE && "WaitForSingleObject failed");
        }

    // reset timer event
    if (!ResetEvent(m_hevtTimerThread))
        {
        DWORD dwErr = GetLastError();
        ft.Trace(VSSDBG_WRITER, L"ResetEvent failed with error %d", dwErr);
        BS_ASSERT(FALSE && "ResetEvent failed");
        }

    Lock();

    CVssAutoDiagLogger logger(m_writerstate, VSS_IN_BKGND_FREEZE_THREAD, snapshotSetId);
    
    // make sure that we are still in a snapshot sequence
    if (!m_bSequenceInProgress || snapshotSetId != GetCurrentSnapshotSetId())
        {
        // not in sequence, exit function
        Unlock();
        // allow another timer thread to start
        ReleaseMutex(m_hmtxTimerThread);
        return;
        }

    // initial command is to abort the current sequence on timeout
    m_command = VSS_TC_ABORT_CURRENT_SEQUENCE;

    Unlock();
    DWORD dwTimeout = m_dwTimeoutFreeze;

    if (WaitForSingleObject(m_hevtTimerThread, dwTimeout) == WAIT_FAILED)
        {
        ft.Trace
            (
            VSSDBG_WRITER,
            L"Wait in timer thread failed due to reason %d.",
            GetLastError()
            );

        // allow another thread to start
        ReleaseMutex(m_hmtxTimerThread);
        return;
        }

    CVssWriterImplLock lock(this);
    if (m_command != VSS_TC_TERMINATE_THREAD)
        {
        BS_ASSERT(m_command == VSS_TC_ABORT_CURRENT_SEQUENCE);

        // cause current sequence to abort
        ft.Trace(VSSDBG_WRITER, L"Aborting due to timeout\n");
        DoAbort(true);
        }

    // allow another timer thread to start
    ReleaseMutex(m_hmtxTimerThread);
    }



/////////////////////////////////////////////////////////////////////////////
// IVssWriter implementation


STDMETHODIMP CVssWriterImpl::RequestWriterInfo
    (
    IN      BSTR bstrSnapshotSetId,
    IN      BOOL bWriterMetadata,
    IN      BOOL bWriterState,
    IN      IDispatch* pWriterCallback
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::RequestWriterInfo" );


    // created metadata, deleted on exit from routine
    CVssCreateWriterMetadata *pcwm = NULL;
    try
        {
        // validate that the flags make sense
        if (bWriterMetadata && bWriterState ||
            !bWriterMetadata && !bWriterState)
            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"Incorrect flags");

        // if we are requesting writer state then we must have a snapshot
        // set id
        if (bWriterState && bstrSnapshotSetId == NULL)
            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

        if (pWriterCallback == NULL)
            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

        if (!IsBackupOperator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"Backup Operator privileges are not set");

    _retry_OnIdentify:
    
        if (bWriterMetadata)
            {
            
            // obtain writer metadata
            
            // First, we prevent OnIdentify to be issued between Freeze and Thaw
            DWORD dwTimeout = m_dwTimeoutFreeze;
            if (WaitForSingleObject(m_hevtTimerThread, dwTimeout) == WAIT_FAILED)
                ft.Trace(VSSDBG_WRITER,L"Wait failed due to reason %d.",GetLastError());

            // MTA synchronization: The critical section will be left automatically 
            // at the end of scope.
            CVssWriterImplLock lock(this);

            // Still, do not allow OnIdentify to be called between Freeze and Thaw 
            // - There is an extremely small window where Freeze can be send after 
            // WaitForSingleObject test passed but before acquiring the lock
            VSWRITER_STATE state;
            m_writerstate.GetStateForSnapshot(GUID_NULL, state);

            // A writer cannot stay forever in this state... 
            // (the background timer thread will reset the current VSS_WS_WAITING_FOR_THAW state)
            if ((state.m_state == VSS_WS_WAITING_FOR_THAW) && 
                (state.m_idSnapshotSet != GUID_NULL))
                goto _retry_OnIdentify;

            CVssAutoDiagLogger logger(m_writerstate, VSS_IN_IDENTIFY);

            try
                {
                // get IVssWriterCallback interface
                CComPtr<IVssWriterCallback> pCallback;
                GetCallback(pWriterCallback, &pCallback);


                // create basic metadata using initialization parameters
                pcwm = CreateBasicWriterMetadata();

                // call writer's OnIdentify method to get more metadata
                BS_ASSERT(m_pWriter);
                bool bSucceeded;
                try
                    {
                    bSucceeded = m_pWriter->OnIdentify
                                    (
                                    (IVssCreateWriterMetadata *) pcwm
                                    );
                    }
                catch(...)
                    {
                    ft.Trace(VSSDBG_WRITER, L"Writer's OnIdentify method threw and exception.");
                    throw;
                    }

                if (!bSucceeded)
                    {
                    // indicate failure if writer fails OnIdentify
                    ft.Throw(VSSDBG_WRITER, S_FALSE, L"Writer's OnIdentify method returned false.");
                    }

                CComBSTR bstrXML;
                CComBSTR bstrInstanceId(m_InstanceID);
                CComBSTR bstrWriterId(m_WriterID);
                CComBSTR bstrWriterName(m_wszWriterName);
                if (!bstrInstanceId ||
                    !bstrWriterId ||
                    !bstrWriterName)
                    ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"Couldn't allocate memory for ids or name");

                // save WRITER_METADATA document as XML string
                ft.hr = pcwm->SaveAsXML(&bstrXML);
                if (FAILED(ft.hr))
                    ft.Throw
                        (
                        VSSDBG_WRITER,
                        E_OUTOFMEMORY,
                        L"Cannot save XML document as string. hr = 0x%08lx",
                        ft.hr
                        );

                // callback through ExposeWriterMetadata method
                try
                    {
                    ft.hr = pCallback->ExposeWriterMetadata
                            (
                            bstrInstanceId,
                            bstrWriterId,
                            bstrWriterName,
                            bstrXML
                            );
                    }
                catch(...)
                    {
                    ft.Trace(VSSDBG_WRITER, L"IVssWriterCallback::ExposeWriterMetadata threw an exception.");
                    throw;
                    }

                }
            catch(...)
                {
                }

            }
        else
            {
            // get writer state

            CComBSTR bstrInstanceId(m_InstanceID);
            if (!bstrInstanceId)
                ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"Couldn't allocate memory for ids or name");

            CVssID id;
            id.Initialize(ft, (LPCWSTR) bstrSnapshotSetId, E_INVALIDARG);

            CVssAutoDiagLogger logger(m_writerstate, VSS_IN_GETSTATE, id);

            // get IVssWriterCallback interface
            CComPtr<IVssWriterCallback> pCallback;
            GetCallback(pWriterCallback, &pCallback);

            VSWRITER_STATE state;
_retry:
            m_writerstate.GetStateForSnapshot(id, state);

            // Special handling for the case where the writer is in the middle of operation
            if (state.m_bInOperation)
                {
                if (state.m_state != VSS_WS_FAILED_AT_PREPARE_BACKUP &&
                    state.m_state != VSS_WS_FAILED_AT_PREPARE_SNAPSHOT &&
                    state.m_state != VSS_WS_FAILED_AT_FREEZE &&
                    state.m_state != VSS_WS_FAILED_AT_THAW)
                    {
                    state.m_hrWriterFailure = VSS_E_WRITER_NOT_RESPONDING;
                    switch(state.m_currentOperation)
                        {
                        default:
                            state.m_state = VSS_WS_UNKNOWN;
                            BS_ASSERT(false);
                            break;

                        case VSS_IN_PREPAREBACKUP:
                            state.m_state = VSS_WS_FAILED_AT_PREPARE_BACKUP;
                            break;

                        case VSS_IN_PREPARESNAPSHOT:
                            state.m_state = VSS_WS_FAILED_AT_PREPARE_SNAPSHOT;
                            break;

                        case VSS_IN_FREEZE:
                            state.m_state = VSS_WS_FAILED_AT_FREEZE;
                            break;

                        case VSS_IN_THAW:
                            state.m_state = VSS_WS_FAILED_AT_THAW;
                            break;

                        case VSS_IN_POSTSNAPSHOT:
                            state.m_state = VSS_WS_FAILED_AT_POST_SNAPSHOT;
                            break;

                        case VSS_IN_BACKUPCOMPLETE:
                            state.m_state = VSS_WS_FAILED_AT_BACKUP_COMPLETE;
                            break;

                        case VSS_IN_PRERESTORE:
                            state.m_state = VSS_WS_FAILED_AT_PRE_RESTORE;
                            break;

                        case VSS_IN_POSTRESTORE:
                            state.m_state = VSS_WS_FAILED_AT_POST_RESTORE;
                            break;

                        case VSS_IN_BACKUPSHUTDOWN:
                            state.m_state = VSS_WS_UNKNOWN;  
                            break;
                        }

                    if (!m_writerstate.SetNoResponseFailure(id, state))
                        goto _retry;
                    }
                }


            // call Backup's ExposeCurrentState callback method
            try
                {
                ft.hr = pCallback->ExposeCurrentState
                                (
                                bstrInstanceId,
                                state.m_state,
                                state.m_hrWriterFailure
                                );
                }
            catch(...)
                {
                ft.Trace(VSSDBG_WRITER, L"IVssWriterCallback::ExposeCurrentState threw an exception");
                throw;
                }

            }
        }
    VSS_STANDARD_CATCH(ft)

    delete pcwm;

    // Bug 255996
    return S_OK;
    }


// process PrepareForBackup event
STDMETHODIMP CVssWriterImpl::PrepareForBackup
    (
    IN      BSTR bstrSnapshotSetId,
    IN      IDispatch* pWriterCallback
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::PrepareForBackup" );

    bool EnteredStateCalled = false;
    try
        {
        // access check
        if (!IsBackupOperator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"Backup Operator privileges are not set");

        if (pWriterCallback == NULL || bstrSnapshotSetId == NULL)
            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");


        ft.Trace(VSSDBG_WRITER, L"\nReceived Event: PrepareForBackup\nParameters:\n");
        ft.Trace(VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_PREPAREBACKUP, bstrSnapshotSetId);

	    EnteredStateCalled  = true;	// At this point, EnterState will always be called
        // enter PrepareForBackup state
        if (!EnterState
                (
                s_rgWriterStates[s_ivwsmPrepareForBackup],
                bstrSnapshotSetId
                ))
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Couldn't properly begin sequence"
                );
            }


        AssertLocked();

        // indicate we are in an operation
        m_writerstate.SetInOperation(VSS_IN_PREPAREBACKUP);

        // get IVssWriterCallback interface
        CComPtr<IVssWriterCallback> pCallback;
        GetCallback(pWriterCallback, &pCallback);

        // get IVssWriterComponentsExt interface
        CComPtr<IVssWriterComponentsInt> pComponents;
        InternalGetWriterComponents(pCallback, &pComponents, true, false);

        BS_ASSERT(m_pWriter);

        // call writer's OnPrepareBackup method
        bool bResult;
        try
            {
            bResult = m_pWriter->OnPrepareBackup(pComponents);
            BS_ASSERT(m_bOnAbortPermitted == false);
            m_bOnAbortPermitted = true;
            }
        catch(...)
            {
            ft.Trace(VSSDBG_WRITER, L"Writer's OnPrepareBackup method threw an exception");
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

            throw;
            }

        if (!bResult)
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the preparebackup");


        // save changes to components if any
        if (pComponents)
            SaveChangedComponents(pCallback, false, pComponents);
        }
    VSS_STANDARD_CATCH(ft)

    // leave PrepareBackup state
    if (EnteredStateCalled)
	    LeaveState(s_rgWriterStates[s_ivwsmPrepareForBackup], ft.HrSucceeded());

    // Bug 255996
    return S_OK;
    }


// if the writer components were changed, save them back to the requestor's
// XML document.
void CVssWriterImpl::SaveChangedComponents
    (
    IN IVssWriterCallback *pCallback,
    IN bool bRestore,
    IN IVssWriterComponentsInt *pComponents
    )
    {
    CVssFunctionTracer ft(VSSDBG_XML, L"CVssWriterImpl::SaveChangedComponents");

    bool bChanged;

    // determine if components are changed
    ft.hr = pComponents->IsChanged(&bChanged);
    BS_ASSERT(ft.hr == S_OK);
    if (bChanged)
        {
        // get instance id
        CComBSTR bstrWriterInstanceId(bRestore ? m_WriterID : m_InstanceID);
        if (!bstrWriterInstanceId)
            ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"Couldn't allocate instance id string");

        // get WRITER_COMPONENTS XML document
        CComBSTR bstrWriterComponentsDocument;
        ft.hr = pComponents->SaveAsXML(&bstrWriterComponentsDocument);
        if (ft.HrFailed())
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_OUTOFMEMORY,
                L"Saving WRITER_COMPONENTS document as XML failed.  hr = 0x%08lx",
                ft.hr
                );
            }

        // callback to set component in BACKUP_COMPONENTS document
        try
            {
            ft.hr = pCallback->SetContent(bstrWriterInstanceId, bstrWriterComponentsDocument);
            }
        catch(...)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Trace(VSSDBG_WRITER, L"IVssWriterCallback::SetContent threw an exception.");
            throw;
            }

        if (ft.HrFailed() && m_writerstate.GetCurrentFailure() == S_OK)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                ft.hr,
                L"IVssWriterCallback::SetContent failed.  hr = 0x%08lx",
                ft.hr
                );
            }
        }
    }


// process PrepareForSnapshot event
STDMETHODIMP CVssWriterImpl::PrepareForSnapshot
    (
    IN  BSTR    bstrSnapshotSetId,          // snapshot set id
    IN  BSTR    bstrVolumeNamesList         // list of volume names separated by ';'
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::PrepareForSnapshot" );

    bool EnterStateCalled = false;
    try
        {
        // should only be called by coordinator
        // check for admin privileges
        if (!IsAdministrator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"ADMIN privileges are not set");

        if (bstrSnapshotSetId == NULL || bstrVolumeNamesList == NULL)
        	{
        	BS_ASSERT(false);
        	ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"A required in parameter is NULL.");        		
              }
        
        ft.Trace(VSSDBG_WRITER, L"\nReceived Event: PrepareForSnapshot\nParameters:\n");
        ft.Trace(VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);
        ft.Trace(VSSDBG_WRITER, L"\tVolumeNamesList = %s\n", (LPWSTR)bstrVolumeNamesList);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_PREPARESNAPSHOT, bstrSnapshotSetId);

        // enter PrepareForSnapshot state
        EnterStateCalled = true;
        if (!EnterState
                (
                s_rgWriterStates[s_ivwsmPrepareForSnapshot],
                bstrSnapshotSetId
                ))
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"improper state transition"
                );
            }

        AssertLocked();

        // indicate that we are in an operation
        m_writerstate.SetInOperation(VSS_IN_PREPARESNAPSHOT);

        // Get the array of volume names
        BS_ASSERT(m_pwszLocalVolumeNameList == NULL);
        ::VssSafeDuplicateStr(ft, m_pwszLocalVolumeNameList, (LPWSTR)bstrVolumeNamesList);

        // Get the number of volumes
        BS_ASSERT(m_nVolumesCount == 0);
        m_nVolumesCount = 0; // For safety
        LPWSTR pwszVolumesToBeParsed = m_pwszLocalVolumeNameList;

        // parse volume name string
        while(true)
            {
            // get pointer to next volume
            WCHAR* pwszNextVolume = ::wcstok(pwszVolumesToBeParsed, VSS_VOLUME_DELIMITERS);
            pwszVolumesToBeParsed = NULL;

            if (pwszNextVolume == NULL)
                // no more volumes
                break;

            // skip if volume name is empty
            if (pwszNextVolume[0] == L'\0')
                continue;

            // count of volumes
            m_nVolumesCount++;
            }

        // make sure there is at least one volume
        if (m_nVolumesCount == 0)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.LogError(VSS_ERROR_EMPTY_SNAPSHOT_SET, VSSDBG_WRITER);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"No volumes in the snapshot set"
                );
            }

        // Allocate the array of pointers to volume names
        BS_ASSERT(m_nVolumesCount > 0);
        BS_ASSERT(m_ppwszVolumesArray == NULL);
        m_ppwszVolumesArray = new LPWSTR[m_nVolumesCount];
        if (m_ppwszVolumesArray == NULL)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.Throw( VSSDBG_WRITER, E_OUTOFMEMORY, L"Memory allocation error");
            }

        //
        // Copy the volume names into the array.
        //

        // re-copy the whole volume list
        ::wcscpy(m_pwszLocalVolumeNameList, (LPWSTR)bstrVolumeNamesList);

        // Fill the array by re-parsing the volume list.
        INT nVolumesIndex = 0;
        pwszVolumesToBeParsed = m_pwszLocalVolumeNameList;
        while(true)
            {
            WCHAR* pwszNextVolume = ::wcstok(pwszVolumesToBeParsed, VSS_VOLUME_DELIMITERS);
            pwszVolumesToBeParsed = NULL;

            if (pwszNextVolume == NULL)
                break;

            if (pwszNextVolume[0] == L'\0')
                continue;

            BS_ASSERT(nVolumesIndex < m_nVolumesCount);
            m_ppwszVolumesArray[nVolumesIndex] = pwszNextVolume;

            nVolumesIndex++;
            }

        BS_ASSERT(nVolumesIndex == m_nVolumesCount);

        // Call the writer's OnPrepareSnapshot method
        BS_ASSERT(m_pWriter);

        bool bResult;
        try
            {
            bResult = m_pWriter->OnPrepareSnapshot();
            m_bOnAbortPermitted = true;
            }
        catch(...)
            {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);
            ft.Trace(VSSDBG_WRITER, L"Writer's OnPrepareSnapshot method threw an execption");
            throw;
            }

        if (!bResult)
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the prepare snapshot");
        }
    VSS_STANDARD_CATCH(ft)

    // leave PrepareSnapshot state
    if (EnterStateCalled)
	    LeaveState(s_rgWriterStates[s_ivwsmPrepareForSnapshot], ft.HrSucceeded());

    // Bug 255996
    return S_OK;
    }


// process freeze event
STDMETHODIMP CVssWriterImpl::Freeze
    (
    IN  BSTR    bstrSnapshotSetId,
    IN  INT     nLevel
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::Freeze" );

    bool EnterStateCalled = false;
    try
        {
        // should only be called by the coordinator, access check for admin privileges
        if (!IsAdministrator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"ADMIN privileges are not set");
        
    	if (bstrSnapshotSetId == NULL)
		{
		BS_ASSERT(false);
		ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"A required parameter is NULL.");
		}
	
        ft.Trace( VSSDBG_WRITER, L"\nReceived Event: Freeze\nParameters:\n");
        ft.Trace( VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);
        ft.Trace( VSSDBG_WRITER, L"\tLevel = %d\n", nLevel);
	
        // Ignore other Levels
        if (m_nLevel != nLevel)
            return S_OK;

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_FREEZE, bstrSnapshotSetId);

        // enter freeze state
        EnterStateCalled = true;
        if (!EnterState
                (
                s_rgWriterStates[s_ivwsmFreeze],
                bstrSnapshotSetId
                ))
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Improper entry into state"
                );
            }

        AssertLocked();

        // indicate that we are in an operation
        m_writerstate.SetInOperation(VSS_IN_FREEZE);

        // Call writer's OnFreeze
        BS_ASSERT(m_pWriter);

        bool bResult;
        try
            {
            bResult = m_pWriter->OnFreeze();
            BS_ASSERT(m_bOnAbortPermitted == true);
            }
        catch(...)
            {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);
            ft.Trace(VSSDBG_WRITER, L"Writer's OnFreeze Method threw and exception");
            throw;
            }

        if (!bResult)
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the freeze");


        // setup arguments to timer thread
        CVssTimerArgs *pArgs = new CVssTimerArgs(this, m_CurrentSnapshotSetId);
        if (pArgs == NULL)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_OUTOFMEMORY,
                L"Cannot create timer args due to allocation failure"
                );
            }

        DWORD tid;

        // create timer thread
        m_hThreadTimerThread =
            CreateThread
                (
                NULL,
                VSS_STACK_SIZE,
                &CVssWriterImpl::StartTimerThread,
                pArgs,
                0,
                &tid
                );

        if (m_hThreadTimerThread == NULL)
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_OUTOFRESOURCES);
            delete pArgs;
            ft.Throw
                (
                VSSDBG_WRITER,
                E_OUTOFMEMORY,
                L"Failure to create thread due to error %d.",
                GetLastError()
                );
           }
        }
    VSS_STANDARD_CATCH(ft)

    // leave OnFreeze state
    if (EnterStateCalled)
	    LeaveState( s_rgWriterStates[s_ivwsmFreeze], ft.HrSucceeded());

    // Bug 255996
    return S_OK;
    }


// handle IVssWriter::Thaw event
STDMETHODIMP CVssWriterImpl::Thaw
    (
    IN  BSTR    bstrSnapshotSetId
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::Thaw" );

    bool EnterStateCalled = false;
    try
        {
        // should only be called by coordinator.  Access check for admin
        if (!IsAdministrator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"ADMIN privileges are not set");

        if (bstrSnapshotSetId == NULL)
        	{
        	BS_ASSERT(false);
        	ft.Throw(VSSDBG_COORD, E_INVALIDARG, L"A required parameter is NULL");
        	}

        ft.Trace( VSSDBG_WRITER, L"\nReceived Event: Thaw\nParameters:\n");
        ft.Trace( VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_THAW, bstrSnapshotSetId);

        // enter Thaw state
        EnterStateCalled = true;	// this line of code must be immediately before the call of EnterState
        if (!EnterState
                (
                s_rgWriterStates[s_ivwsmThaw],
                bstrSnapshotSetId
                ))
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Improper entry into state"
                );
            }


        // indicate that we are in an operation
        m_writerstate.SetInOperation(VSS_IN_THAW);

        AssertLocked();

        // terminate timer thread as we are about to thaw the operation
        // Warning: BUG 488348	VSS: Assert when testing m_bSequenceInProgress	Bug Understood	Server RC1	 

        TerminateTimerThread();

        // We should "live" in a sequence since Thaw is not the first phase of the sequence.
        if (!m_bSequenceInProgress)
        {
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the thaw");
        }

        // Call writer's OnThaw
        BS_ASSERT(m_pWriter);

        bool bResult;
        try
            {
            bResult = m_pWriter->OnThaw();
            }
        catch(...)
            {
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

            ft.Trace(VSSDBG_WRITER, L"Writer's OnThaw method threw an exception");
            throw;
            }

        // throw veto if writer vetoes the event
        if (!bResult)
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the thaw");
        }
    VSS_STANDARD_CATCH(ft)

    // leave OnThaw state
    if (EnterStateCalled)
	    LeaveState(s_rgWriterStates[s_ivwsmThaw], ft.HrSucceeded());
    
    // Bug 255996
    return S_OK;
    }

// process PostSnapshot event
STDMETHODIMP CVssWriterImpl::PostSnapshot
    (
    IN      BSTR bstrSnapshotSetId,
    IN      IDispatch* pWriterCallback,
    IN      BSTR SnapshotDevicesList    
    )
    {
    UNREFERENCED_PARAMETER(SnapshotDevicesList);

    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::PostSnapshot" );


    bool  EnterStateCalled = false;
    try
        {
        // access check
        if (!IsAdministrator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"Backup Operator privileges are not set");
        
        if (pWriterCallback == NULL || bstrSnapshotSetId == NULL)
            {
            BS_ASSERT(false);
            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");
            }
        
        ft.Trace(VSSDBG_WRITER, L"\nReceived Event: PostSnapshot\nParameters:\n");
        ft.Trace(VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_POSTSNAPSHOT, bstrSnapshotSetId);

        // enter PostSnapshot state
        EnterStateCalled = true;
        if (!EnterState
                (
                s_rgWriterStates[s_ivwsmPostSnapshot],
                bstrSnapshotSetId
                ))
            {
            m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);
            ft.Throw
                (
                VSSDBG_WRITER,
                E_UNEXPECTED,
                L"Couldn't properly begin sequence"
                );
            }


        AssertLocked();

        // indicate we are in an operation
        m_writerstate.SetInOperation(VSS_IN_POSTSNAPSHOT);

        // get IVssWriterCallback interface
        CComPtr<IVssWriterCallback> pCallback;

        //
        //  This is a special case where the writer calls VSS instead of
        //  the requestor.  In this case we have to allow impersonation.
        //
        GetCallback(pWriterCallback, &pCallback, TRUE);

        // get IVssWriterComponentsExt interface
        CComPtr<IVssWriterComponentsInt> pComponents;
        InternalGetWriterComponents(pCallback, &pComponents, true, false);

        BS_ASSERT(m_pWriter);

        // call writer's OnPostSnapshot method
        bool bResult;
        try
            {
            bResult = m_pWriter->OnPostSnapshot(pComponents);
            }
        catch(...)
            {
            ft.Trace(VSSDBG_WRITER, L"Writer's OnPostSnapshot method threw an exception");
            if (m_writerstate.GetCurrentFailure() == S_OK)
                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

            throw;
            }

        if (!bResult)
            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the post Snapshot");

        // save changes to components if any
        if (pComponents)
            SaveChangedComponents(pCallback, false, pComponents);
        }
    VSS_STANDARD_CATCH(ft)

    // leave PostSnapshot state
    if (EnterStateCalled)
	    LeaveState(s_rgWriterStates[s_ivwsmPostSnapshot], ft.HrSucceeded());

    // Bug 255996
    return S_OK;
    }



// process backup complete event
STDMETHODIMP CVssWriterImpl::BackupComplete
    (
    IN      BSTR bstrSnapshotSetId,
    IN      IDispatch* pWriterCallback
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::BackupComplete" );

            // access check
    try
        {
	 if (!IsBackupOperator())
              ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED,L"Backup Operator privileges are not set");
    	
	    // MTA synchronization: The critical section will be left automatically at the end of scope.
	    CVssWriterImplLock lock(this);
	    CVssID id;
	    bool bIdInitialized = false;


	    try
	        {        
	        if (pWriterCallback == NULL || bstrSnapshotSetId == NULL)
	            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

	        ft.Trace(VSSDBG_WRITER, L"\nReceived Event: OnBackupComplete\nParameters:\n");
	        ft.Trace(VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

            CVssAutoDiagLogger logger(m_writerstate, VSS_IN_BACKUPCOMPLETE, bstrSnapshotSetId);

	        m_writerstate.SetInOperation(VSS_IN_BACKUPCOMPLETE);

	        BS_ASSERT(!m_bSequenceInProgress);
	        BS_ASSERT(m_CurrentSnapshotSetId == GUID_NULL);

	        id.Initialize(ft, (LPCWSTR) bstrSnapshotSetId, E_INVALIDARG);
	        bIdInitialized = true;

	        m_writerstate.FinishBackupComplete(id);

	        // get IVssWriterCallback interface
	        CComPtr<IVssWriterCallback> pCallback;
	        GetCallback(pWriterCallback, &pCallback);


	        // get IVssWriterComponentsInt object
	        CComPtr<IVssWriterComponentsInt> pComponents;
	        InternalGetWriterComponents(pCallback, &pComponents, false, false);

	        // call writer's OnBackupComplete method
	        BS_ASSERT(m_pWriter);
	        try
	            {
	            if (!m_pWriter->OnBackupComplete(pComponents))
	                ft.hr = S_FALSE;
	            }
	        catch(...)
	            {
	            if (m_writerstate.GetCurrentFailure() == S_OK)
	                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

	            ft.Trace(VSSDBG_WRITER, L"Writer's OnBackupComplete method threw an exception.");
	            throw;
	            }

	        if (ft.hr == S_FALSE)
	            ft.Throw(VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the backup complete");
	        }
	    VSS_STANDARD_CATCH(ft)

	    // indicate that sequence is complete
	    if (m_writerstate.GetCurrentState() == VSS_WS_WAITING_FOR_BACKUP_COMPLETE)
	        m_writerstate.SetCurrentState(VSS_WS_STABLE);

	    m_writerstate.SetBackupCompleteStatus(id, ft.hr);

	    m_writerstate.ExitOperation();
            }
    VSS_STANDARD_CATCH(ft) 

    // Bug 255996
    return S_OK;
    }

STDMETHODIMP CVssWriterImpl::BackupShutdown
    (
    IN BSTR bstrSnapshotSetId
    )
   {
   UNREFERENCED_PARAMETER(bstrSnapshotSetId);
   
   CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::BackupShutdown");

    // access check
    try
        {
	 if (!IsAdministrator())
              ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED,L"Can only be called from the coordinator");
    	
	    // MTA synchronization: The critical section will be left automatically at the end of scope.
	    CVssWriterImplLock lock(this);
	    CVssID id;


	    try
	        {        
	        if (bstrSnapshotSetId == NULL)
	            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

	        ft.Trace(VSSDBG_WRITER, L"\nReceived Event: OnBackupShutdown\nParameters:\n");
	        ft.Trace(VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

            CVssAutoDiagLogger logger(m_writerstate, VSS_IN_BACKUPSHUTDOWN, bstrSnapshotSetId);
            
	        m_writerstate.SetInOperation(VSS_IN_BACKUPSHUTDOWN);

	        id.Initialize(ft, (LPCWSTR) bstrSnapshotSetId, E_INVALIDARG);

	        // call writer's OnBackupComplete method
	        BS_ASSERT(m_pWriter);
	        try
	            {
	            if (!m_pWriter->OnBackupShutdown(id))
	                ft.hr = S_FALSE;
	            }
	        catch(...)
	            {
	            if (m_writerstate.GetCurrentFailure() == S_OK)
	                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

	            ft.Trace(VSSDBG_WRITER, L"Writer's OnBackupShutdown  method threw an exception.");
	            throw;
	            }

	        if (ft.hr == S_FALSE)
	            ft.Throw(VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the backup shutdown");
	        }
	    VSS_STANDARD_CATCH(ft)


	    m_writerstate.ExitOperation();
            }
    VSS_STANDARD_CATCH(ft) 

    // Bug 255996
    return S_OK;
   }

// handle IVssWriter::Abort event
STDMETHODIMP CVssWriterImpl::Abort
    (
    IN  BSTR    bstrSnapshotSetId
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::Abort" );

    try
    {
        if (!IsBackupOperator())
            ft.Throw(VSSDBG_WRITER, E_ACCESSDENIED, L"Backup privileges are not set");
    
        ft.Trace( VSSDBG_WRITER, L"\nReceived Event: Abort\nParameters:\n");
        ft.Trace( VSSDBG_WRITER, L"\tSnapshotSetID = %s\n", (LPWSTR)bstrSnapshotSetId);

        Lock();

        CVssID id;
        id.Initialize(ft, bstrSnapshotSetId, S_OK); // Ignore errors here.

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_ABORT, id);

        // call do abort function
        DoAbort(false, bstrSnapshotSetId);


        Unlock();
    }
    VSS_STANDARD_CATCH(ft)

    return ft.hr;
    }

// process prerestore event
STDMETHODIMP CVssWriterImpl::PreRestore
    (
    IN      IDispatch* pWriterCallback
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::PreRestore" );
    
    ft.Trace(VSSDBG_WRITER, L"\nReceived Event: PreRestore\n");

    try
    	{
	    // access check
	    if (!IsRestoreOperator())
	    	ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"Restore Operator privileges are not set");

	    // MTA synchronization: The critical section will be left automatically at the end of scope.
	    CVssWriterImplLock lock(this);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_PRERESTORE);
        
	    m_writerstate.SetInOperation(VSS_IN_PRERESTORE);
	    m_writerstate.SetCurrentFailure(S_OK);

	    try
	        {
	        if (pWriterCallback == NULL)
	            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

	        // get writer callback interface
	        CComPtr<IVssWriterCallback> pCallback;
	        GetCallback(pWriterCallback, &pCallback);
	        CComPtr<IVssWriterComponentsInt> pComponents;

	        // get IVssWriterComponentsInt object
	        InternalGetWriterComponents(pCallback, &pComponents, true, true);

	        // call writer's OnPreRestore method
	        BS_ASSERT(m_pWriter);
	        try
	            {
	            if (!m_pWriter->OnPreRestore(pComponents))
	                ft.hr = S_FALSE;
	            }
	        catch(...)
	            {
	            if (m_writerstate.GetCurrentFailure() == S_OK)
	                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

	            ft.Trace(VSSDBG_WRITER, L"Writer's OnPreRestore method threw an exception");
	            throw;
	            }

	        if (ft.hr == S_FALSE)
	            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the prerestore");

	        if (pComponents)
	            SaveChangedComponents(pCallback, true, pComponents);
	        }
	    VSS_STANDARD_CATCH(ft)

	    if (FAILED(ft.hr))
	        m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_PRE_RESTORE);
	    else
	        m_writerstate.SetCurrentState(VSS_WS_STABLE);


	    m_writerstate.ExitOperation();
    	}
    VSS_STANDARD_CATCH(ft)
    	
    // Bug 255996
    return S_OK;
    }



// process post restore event
STDMETHODIMP CVssWriterImpl::PostRestore
    (
    IN      IDispatch* pWriterCallback
    )
    {
    CVssFunctionTracer ft( VSSDBG_WRITER, L"CVssWriterImpl::PostRestore" );

    try
    	{
	    // access check
	    if (!IsRestoreOperator())
	          ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"Restore Operator privileges are not set");

	    ft.Trace(VSSDBG_WRITER, L"\nReceived Event: PostRestore\n");

	    // MTA synchronization: The critical section will be left automatically at the end of scope.
	    CVssWriterImplLock lock(this);

        CVssAutoDiagLogger logger(m_writerstate, VSS_IN_POSTRESTORE);

	    m_writerstate.SetInOperation(VSS_IN_POSTRESTORE);
	    m_writerstate.SetCurrentFailure(S_OK);

	    try
	        {        
	        if (pWriterCallback == NULL)
	            ft.Throw(VSSDBG_WRITER, E_INVALIDARG, L"NULL required input parameter.");

	        // get writer callback interface
	        CComPtr<IVssWriterCallback> pCallback;
	        GetCallback(pWriterCallback, &pCallback);
	        CComPtr<IVssWriterComponentsInt> pComponents;

	        // get IVssWriterComponentsInt object
	        InternalGetWriterComponents(pCallback, &pComponents, true, true);

	        // call writer's OnPostRestore method
	        BS_ASSERT(m_pWriter);
	        try
	            {
	            if (!m_pWriter->OnPostRestore(pComponents))
	                ft.hr = S_FALSE;
	            }
	        catch(...)
	            {
	            if (m_writerstate.GetCurrentFailure() == S_OK)
	                m_writerstate.SetCurrentFailure(VSS_E_WRITERERROR_NONRETRYABLE);

	            ft.Trace(VSSDBG_WRITER, L"Writer's OnPostRestore method threw an exception");
	            throw;
	            }

	        if (ft.hr == S_FALSE)
	            ft.Throw( VSSDBG_WRITER, E_UNEXPECTED, L"Writer rejected the postrestore");

	        if (pComponents)
	            SaveChangedComponents(pCallback, true, pComponents);
	        }
	    VSS_STANDARD_CATCH(ft)

	    if (FAILED(ft.hr))
	        m_writerstate.SetCurrentState(VSS_WS_FAILED_AT_POST_RESTORE);
	    else
	        m_writerstate.SetCurrentState(VSS_WS_STABLE);


	    m_writerstate.ExitOperation();
	    }
    VSS_STANDARD_CATCH(ft)
    	
    // Bug 255996
    return S_OK;
    }


// table of names of events that we are subscribing to
// NOTE: this table is based on definition of VSS_EVENT_MASK.  Each
// offset corresponds to a bit on that mask
const WCHAR *g_rgwszSubscriptions[] =
    {
    g_wszPrepareForBackupMethodName,        // VSS_EVENT_PREPAREBackup
    g_wszPrepareForSnapshotMethodName,      // VSS_EVENT_PREPARESnapshot
    g_wszFreezeMethodName,                  // VSS_EVENT_FREEZE
    g_wszThawMethodName,                    // VSS_EVENT_THAW
    g_wszPostSnapshotMethodName,            // VSS_EVENT_POST_SNAPSHOT
    g_wszAbortMethodName,                   // VSS_EVENT_ABORT
    g_wszBackupCompleteMethodName,          // VSS_EVENT_BACKUPCOMPLETE
    g_wszRequestInfoMethodName,             // VSS_EVENT_REQUESTINFO
    g_wszPreRestoreMethodName,              // VSS_EVENT_RESTORE
    g_wszPostRestoreMethodName,              // VSS_EVENT_POST_RESTORE
    g_wszBackupShutdownName			     // VSS_EVENT_BACKUPSHUTDOWN 
    };


/////////////////////////////////////////////////////////////////////////////
//  Subscription-related members


// create subscriptions
// This function returns S_FALSE when the writer is inactive (setup or safe mode)
void CVssWriterImpl::Subscribe()
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::Subscribe");

    // validate that the writer is initialized
    if (m_bInSetup || m_bInSafeMode)
        ft.Throw
            (
            VSSDBG_WRITER,
            S_FALSE,
            L"Writer is inactive during setup or safe mode"
            );

    // validate that the writer is initialized
    if (!m_bInitialized)
        ft.Throw
            (
            VSSDBG_WRITER,
            VSS_E_BAD_STATE,
            L"You must initialize the writer before other operations"
            );

    // currently we subscribe to all events
    m_dwEventMask = VSS_EVENT_ALL;

    if (m_bstrSubscriptionName.Length() > 0)
        ft.Throw
            (
            VSSDBG_XML,
            VSS_E_WRITER_ALREADY_SUBSCRIBED,
            L"The writer has already called the Subscribe function."
            );

    // create event system
    CComPtr<IEventSystem> pSystem;
    ft.CoCreateInstanceWithLog(
            VSSDBG_WRITER,
            CLSID_CEventSystem,
            L"CEventSystem",
            CLSCTX_SERVER,
            IID_IEventSystem,
            (IUnknown**)&(pSystem));
    ft.CheckForError(VSSDBG_WRITER, L"CoCreateInstance");
    CComBSTR bstrClassId = CLSID_VssEvent;
    CComBSTR bstrIID = IID_IVssWriter;
    CComBSTR bstrProgId = PROGID_EventSubscription;

    // see if event class already exists
    CComBSTR bstrQuery = "EventClassID == ";
    if (!bstrQuery)
        ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"Cannot allocate BSTR.");

    bstrQuery.Append(bstrClassId);
    if (!bstrQuery)
        ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"Cannot allocate BSTR.");

    int location;
    CComPtr<IEventObjectCollection> pCollection;
    ft.hr = pSystem->Query
                (
                PROGID_EventClassCollection,
                bstrQuery,
                &location,
                (IUnknown **) &pCollection
                );

    ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Query");
    long cEvents;
    ft.hr = pCollection->get_Count(&cEvents);
    ft.CheckForError(VSSDBG_WRITER, L"IEventObjectCollection::get_Count");
    if (cEvents == 0)
        {
        // event class does not exist, create it.  Note that there is a
        // potential race condition here if two writers try creating the event
        // class at the same time.  We create the event class during installation
        // so that this should rarely happen
        CComPtr<IEventClass> pEvent;

        CComBSTR bstrEventClassName = L"VssEvent";
        WCHAR buf[MAX_PATH*2];

        // event class typelib
        UINT cwc = ExpandEnvironmentStrings
                        (
                        L"%systemroot%\\system32\\eventcls.dll",
                        buf,
                        sizeof(buf)/sizeof(WCHAR)
                        );

        if (cwc == 0)
            {
            ft.hr = HRESULT_FROM_WIN32(GetLastError());
            ft.CheckForError(VSSDBG_WRITER, L"ExpandEnvironmentStrings");
            }

        CComBSTR bstrTypelib = buf;

        // create event class
        ft.CoCreateInstanceWithLog(
                VSSDBG_WRITER,
                CLSID_CEventClass,
                L"CEventClass",
                CLSCTX_SERVER,
                IID_IEventClass,
                (IUnknown**)&(pEvent));

        ft.CheckForError(VSSDBG_WRITER, L"CoCreatInstance");

        // setup class id
        ft.hr = pEvent->put_EventClassID(bstrClassId);
        ft.CheckForError(VSSDBG_WRITER, L"IEventClass::put_EventClassID");

        // set up class name
        ft.hr = pEvent->put_EventClassName(bstrEventClassName);
        ft.CheckForError(VSSDBG_WRITER, L"IEventClass::put_EventClassName");

        // set up typelib
        ft.hr = pEvent->put_TypeLib(bstrTypelib);
        ft.CheckForError(VSSDBG_WRITER, L"IEventClass::put_TypeLib");

        // store event class
        ft.hr = pSystem->Store(PROGID_EventClass, pEvent);
        ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Store");
        }

    // create subscription id
    VSS_ID SubscriptionId;
    ft.hr = ::CoCreateGuid(&SubscriptionId);
    ft.CheckForError(VSSDBG_WRITER, L"CoCreateGuid");
    m_bstrSubscriptionName = SubscriptionId;

    // get IUnknown for subscribers class
    IUnknown *pUnkSubscriber = GetUnknown();
    UINT iwsz, mask;

    try
        {
        // loop through subscriptions
        for(mask = 1, iwsz = 0; mask < VSS_EVENT_ALL; mask = mask << 1, iwsz++)
            {
            if (m_dwEventMask & mask && g_rgwszSubscriptions[iwsz] != NULL)
                {
                // create IEventSubscription object
                CComPtr<IEventSubscription> pSubscription;
                ft.CoCreateInstanceWithLog(
                        VSSDBG_WRITER,
                        CLSID_CEventSubscription,
                        L"CEventSubscription",
                        CLSCTX_SERVER,
                        IID_IEventSubscription,
                        (IUnknown**)&(pSubscription));
                ft.CheckForError(VSSDBG_WRITER, L"CoCreateInstance");

                // set subscription name
                ft.hr = pSubscription->put_SubscriptionName(m_bstrSubscriptionName);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_SubscriptionName");

                // set event class id
                ft.hr = pSubscription->put_EventClassID(bstrClassId);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_EventClassID");

                // set interface id
                ft.hr = pSubscription->put_InterfaceID(bstrIID);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_InterfaceID");

                // set subcriber interface
                ft.hr = pSubscription->put_SubscriberInterface(pUnkSubscriber);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_SubscriberInterface");

                // make subscription per user since this is not necessarily in local system
                ft.hr = pSubscription->put_PerUser(TRUE);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_PerUser");

                // set method name for subscrpition
                ft.hr = pSubscription->put_MethodName(CComBSTR(g_rgwszSubscriptions[iwsz]));
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::put_MethodName");

                // setup InstanceId and WriterId subscription properties
                VARIANT varWriterId;
                VARIANT varInstanceId;

                CComBSTR bstrWriterId = m_WriterID;
                CComBSTR bstrInstanceId = m_InstanceID;

                varWriterId.vt = VT_BSTR;
                varWriterId.bstrVal = bstrWriterId;
                varInstanceId.vt = VT_BSTR;
                varInstanceId.bstrVal = bstrInstanceId;

                ft.hr = pSubscription->PutSubscriberProperty(L"WriterId", &varWriterId);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::PutSubscriberProperty");

                ft.hr = pSubscription->PutSubscriberProperty(L"WriterInstanceId", &varInstanceId);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::PutSubscriberProperty");

                // store subscription
                ft.hr = pSystem->Store(bstrProgId, pSubscription);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Store");

                // get constructed subscription id and save it
                ft.hr = pSubscription->get_SubscriptionID(&m_rgbstrSubscriptionId[m_cbstrSubscriptionId]);
                ft.CheckForError(VSSDBG_WRITER, L"IEventSubscription::get_SubscriptionID");

                // increment count of
                m_cbstrSubscriptionId++;
                }
            }
        }
    VSS_STANDARD_CATCH(ft)

    // if the operation fails with us partially subscribed, then unsubscribe
    if (ft.HrFailed() && m_cbstrSubscriptionId)
        {
        Unsubscribe();
        ft.Throw(VSSDBG_WRITER, ft.hr, L"Rethrowing exception");
        }

    ft.Trace(VSSDBG_WRITER, L"**** Subscribe succeeded for [%p]", this);
    }


// terminate timer thread
// assumes caller has the critical section locked
void CVssWriterImpl::TerminateTimerThread()
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::TerminateTimerThread");

    AssertLocked();
    if (m_hThreadTimerThread)
        {
        // cause timer thread to terminate
        m_command = VSS_TC_TERMINATE_THREAD;
        if (!SetEvent(m_hevtTimerThread))
            {
            DWORD dwErr = GetLastError();
            ft.Trace(VSSDBG_WRITER, L"SetEvent failed with error %d\n", dwErr);
            BS_ASSERT(FALSE && "SetEvent failed");
            }


        // get thread handle
        HANDLE hThread = m_hThreadTimerThread;
        m_hThreadTimerThread = NULL;

        // unlock during wait
        Unlock();
        if (WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED)
            {
            DWORD dwErr = GetLastError();
            ft.Trace(VSSDBG_WRITER, L"WaitForSingleObject failed with error %d\n", dwErr);
            BS_ASSERT(FALSE && "WaitForSingleObject failed");
            }

        CloseHandle(hThread);
        Lock();
        }
    }


// unsubscribe this writer from IVssWriter events
// This function returns S_FALSE when the writer is inactive (setup or safe mode)
void CVssWriterImpl::Unsubscribe()
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::Unsubscribe");

    if (m_bInSetup || m_bInSafeMode)
        ft.Throw
            (
            VSSDBG_WRITER,
            S_FALSE,
            L"Writer is inactive during setup or safe mode"
            );

    // validate that the writer is initialized
    if (!m_bInitialized)
        ft.Throw
            (
            VSSDBG_WRITER,
            VSS_E_BAD_STATE,
            L"You must initialize the writer before other operations"
            );

    // terminate timer thread if active
    Lock();
    TerminateTimerThread();
    Unlock();

    // make sure subscription name was assigned; if not assume subscriptions
    // weren't created
    if (m_bstrSubscriptionName.Length() == 0)
        return;

    // create event system
    CComPtr<IEventSystem> pSystem;
    ft.CoCreateInstanceWithLog(
            VSSDBG_WRITER,
            CLSID_CEventSystem,
            L"CEventSystem",
            CLSCTX_SERVER,
            IID_IEventSystem,
            (IUnknown**)&(pSystem));
    ft.CheckForError(VSSDBG_WRITER, L"CoCreateInstance");

#if 0
    WCHAR buf[256];
    int location;
    swprintf(buf, L"SubscriptionName = \"%s\"", m_bstrSubscriptionName);

    CComPtr<IEventObjectCollection> pCollection;

    ft.hr = pSystem->Query
        (
        PROGID_EventSubscriptionCollection,
        buf,
        &location,
        (IUnknown **) &pCollection
        );

    ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Query");

    long cSub;
    ft.hr = pCollection->get_Count(&cSub);
    ft.CheckForError(VSSDBG_WRITER, L"IEventObjectCollection::get_Count");
    pCollection = NULL;
#endif

    UINT iSubscription;
    for(iSubscription = 0; iSubscription < m_cbstrSubscriptionId; iSubscription++)
        {
        // setup query string
        CComBSTR bstrQuery = L"SubscriptionID == ";
        if (!bstrQuery)
            ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"allocation of BSTR failed");

        // if subscription exists, then remove it
        if (m_rgbstrSubscriptionId[iSubscription])
            {
            bstrQuery.Append(m_rgbstrSubscriptionId[iSubscription]);
            if (!bstrQuery)
                ft.Throw(VSSDBG_WRITER, E_OUTOFMEMORY, L"allocation of BSTR failed");

            int location;

            // remove subscription
            ft.hr = pSystem->Remove(PROGID_EventSubscription, bstrQuery, &location);
            ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Remove");

            // indicate that subscription was removed
            m_rgbstrSubscriptionId[iSubscription].Empty();
            }
        }
#if 0
    ft.hr = pSystem->Query
        (
        PROGID_EventSubscriptionCollection,
        buf,
        &location,
        (IUnknown **) &pCollection
        );

    ft.CheckForError(VSSDBG_WRITER, L"IEventSystem::Query");

    ft.hr = pCollection->get_Count(&cSub);
    ft.CheckForError(VSSDBG_WRITER, L"IEventObjectCollection::get_Count");
    pCollection = NULL;
#endif

    // reset subscription name so unsubscribe does nothing if called again
    m_bstrSubscriptionName.Empty();
    m_cbstrSubscriptionId = 0;

    // Disconnect the subscription object, if any are left (bug 496343)
    ::CoDisconnectObject(GetUnknown(), 0);
 
    ft.Trace(VSSDBG_WRITER, L"**** Unsubscribe succeeded for [%p] (%u subscriptions removed)", this, iSubscription);
    }

// create a internal writer class and link it up to the external writer class
void CVssWriterImpl::CreateWriter
    (
    CVssWriter *pWriter,            // external writer
    IVssWriterImpl **ppImpl         // interface to be used by external writer
    )
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterImpl::CreateWriter");

    BS_ASSERT(ppImpl);
    BS_ASSERT(pWriter);

    *ppImpl = NULL;

    // create internal wrier class
    CComObject<CVssWriterImpl> *pImpl;
    // create CVssWriterImpl object <core writer class>
    ft.hr = CComObject<CVssWriterImpl>::CreateInstance(&pImpl);
    if (ft.HrFailed())
        ft.Throw
            (
            VSSDBG_WRITER,
            E_OUTOFMEMORY,
            L"Failed to create CVssWriterImpl.  hr = 0x%08lx",
            ft.hr
            );

    // set reference count of internal writer to 1
    pImpl->GetUnknown()->AddRef();

    // link external writer into internal writer
    pImpl->SetWriter(pWriter);

    // return internal writer interface
    *ppImpl = (IVssWriterImpl *) pImpl;
    }

// constructor for writer state
CVssWriterState::CVssWriterState(
    	IN	CVssDiag& diag
    ) :
    m_iPreviousSnapshots(0),
    m_bSequenceInProgress(false),
    m_diag(diag) 
    {
    // initialize current state
    m_currentState.m_state = VSS_WS_STABLE;
    m_currentState.m_idSnapshotSet = GUID_NULL;
    m_currentState.m_bInOperation = false;
    m_currentState.m_hrWriterFailure = S_OK;

    // initialize stack
    for(UINT i = 0; i < MAX_PREVIOUS_SNAPSHOTS; i++)
        {
        m_rgPreviousStates[i].m_idSnapshotSet = GUID_NULL;
        m_rgPreviousStates[i].m_state = VSS_WS_UNKNOWN;
        m_rgPreviousStates[i].m_bInOperation = false;
        m_rgPreviousStates[i].m_hrWriterFailure = E_UNEXPECTED;
        }
    }

// setup state at the beginning of a snapshot
void CVssWriterState::InitializeCurrentState(IN const VSS_ID &idSnapshot)
    {
    CVssSafeAutomaticLock lock(m_cs);

    // initalize snapshot id
    m_currentState.m_idSnapshotSet = idSnapshot;
    
    // indicate that there is no failure
    m_currentState.m_hrWriterFailure = S_OK;

    // clear that we are in an operation
    m_currentState.m_bInOperation = false;

    // indicate that sequence is in progress
    m_bSequenceInProgress = true;

    // current state is STABLE (i.e., beginning of sequence, clears
    // any completion state we were in)
    SetCurrentState(VSS_WS_STABLE);
    
    }

// push the current state
void CVssWriterState::PushCurrentState()
    {
    CVssSafeAutomaticLock lock(m_cs);

    if (m_bSequenceInProgress)
        {
        // Reset the sequence-related data members
        m_bSequenceInProgress = false;

        // We need to test to not add the same SSID twice - bug 228622.
        if (SearchForPreviousSequence(m_currentState.m_idSnapshotSet) == INVALID_SEQUENCE_INDEX)
            {
            BS_ASSERT(m_iPreviousSnapshots < MAX_PREVIOUS_SNAPSHOTS);
            VSWRITER_STATE *pState = &m_rgPreviousStates[m_iPreviousSnapshots];
            memcpy(pState, &m_currentState, sizeof(m_currentState));
            m_iPreviousSnapshots = (m_iPreviousSnapshots + 1) % MAX_PREVIOUS_SNAPSHOTS;
            }
        else
            BS_ASSERT(false); // The same SSID was already added - programming error.
        }
    }

// find the state for a previous snapshot set
INT CVssWriterState::SearchForPreviousSequence(IN const VSS_ID& idSnapshotSet)
    {
    CVssSafeAutomaticLock lock(m_cs);

    for(INT iSeqIndex = 0;
        iSeqIndex < MAX_PREVIOUS_SNAPSHOTS;
        iSeqIndex++)
        {
        if (idSnapshotSet == m_rgPreviousStates[iSeqIndex].m_idSnapshotSet)
            return iSeqIndex;
        } // end for

    return INVALID_SEQUENCE_INDEX;
    }


// obtain the state given the snapshot id
void CVssWriterState::GetStateForSnapshot
    (
    IN const VSS_ID &id,
    OUT VSWRITER_STATE &state
    )
    {
    // get lock on state class
    CVssSafeAutomaticLock lock(m_cs);
    
    if (id == GUID_NULL ||
        m_bSequenceInProgress && id == m_currentState.m_idSnapshotSet)
        {
        // get state for current snapshot set
        state = m_currentState;
        }
    else
        {
        // return state for a previously created snapshot set

        // Search for the previous sequence with the same ID
        INT nPreviousSequence = SearchForPreviousSequence(id);
        if (nPreviousSequence == INVALID_SEQUENCE_INDEX)
            {
            // don't have any information about the snapshot set
            state.m_idSnapshotSet = id;
            state.m_bInOperation = false;
            state.m_state = VSS_WS_UNKNOWN;
            state.m_hrWriterFailure = E_UNEXPECTED;
            }
        else
            {
            BS_ASSERT(m_rgPreviousStates[nPreviousSequence].m_idSnapshotSet == id);

            // return state from snapshot set
            state = m_rgPreviousStates[nPreviousSequence];
            }
        }
    }



// handle completion of the BackupComplete state.
void CVssWriterState::FinishBackupComplete(const VSS_ID &id)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterState::FinishBackupComplete");

    // lock class
    CVssSafeAutomaticLock lock(m_cs);

    // We must search for a previous state - Thaw already ended the sequence.
    INT iPreviousSequence = SearchForPreviousSequence(id);
    if (iPreviousSequence == INVALID_SEQUENCE_INDEX)
        {
        // couldn't find snapshot set.  We will indicate that this is
        // a retryable error
        SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);

        // unlock class before throwing
        ft.Throw
            (
            VSSDBG_WRITER,
            E_UNEXPECTED,
            L"Couldn't find a previous sequence with the same Snapshot Set ID"
            );
        }

    // We found a previous sequence with the same SSID.
    BS_ASSERT(id == m_rgPreviousStates[iPreviousSequence].m_idSnapshotSet);

    // BUG 228622 - If we do not have a previous successful Thaw transition
    // then we cannot call BackupComplete
    if (m_rgPreviousStates[iPreviousSequence].m_state != VSS_WS_WAITING_FOR_BACKUP_COMPLETE)
        {
        SetCurrentFailure(VSS_E_WRITERERROR_RETRYABLE);

        ft.Throw
            (
            VSSDBG_WRITER,
            E_UNEXPECTED,
            L"Couldn't call BackupComplete without OnThaw as a previous state [%d]",
            m_rgPreviousStates[iPreviousSequence].m_state
            );
        }

    // BUG 219692 - indicate that sequence is complete even in the saved states
    m_rgPreviousStates[iPreviousSequence].m_state = VSS_WS_STABLE;
    m_rgPreviousStates[iPreviousSequence].m_bInOperation = true;
    m_rgPreviousStates[iPreviousSequence].m_currentOperation = VSS_IN_BACKUPCOMPLETE;
    }

// indicate that backup complete failed
void CVssWriterState::SetBackupCompleteStatus(const VSS_ID &id, HRESULT hr)
    {
    CVssFunctionTracer ft(VSSDBG_WRITER, L"CVssWriterState::SetBackupCompleteFailed");

    // lock class
    CVssSafeAutomaticLock lock(m_cs);

    // We must search for a previous state - Thaw already ended the sequence.
    INT iPreviousSequence = SearchForPreviousSequence(id);
    if (iPreviousSequence == INVALID_SEQUENCE_INDEX)
        return;

    // We found a previous sequence with the same SSID.
    BS_ASSERT(id == m_rgPreviousStates[iPreviousSequence].m_idSnapshotSet);


    if (m_rgPreviousStates[iPreviousSequence].m_state == VSS_WS_STABLE ||
        m_rgPreviousStates[iPreviousSequence].m_state == VSS_WS_WAITING_FOR_BACKUP_COMPLETE)
        {
        if (FAILED(hr))
            {
            // indicate failure and use current failure as the backup completion failure
            m_rgPreviousStates[iPreviousSequence].m_state = VSS_WS_FAILED_AT_BACKUP_COMPLETE;
            m_rgPreviousStates[iPreviousSequence].m_hrWriterFailure = m_currentState.m_hrWriterFailure;
            }

        m_rgPreviousStates[iPreviousSequence].m_bInOperation = false;
        }
    }


// no response error.  It first checks to see if we are still
// in the operation.  If not, then we need to retry obtaining
// the writer's state
bool CVssWriterState::SetNoResponseFailure(
    IN const VSS_ID &id, 
    IN const VSWRITER_STATE &state 
    )
    {
    // lock object
    CVssSafeAutomaticLock lock(m_cs);

    if (m_currentState.m_idSnapshotSet == state.m_idSnapshotSet)
        {
        if (!m_currentState.m_bInOperation ||
            m_currentState.m_currentOperation != state.m_currentOperation)
            {
            // no longer in the operation.  Should not return a no-response
            // failure.  Instead requery the current state
            return false;
            }

        // This should apply only if the ID is the current snapshot set ID
        //
        // The logic is that the writer is now hung from the backup app point of view.
        // We need to set the correct state now, so that the backup app knows what's wrong.
        //
        if ((m_currentState.m_idSnapshotSet == id) && (GUID_NULL != id))
            {
            SetCurrentFailure(VSS_E_WRITER_NOT_RESPONDING);
            SetCurrentState(state.m_state);
            }
        
        return true;
        }

    INT iPreviousSequence = SearchForPreviousSequence(state.m_idSnapshotSet);
    if (iPreviousSequence == INVALID_SEQUENCE_INDEX)
        return true;

    VSWRITER_STATE *pState = &m_rgPreviousStates[iPreviousSequence];
    if (!pState->m_bInOperation ||
        pState->m_currentOperation != state.m_currentOperation)
        {
        // no longer in the operation.  We should not return an no-response
        // failure.  Instead requery the state of the snapshot set.
        return false;
        }

    // indicate that writer is not responding
    pState->m_hrWriterFailure = VSS_E_WRITER_NOT_RESPONDING;

    // get last known state of writer
    pState->m_state = state.m_state;
    return true;
    }


//////////////////////////////////////////////////////////////////////////
// Auto diag class




// Constructor
CVssAutoDiagLogger::CVssAutoDiagLogger( 
    IN CVssWriterState & state,
    IN DWORD dwEventID,
    IN VSS_ID ssid, /* = GUID_NULL */
    IN DWORD dwEventFlags /* = 0 */
    ):
    m_state(state),
    m_dwEventID(dwEventID),
    m_ssid(ssid),
    m_dwEventFlags(dwEventFlags)
{
    m_state.GetDiag().RecordGenericEvent(m_dwEventID, 
        CVssDiag::VSS_DIAG_ENTER_OPERATION,
        m_state.GetCurrentState(), 
        m_state.GetCurrentFailure(), 
        m_ssid);
}


// Constructor
CVssAutoDiagLogger::CVssAutoDiagLogger( 
    IN CVssWriterState & state,
    IN DWORD dwEventID,
    IN WCHAR* pwszSSID,
    IN DWORD dwEventFlags /* = 0 */
    ):
    m_state(state),
    m_dwEventID(dwEventID),
    m_ssid(GUID_NULL),
    m_dwEventFlags(dwEventFlags)
{
    // Try to read the SSID
    if (pwszSSID)
        ::CLSIDFromString(W2OLE(pwszSSID), &m_ssid);
    
    m_state.GetDiag().RecordGenericEvent(m_dwEventID, 
        CVssDiag::VSS_DIAG_ENTER_OPERATION | m_dwEventFlags,
        m_state.GetCurrentState(), 
        m_state.GetCurrentFailure(), 
        m_ssid);
}


// Destructor
CVssAutoDiagLogger::~CVssAutoDiagLogger()
{
    m_state.GetDiag().RecordGenericEvent(m_dwEventID, 
        CVssDiag::VSS_DIAG_LEAVE_OPERATION | m_dwEventFlags,
        m_state.GetCurrentState(), 
        m_state.GetCurrentFailure(), 
        m_ssid);
}