windows-server-2003/admin/pchealth/helpctr/service/accounts/slave.cpp

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

Copyright (c) 1999 Microsoft Corporation

Module Name:
    Slave.cpp

Abstract:
    File for Implementation of CPCHMasterSlave and CPCHUserProcess classes,
    used to establish a connection between the service and a slave process.

Revision History:
    Davide Massarenti created  03/28/2000

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

#include "stdafx.h"

#include <UserEnv.h>

/////////////////////////////////////////////////////////////////////////////

static const WCHAR c_HelpHost[] = HC_ROOT_HELPSVC_BINARIES L"\\HelpHost.exe";
static const DWORD c_Timeout = 100 * 1000;

/////////////////////////////////////////////////////////////////////////////

CPCHUserProcess::UserEntry::UserEntry()
{
                           // CComBSTR                  m_bstrUser
    m_dwSessionID = 0;     // DWORD                     m_dwSessionID;
                           //
                           // CComBSTR                  m_bstrVendorID;
                           // CComBSTR                  m_bstrPublicKey;
                           //
                           // GUID                      m_guid;
                           // CComPtr<IPCHSlaveProcess> m_spConnection;
    m_hToken      = NULL;  // HANDLE                    m_hToken;
    m_hProcess    = NULL;  // HANDLE                    m_hProcess;
    m_phEvent     = NULL;  // HANDLE*                   m_phEvent;

    ::ZeroMemory( &m_guid, sizeof(m_guid) );
}

CPCHUserProcess::UserEntry::~UserEntry()
{
    Cleanup();
}

void CPCHUserProcess::UserEntry::Cleanup()
{
    m_bstrUser     .Empty  ();
    m_dwSessionID = 0;

    m_bstrVendorID .Empty  ();
    m_bstrPublicKey.Empty  ();

    m_spConnection .Release();

    if(m_hProcess)
    {
        ::CloseHandle( m_hProcess ); m_hProcess = NULL;
    }

    if(m_hToken)
    {
        ::CloseHandle( m_hToken ); m_hToken = NULL;
    }
}

////////////////////

bool CPCHUserProcess::UserEntry::operator==( /*[in]*/ const UserEntry& ue ) const
{
    if(ue.m_bstrUser)
    {
        if(m_bstrUser == ue.m_bstrUser && m_dwSessionID == ue.m_dwSessionID) return true;
    }

    if(ue.m_bstrVendorID)
    {
        if(MPC::StrICmp( m_bstrVendorID, ue.m_bstrVendorID ) == 0) return true;
    }

    return false;
}

bool CPCHUserProcess::UserEntry::operator==( /*[in]*/ const GUID& guid ) const
{
    return ::IsEqualGUID( m_guid, guid ) ? true : false;
}

////////////////////

HRESULT CPCHUserProcess::UserEntry::Clone( /*[in]*/ const UserEntry& ue )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::UserEntry::Clone" );

    HRESULT hr;

    Cleanup();

    m_bstrUser      = ue.m_bstrUser;      // CComBSTR                  m_bstrUser;
    m_dwSessionID   = ue.m_dwSessionID;   // DWORD                     m_dwSessionID;
                                          //
    m_bstrVendorID  = ue.m_bstrVendorID;  // CComBSTR                  m_bstrVendorID;
    m_bstrPublicKey = ue.m_bstrPublicKey; // CComBSTR                  m_bstrPublicKey;
                                          //
                                          // GUID                      m_guid;          // Used for establishing the connection.
                                          // CComPtr<IPCHSlaveProcess> m_spConnection;  // Live object.
                                          // HANDLE                    m_hToken;        // User token.
                                          // HANDLE                    m_hProcess;      // Process handle.
                                          // HANDLE*                   m_phEvent;       // To notify activator.

    if(ue.m_hToken)
    {
        __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::DuplicateTokenEx( ue.m_hToken, 0, NULL, SecurityImpersonation, TokenPrimary, &m_hToken ));
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHUserProcess::UserEntry::Connect( /*[out]*/ HANDLE& hEvent )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::UserEntry::Connect" );

    HRESULT hr;


    //
    // Logon the user, if not already done.
    //
    if(m_hToken == NULL)
    {
        CPCHAccounts acc;
		LPCWSTR      szUser = SAFEBSTR( m_bstrUser );

////    // DEBUG
////    // DEBUG
////    // DEBUG
////    __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::OpenProcessToken( ::GetCurrentProcess(), TOKEN_ALL_ACCESS, &m_hToken ));

		//
		// Only keep the account enabled for the time it takes to create its token.
		//
		__MPC_EXIT_IF_METHOD_FAILS(hr, acc.ChangeUserStatus( szUser, /*fEnable*/true  ));
        __MPC_EXIT_IF_METHOD_FAILS(hr, acc.LogonUser       ( szUser, NULL, m_hToken   ));
		__MPC_EXIT_IF_METHOD_FAILS(hr, acc.ChangeUserStatus( szUser, /*fEnable*/false ));
    }

    if(m_hProcess     == NULL ||
       m_spConnection == NULL  )
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, SendActivation( hEvent ));
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHUserProcess::UserEntry::SendActivation( /*[out]*/ HANDLE& hEvent )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::UserEntry::SendActivation" );

    HRESULT             hr;
    DWORD               dwRes;
    PROCESS_INFORMATION piProcessInformation;
    STARTUPINFOW        siStartupInfo;
    VOID*               pEnvBlock = NULL;
    MPC::wstring        strExe( c_HelpHost ); MPC::SubstituteEnvVariables( strExe );
    WCHAR               rgCommandLine[1024];

    ::ZeroMemory( (PVOID)&piProcessInformation, sizeof( piProcessInformation ) );
    ::ZeroMemory( (PVOID)&siStartupInfo       , sizeof( siStartupInfo        ) ); siStartupInfo.cb = sizeof( siStartupInfo );


    //
    // Generate random ID.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, ::CoCreateGuid( &m_guid ));


    //
    // Create event.
    //
    __MPC_EXIT_IF_CALL_RETURNS_NULL(hr, (hEvent = ::CreateEvent( NULL, FALSE, FALSE, NULL )));

    //
    // Create process as user.
    //
    {
        CComBSTR bstrGUID( m_guid );

        swprintf( rgCommandLine, L"\"%s\" -guid %s", strExe.c_str(), (BSTR)bstrGUID );
    }

	__MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::CreateEnvironmentBlock( &pEnvBlock, m_hToken, TRUE ));

////    // DEBUG
////    // DEBUG
////    // DEBUG
////    __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::CreateProcessW( NULL,
////                                                           rgCommandLine,
////                                                           NULL,
////                                                           NULL,
////                                                           FALSE,
////                                                           NORMAL_PRIORITY_CLASS,
////                                                           NULL,
////                                                           NULL,
////                                                           &siStartupInfo,
////                                                           &piProcessInformation ));

    // REAL
    // REAL
    // REAL
    __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::CreateProcessAsUserW( m_hToken                                           ,
                                                                 NULL                                               ,
                                                                 rgCommandLine                                      ,
                                                                 NULL                                               ,
                                                                 NULL                                               ,
                                                                 FALSE                                              ,
                                                                 NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT ,
                                                                 pEnvBlock                                          ,
                                                                 NULL                                               ,
                                                                 &siStartupInfo                                     ,
                                                                 &piProcessInformation                              ));

    m_hProcess = piProcessInformation.hProcess; piProcessInformation.hProcess = NULL;
    hr         = S_OK;


    __HCP_FUNC_CLEANUP;

	if(pEnvBlock) ::DestroyEnvironmentBlock( pEnvBlock );

    if(piProcessInformation.hProcess) ::CloseHandle( piProcessInformation.hProcess );
    if(piProcessInformation.hThread ) ::CloseHandle( piProcessInformation.hThread  );

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT CPCHUserProcess::UserEntry::InitializeForVendorAccount( /*[in]*/ BSTR bstrUser      ,
                                                                /*[in]*/ BSTR bstrVendorID  ,
                                                                /*[in]*/ BSTR bstrPublicKey )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::UserEntry::InitializeForVendorAccount" );

    HRESULT hr;

    Cleanup();

    m_bstrUser      = bstrUser;

    m_bstrVendorID  = bstrVendorID;
    m_bstrPublicKey = bstrPublicKey;

    hr = S_OK;


    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHUserProcess::UserEntry::InitializeForImpersonation( /*[in]*/ HANDLE hToken )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::UserEntry::InitializeForImpersonation" );

    HRESULT            hr;
    MPC::Impersonation imp;
    MPC::wstring       strUser;
    DWORD              dwSize;
    PSID               pUserSid = NULL;


    if(hToken == NULL)
    {
        __MPC_EXIT_IF_METHOD_FAILS(hr, imp.Initialize( MAXIMUM_ALLOWED ));

        hToken = imp;
    }

    __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::DuplicateTokenEx( hToken, 0, NULL, SecurityImpersonation, TokenPrimary, &m_hToken ));

    __MPC_EXIT_IF_CALL_RETURNS_FALSE(hr, ::GetTokenInformation( m_hToken, TokenSessionId, &m_dwSessionID, sizeof(m_dwSessionID), &dwSize ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::SecurityDescriptor::GetTokenSids         ( m_hToken, &pUserSid, NULL    ));
    __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::SecurityDescriptor::ConvertSIDToPrincipal(            pUserSid, strUser )); m_bstrUser = strUser.c_str();


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    MPC::SecurityDescriptor::ReleaseMemory( pUserSid );

    __HCP_FUNC_EXIT(hr);
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

CPCHUserProcess::CPCHUserProcess()
{
    // List m_lst;

    (void)MPC::_MPC_Module.RegisterCallback( this, (void (CPCHUserProcess::*)())Shutdown );
}

CPCHUserProcess::~CPCHUserProcess()
{
    MPC::CallDestructorForAll( m_lst );

    MPC::_MPC_Module.UnregisterCallback( this );
}

////////////////////

CPCHUserProcess* CPCHUserProcess::s_GLOBAL( NULL );

HRESULT CPCHUserProcess::InitializeSystem()
{
    if(s_GLOBAL == NULL)
    {
        s_GLOBAL = new CPCHUserProcess;
    }

    return s_GLOBAL ? S_OK : E_OUTOFMEMORY;
}

void CPCHUserProcess::FinalizeSystem()
{
    if(s_GLOBAL)
    {
        delete s_GLOBAL; s_GLOBAL = NULL;
    }
}

////////////////////////////////////////////////////////////////////////////////

void CPCHUserProcess::Shutdown()
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::Shutdown" );

    MPC::SmartLock<_ThreadModel> lock( this );


    m_lst.clear();
}


CPCHUserProcess::UserEntry* CPCHUserProcess::Lookup( /*[in]*/ const UserEntry& ue, /*[in]*/ bool fRelease )
{
    UserEntry* ueReal;

    //
    // Locate vendor and connect to it.
    //
    for(Iter it = m_lst.begin(); it != m_lst.end(); )
    {
        ueReal = *it;
        if(ueReal && *ueReal == ue)
        {
            if(fRelease)
            {
                delete ueReal;

                m_lst.erase( it++ ); continue;
            }
            else
            {
                return ueReal;
            }
        }

        it++;
    }

    return NULL;
}

HRESULT CPCHUserProcess::Remove( /*[in]*/ const UserEntry& ue )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::Remove" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );


    (void)Lookup( ue, /*fRelease*/true );


    hr = S_OK;


    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHUserProcess::Connect( /*[in ]*/ const UserEntry&   ue           ,
                                  /*[out]*/ IPCHSlaveProcess* *spConnection )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::Connect" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );
    HANDLE                       hEvent = NULL;
    UserEntry*                   ueReal = NULL;

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHUserProcess::Connect" );

    //
    // Locate vendor and connect to it.
    //
    ueReal = Lookup( ue, /*fRelease*/false );
    if(ueReal == NULL)
    {
        __MPC_EXIT_IF_ALLOC_FAILS(hr, ueReal, new UserEntry);
        m_lst.push_back( ueReal );

        __MPC_EXIT_IF_METHOD_FAILS(hr, ueReal->Clone( ue ));
    }

    __MPC_EXIT_IF_METHOD_FAILS(hr, ueReal->Connect( hEvent ));


    //
    // If "Connect" returns an event handle, wait on it.
    //
    if(hEvent)
    {
        ueReal->m_phEvent = &hEvent; // For waiting response...

        lock = NULL;

        if(::WaitForSingleObject( hEvent, c_Timeout ) != WAIT_OBJECT_0)
        {
            __MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
        }

        lock = this;

        //
        // Relocate vendor (we release the lock on the object, so "ueReal" is not valid anymore.
        //
        ueReal = Lookup( ue, /*fRelease*/false );
        if(ueReal == NULL)
        {
            __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
        }
    }

    __MPC_EXIT_IF_METHOD_FAILS(hr, ueReal->m_spConnection.QueryInterface( spConnection ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    if(hEvent) ::CloseHandle( hEvent );

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHUserProcess::Connect - done" );

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHUserProcess::RegisterHost( /*[in]*/ BSTR              bstrID ,
                                       /*[in]*/ IPCHSlaveProcess* pObj   )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::RegisterHost" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );
    UserEntry*                   ueReal = NULL;
    GUID                         guid;


    //
    // Validate input.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, ::CLSIDFromString( bstrID, &guid ));


    //
    // Locate vendor and connect to it.
    //
    for(Iter it = m_lst.begin(); it != m_lst.end(); it++)
    {
        ueReal = *it;
        if(ueReal && *ueReal == guid)
        {
            break;
        }
    }
    if(ueReal == NULL)
    {
        __MPC_SET_WIN32_ERROR_AND_EXIT(hr, ERROR_FILE_NOT_FOUND);
    }

    __MPC_EXIT_IF_METHOD_FAILS(hr, pObj->Initialize( ueReal->m_bstrVendorID, ueReal->m_bstrPublicKey ));

    ueReal->m_spConnection = pObj;

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    if(ueReal)
    {
        if(ueReal->m_phEvent)
        {
            //
            // Signal the event handle, to awake the activator.
            //
            ::SetEvent( *(ueReal->m_phEvent) );

            ueReal->m_phEvent = NULL;
        }
    }

    __HCP_FUNC_EXIT(hr);
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

HRESULT CPCHUserProcess::SendResponse( /*[in]*/ DWORD    dwArgc   ,
                                       /*[in]*/ LPCWSTR* lpszArgv )
{
    __HCP_FUNC_ENTRY( "CPCHUserProcess::SendResponse" );

    HRESULT                   hr;
    int                       i;
    CComBSTR                  bstrGUID;
    CComPtr<IPCHService>      srv;
    CComPtr<CPCHSlaveProcess> obj;
#ifdef DEBUG
    bool                      fDebug = false;
#endif


    //
    // Parse the arguments.
    //
    for(i=1; i<dwArgc; i++)
    {
        LPCWSTR szArg = lpszArgv[i];

        if(szArg[0] == '-' ||
           szArg[0] == '/'  )
        {
            szArg++;

            if(_wcsicmp( szArg, L"guid" ) == 0 && (i<dwArgc-1))
            {
                bstrGUID = lpszArgv[++i];
                continue;
            }

#ifdef DEBUG
            if(_wcsicmp( szArg, L"debug" ) == 0)
            {
                fDebug = true;
                continue;
            }
#endif
        }

        __MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
    }

#ifdef DEBUG
    if(fDebug) DebugBreak();
#endif

    //
    // Create the COM object.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, MPC::CreateInstance( &obj ));

    //
    // Register it with the service.
    //
    __MPC_EXIT_IF_METHOD_FAILS(hr, ::CoCreateInstance( CLSID_PCHService, NULL, CLSCTX_ALL, IID_IPCHService, (void**)&srv ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, srv->RegisterHost( bstrGUID, obj ));


    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

CPCHSlaveProcess::CPCHSlaveProcess()
{
    						 // CComBSTR                    m_bstrVendorID;
    						 // CComBSTR                    m_bstrPublicKey;
	m_ScriptLauncher = NULL; // CPCHScriptWrapper_Launcher* m_ScriptLauncher;
}

CPCHSlaveProcess::~CPCHSlaveProcess()
{
	delete m_ScriptLauncher;
}

HRESULT CPCHSlaveProcess::Initialize( /*[in]*/ BSTR bstrVendorID, /*[in]*/ BSTR bstrPublicKey )
{
    m_bstrVendorID  = bstrVendorID;
    m_bstrPublicKey = bstrPublicKey;

    return S_OK;
}

HRESULT CPCHSlaveProcess::CreateInstance( /*[in ]*/ REFCLSID   rclsid    ,
                                          /*[in ]*/ IUnknown*  pUnkOuter ,
                                          /*[out]*/ IUnknown* *ppvObject )
{
	HRESULT hr;

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::CreateInstance" );

    hr = ::CoCreateInstance( rclsid, pUnkOuter, CLSCTX_ALL, IID_IUnknown, (void**)ppvObject );

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::CreateInstance - done" );

	return hr;
}

HRESULT CPCHSlaveProcess::CreateScriptWrapper( /*[in ]*/ REFCLSID   rclsid   ,
                                               /*[in ]*/ BSTR       bstrCode ,
                                               /*[in ]*/ BSTR       bstrURL  ,
                                               /*[out]*/ IUnknown* *ppObj    )
{
    __HCP_FUNC_ENTRY( "CPCHSlaveProcess::CreateScriptWrapper" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );

	if(!m_ScriptLauncher)
	{
		__MPC_EXIT_IF_ALLOC_FAILS(hr, m_ScriptLauncher, new CPCHScriptWrapper_Launcher);
	}

	__MPC_EXIT_IF_METHOD_FAILS(hr, m_ScriptLauncher->CreateScriptWrapper( rclsid, bstrCode, bstrURL, ppObj ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHSlaveProcess::OpenBlockingStream( /*[in ]*/ BSTR       bstrURL   ,
                                              /*[out]*/ IUnknown* *ppvObject )
{
    __HCP_FUNC_ENTRY( "CPCHSlaveProcess::OpenBlockingStream" );

    HRESULT          hr;
    CComPtr<IStream> stream;


	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::OpenBlockingStream" );

    __MPC_EXIT_IF_METHOD_FAILS(hr, URLOpenBlockingStreamW( NULL, bstrURL, &stream, 0, NULL ));

    __MPC_EXIT_IF_METHOD_FAILS(hr, stream.QueryInterface( ppvObject ));

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::OpenBlockingStream - done" );

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHSlaveProcess::IsNetworkAlive( /*[out]*/ VARIANT_BOOL* pfRetVal )
{
    __HCP_FUNC_ENTRY( "CPCHSlaveProcess::IsNetworkAlive" );

    HRESULT hr;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_POINTER_AND_SET(pfRetVal,VARIANT_FALSE);
    __MPC_PARAMCHECK_END();

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::IsNetworkAlive" );

    if(SUCCEEDED(MPC::Connectivity::NetworkAlive( HC_TIMEOUT_CONNECTIONCHECK )))
    {
        *pfRetVal = VARIANT_TRUE;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::IsNetworkAlive - done" );

    __HCP_FUNC_EXIT(hr);
}

HRESULT CPCHSlaveProcess::IsDestinationReachable( /*[in ]*/ BSTR bstrDestination, /*[out]*/ VARIANT_BOOL *pfRetVal )
{
    __HCP_FUNC_ENTRY( "CPCHSlaveProcess::IsDestinationReachable" );

    HRESULT hr;

    __MPC_PARAMCHECK_BEGIN(hr)
        __MPC_PARAMCHECK_STRING_NOT_EMPTY(bstrDestination);
        __MPC_PARAMCHECK_POINTER_AND_SET(pfRetVal,VARIANT_FALSE);
    __MPC_PARAMCHECK_END();

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::IsDestinationReachable" );

    if(SUCCEEDED(MPC::Connectivity::DestinationReachable( bstrDestination, HC_TIMEOUT_CONNECTIONCHECK )))
    {
        *pfRetVal = VARIANT_TRUE;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

	DEBUG_AppendPerf( DEBUG_PERF_HELPHOST, "CPCHSlaveProcess::IsDestinationReachable - done" );

    __HCP_FUNC_EXIT(hr);
}