able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/ias/mmc/nap/machinenode.cpp

1120 lines
27 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//////////////////////////////////////////////////////////////////////////////
/*++
Copyright (C) Microsoft Corporation, 1997 - 1999
Module Name:
MachineNode.cpp
Abstract:
Implementation file for the CMachineNode class.
Revision History:
mmaguire 12/03/97
byao 6/11/98 Added asynchrnous connect
--*/
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// BEGIN INCLUDES
//
// standard includes:
//
#include "Precompiled.h"
//
// where we can find declaration for main class in this file:
//
#include "MachineNode.h"
#include "Component.h"
#include "SnapinNode.cpp" // Template implementation
//
// where we can find declarations needed in this file:
//
#include "NapUtil.h"
#include "MachineEnumTask.h"
#include "NodeTypeGUIDS.h"
#include "ChangeNotification.h"
//
// END INCLUDES
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::IsSupportedGUID
Used to determine whether we extend the node type of a given GUID, and sets
the m_enumExtendedSnapin variable to indicate what snapin we are extending.
--*/
//////////////////////////////////////////////////////////////////////////////
BOOL CMachineNode::IsSupportedGUID( GUID & guid )
{
if( IsEqualGUID( guid, InternetAuthenticationServiceGUID_ROOTNODETYPE ) )
{
m_enumExtendedSnapin = INTERNET_AUTHENTICATION_SERVICE_SNAPIN;
return TRUE;
}
else
{
if( IsEqualGUID( guid, NetworkConsoleGUID_ROOTNODETYPE) )
{
m_enumExtendedSnapin = NETWORK_MANAGEMENT_SNAPIN;
return TRUE;
}
else
{
if( IsEqualGUID( guid, RoutingAndRemoteAccessGUID_MACHINENODETYPE ) )
{
m_enumExtendedSnapin = RRAS_SNAPIN;
return TRUE;
}
}
}
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::GetExtNodeObject
Depending on which snapin we are extending, when queried for a node object
corresponding to a particular machine, we must decide which node we want
to give a pointer to.
When we extend a snapin like IAS or Network Management, where there is one
instance of a snapin per machine being configured, we simply return a pointer
to "this" -- this CMachineNode object is the single one being administed.
When we extend a snapin like RRAS where there is an "Enterprise" view and
one snapin may need to manage a view of multiple machines, this CMachineNode
will act as a redirector to a CMachineNode in a list of m_mapMachineNodes it
maintains which corresponds to the appropriate machines.
--*/
//////////////////////////////////////////////////////////////////////////////
CSnapInItem * CMachineNode::GetExtNodeObject(LPDATAOBJECT pDataObject, CMachineNode * pDataClass )
{
TRACE_FUNCTION("CMachineNode::GetExtNodeObject");
if( m_enumExtendedSnapin == INTERNET_AUTHENTICATION_SERVICE_SNAPIN
|| m_enumExtendedSnapin == NETWORK_MANAGEMENT_SNAPIN )
{
// There is one instance of a machine node per snapin.
// This machine node is a "virtual root" that shadows the node being extended.
m_fNodeHasUI = TRUE;
return this;
}
else
{
try
{
_ASSERTE( m_enumExtendedSnapin == RRAS_SNAPIN );
// There are many machine nodes and one extension snapin needs to handle them all.
// We use this function to extract the machine name from the clipboard format.
// It will set the corrent value in m_bstrServerAddress.
m_fAlreadyAnalyzedDataClass = FALSE;
InitDataClass( pDataObject, pDataClass );
// See if we already have a CMachineNode object corresponding to the
// machine named in m_bstrServerAddress and insert it if we do not.
SERVERSMAP::iterator theIterator;
BOOL bAddedAsLocal = ExtractComputerAddedAsLocal(pDataObject);
std::basic_string< wchar_t > MyString = m_bstrServerAddress;
// local machine has special entry
if(bAddedAsLocal)
MyString = _T("");
CMachineNode * pMachineNode = NULL;
theIterator = m_mapMachineNodes.find(MyString);
if( theIterator == m_mapMachineNodes.end() )
{
// We need to insert a new CMachineNode object for m_bstrServerAddress.
pMachineNode = new CMachineNode();
pMachineNode->m_pComponentData = m_pComponentData;
pMachineNode->m_enumExtendedSnapin = m_enumExtendedSnapin;
m_mapMachineNodes.insert( SERVERSMAP::value_type( MyString, pMachineNode ) );
// ISSUE: We should be able to use the pair returned from insert above,
// but for now, just use find again.
theIterator = m_mapMachineNodes.find(MyString);
}
else
pMachineNode = (CMachineNode*)theIterator->second;
// RRAS refresh advise setup F bug 213623:
if(!pMachineNode->m_spRtrAdviseSink)
pMachineNode->m_spRtrAdviseSink.p = CRtrAdviseSinkForIAS<CMachineNode>::SetAdvise(pMachineNode, pDataObject);
pMachineNode->m_fNodeHasUI = TRUE;
// ~RRAS
// We already have a CMachineNode for this object.
return theIterator->second;
}
catch(...)
{
// Error.
return NULL;
}
}
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::OnRRASChange
// OnRRASChange -- to decide if to show RAP node under the machine node
// Only show RAP node if NT Authentication is selected
--*/
HRESULT CMachineNode::OnRRASChange(
/* [in] */ LONG_PTR ulConnection,
/* [in] */ DWORD dwChangeType,
/* [in] */ DWORD dwObjectType,
/* [in] */ LPARAM lUserParam,
/* [in] */ LPARAM lParam)
{
HRESULT hr = S_OK;
if(m_fNodeHasUI)
hr = TryShow(NULL);
return S_OK;
}
//==============
//==============
HRESULT CMachineNode::TryShow(BOOL* pbVisible )
{
HRESULT hr = S_OK;
CComPtr<IConsole> spConsole;
CComPtr<IConsoleNameSpace> spConsoleNameSpace;
BOOL bShow = FALSE;
if(!m_bServerSupported || !m_fAlreadyAnalyzedDataClass || !m_pPoliciesNode || !m_fNodeHasUI)
return hr;
// when RRAS_SNAPIN extension
if(m_enumExtendedSnapin == RRAS_SNAPIN)
{
BSTR bstrMachine = NULL;
if(!m_bConfigureLocal)
bstrMachine = m_bstrServerAddress;
bShow = (IsRRASConfigured(bstrMachine) && IsRRASUsingNTAuthentication(bstrMachine));
}
// IAS, show only IAS service is installed on the machine
else if (INTERNET_AUTHENTICATION_SERVICE_SNAPIN == m_enumExtendedSnapin)
{
hr = IfServiceInstalled(m_bstrServerAddress, _T("IAS"), &bShow);
if(hr != S_OK) return hr;
}
else // always show
{
bShow = TRUE;
}
// deal with the node
hr = m_pComponentData->m_spConsole->QueryInterface(
IID_IConsoleNameSpace,
(VOID**)(&spConsoleNameSpace) );
if(S_OK != hr)
goto Error;
if ( bShow && m_pPoliciesNode->m_scopeDataItem.ID == NULL) // show the node
{
hr = spConsoleNameSpace->InsertItem( &(m_pPoliciesNode->m_scopeDataItem) );
// _ASSERT( NULL != m_pPoliciesNode->m_scopeDataItem.ID );
}
else if (!bShow && m_pPoliciesNode->m_scopeDataItem.ID != NULL) // hide
{ // hide the node
hr = spConsoleNameSpace->DeleteItem( m_pPoliciesNode->m_scopeDataItem.ID, TRUE );
m_pPoliciesNode->m_scopeDataItem.ID = NULL;
}
if(hr == S_OK && pbVisible)
*pbVisible = bShow;
Error:
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::CMachineNode
Constructor
--*/
//////////////////////////////////////////////////////////////////////////////
CMachineNode::CMachineNode(): CSnapinNode<CMachineNode, CComponentData, CComponent>( NULL )
{
TRACE_FUNCTION("CMachineNode::CMachineNode");
// The children subnodes have not yet been created.
m_pPoliciesNode = NULL;
// Set the display name for this object
m_bstrDisplayName = L"@Some Machine";
// In IComponentData::Initialize, we are asked to inform MMC of
// the icons we would like to use for the scope pane.
// Here we store an index to which of these images we
// want to be used to display this node
m_scopeDataItem.nImage = IDBI_NODE_MACHINE_CLOSED;
m_scopeDataItem.nOpenImage = IDBI_NODE_MACHINE_OPEN;
//
// initialize all the SDO pointers
//
m_fAlreadyAnalyzedDataClass = FALSE;
// connected?
m_fSdoConnected = FALSE;
// default to not configuring the local machine
m_bConfigureLocal = FALSE;
m_fUseActiveDirectory = FALSE;
m_fDSAvailable = FALSE;
// helper class that connect to server asynchrnously
m_pConnectionToServer = NULL;
m_fNodeHasUI = FALSE;
m_bServerSupported = TRUE;
m_enumExtendedSnapin = INTERNET_AUTHENTICATION_SERVICE_SNAPIN;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::~CMachineNode
Destructor
--*/
//////////////////////////////////////////////////////////////////////////////
CMachineNode::~CMachineNode()
{
TRACE_FUNCTION("CMachineNode::~CMachineNode");
// RRAS refresh
if(m_spRtrAdviseSink != NULL)
{
m_spRtrAdviseSink->ReleaseSink();
m_spRtrAdviseSink.Release();
}
// ~RRAS
if( NULL != m_pConnectionToServer )
{
m_pConnectionToServer->Release(TRUE);
}
// Delete children nodes
delete m_pPoliciesNode;
// Delete the list of machines in case we are extending a snapin with
// enterprise view like RRAS.
SERVERSMAP::iterator theIterator;
for( theIterator = m_mapMachineNodes.begin(); theIterator != m_mapMachineNodes.end(); ++theIterator )
{
delete theIterator->second;
}
m_mapMachineNodes.clear();
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::GetResultPaneColInfo
See CSnapinNode::GetResultPaneColInfo (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
LPOLESTR CMachineNode::GetResultPaneColInfo(int nCol)
{
TRACE_FUNCTION("CMachineNode::GetResultPaneColInfo");
if (nCol == 0)
{
return m_bstrDisplayName;
}
// TODO : Return the text for other columns
return OLESTR("Running");
}
HRESULT CMachineNode::OnRemoveChildren(
LPARAM arg
, LPARAM param
, IComponentData * pComponentData
, IComponent * pComponent
, DATA_OBJECT_TYPES type
)
{
// policy node will be removed, so we should set the ID to 0
if(m_pPoliciesNode)
m_pPoliciesNode->m_scopeDataItem.ID = 0;
// disconnect RRAS on change notify
// RRAS refresh
if(m_spRtrAdviseSink != NULL)
{
m_spRtrAdviseSink->ReleaseSink();
m_spRtrAdviseSink.Release();
}
m_fNodeHasUI = FALSE;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::DataRefresh
--*/
//////////////////////////////////////////////////////////////////////////////
// called to refresh the nodes
HRESULT CMachineNode::DataRefresh()
{
HRESULT hr = S_OK;
CComPtr<ISdo> spSdo;
CComPtr<ISdoDictionaryOld> spDic;
hr = m_pConnectionToServer->ReloadSdo(&spSdo, &spDic);
// refresh client node
if(hr == S_OK)
{
hr = m_pPoliciesNode->DataRefresh(spSdo, spDic);
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::OnExpand
See CSnapinNode::OnExpand (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
HRESULT CMachineNode::OnExpand(
LPARAM arg
, LPARAM param
, IComponentData * pComponentData
, IComponent * pComponent
, DATA_OBJECT_TYPES type
)
{
TRACE_FUNCTION("CMachineNode::OnExpand");
IConsoleNameSpace * pConsoleNameSpace;
HRESULT hr = S_FALSE;
if( TRUE == arg )
{
// we are expanding the root node -- which is the machine node here.
// Try to create the children of this Machine node
if( NULL == m_pPoliciesNode )
{
m_pPoliciesNode = new CPoliciesNode
(
this,
m_bstrServerAddress,
m_enumExtendedSnapin == INTERNET_AUTHENTICATION_SERVICE_SNAPIN
);
}
if( NULL == m_pPoliciesNode )
{
hr = E_OUTOFMEMORY;
// Use MessageBox() rather than IConsole::MessageBox() here because the
// first time this gets called m_ipConsole is not fully initialized
// ISSUE: The above statement is probably not true for this node.
::MessageBox( NULL, L"@Unable to allocate new nodes", L"CMachineNode::OnExpand", MB_OK );
return(hr);
}
//
// we need to get all the SDO pointers, this include the SdoServer,
// Dictionary, Profile collection, policy collection and condition collection
//
//todo: report error when not connected?
hr = BeginConnectAction();
if ( FAILED(hr) )
{
return hr;
}
// But to get that, first we need IConsole
CComPtr<IConsole> spConsole;
if( pComponentData != NULL )
{
spConsole = ((CComponentData*)pComponentData)->m_spConsole;
}
else
{
// We should have a non-null pComponent
spConsole = ((CComponent*)pComponent)->m_spConsole;
}
_ASSERTE( spConsole != NULL );
hr = spConsole->QueryInterface(IID_IConsoleNameSpace, (VOID**)(&pConsoleNameSpace) );
_ASSERT( S_OK == hr );
// This was done in MeanGene's Step 3 -- I'm guessing MMC wants this filled in
m_pPoliciesNode->m_scopeDataItem.relativeID = (HSCOPEITEM) param;
#ifndef ALWAYS_SHOW_RAP_NODE
hr = TryShow(NULL);
#else
hr = pConsoleNameSpace->InsertItem( &(m_pPoliciesNode->m_scopeDataItem) );
_ASSERT( NULL != m_pPoliciesNode->m_scopeDataItem.ID );
#endif
pConsoleNameSpace->Release(); // Don't forget to do this!
}
else // arg != TRUE so not expanding
{
// do nothing for now -- I don't think arg = FALSE is even implemented
// for MMC v. 1.0 or 1.1
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::OnRename
See CSnapinNode::OnRename (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
HRESULT CMachineNode::OnRename(
LPARAM arg
, LPARAM param
, IComponentData * pComponentData
, IComponent * pComponent
, DATA_OBJECT_TYPES type
)
{
TRACE_FUNCTION("MachineNode::OnRename");
HRESULT hr = S_FALSE;
//ISSUE: Consider moving this into base CNAPNode class or a CLeafNode class
OLECHAR * pTemp = new OLECHAR[lstrlen((OLECHAR*) param) + 1];
if ( NULL == pTemp )
{
return S_FALSE;
}
lstrcpy( pTemp, (OLECHAR*) param );
m_bstrDisplayName = pTemp;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::SetVerbs
See CSnapinNode::SetVerbs (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
HRESULT CMachineNode::SetVerbs( IConsoleVerb * pConsoleVerb )
{
TRACE_FUNCTION("CMachineNode::SetVerbs");
HRESULT hr = S_OK;
// We want the user to be able to choose Properties on this node
hr = pConsoleVerb->SetVerbState( MMC_VERB_PROPERTIES, ENABLED, TRUE );
// We want the default verb to be Properties
hr = pConsoleVerb->SetDefaultVerb( MMC_VERB_PROPERTIES );
// We want the user to be able to delete this node
hr = pConsoleVerb->SetVerbState( MMC_VERB_DELETE, ENABLED, TRUE );
// We want the user to be able to rename this node
hr = pConsoleVerb->SetVerbState( MMC_VERB_RENAME, ENABLED, TRUE );
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::GetComponentData
This method returns our unique CComponentData object representing the scope
pane of this snapin.
It relies upon the fact that each node has a pointer to its parent,
except for the root node, which instead has a member variable pointing
to CComponentData.
This would be a useful function to use if, for example, you need a reference
to some IConsole but you weren't passed one. You can use GetComponentData
and then use the IConsole pointer which is a member variable of our
CComponentData object.
--*/
//////////////////////////////////////////////////////////////////////////////
CComponentData * CMachineNode::GetComponentData( void )
{
TRACE_FUNCTION("CMachineNode::GetComponentData");
return m_pComponentData;
return NULL;
}
//+---------------------------------------------------------------------------
//
// Function: CMachineNode::InitClipboardFormat
//
// Synopsis: initialize the clipboard format that's used to pass computer name
// from the primary snap-in and extension snap-in
//
// Arguments: None
//
// Returns: Nothing
//
// History: Created Header byao 2/25/98 7:04:33 PM
//
//+---------------------------------------------------------------------------
void CMachineNode::InitClipboardFormat()
{
TRACE_FUNCTION("CMachineNode::InitClipboardFormat");
// Init a clipboard format which will allow us to exchange
// machine name information.
m_CCF_MMC_SNAPIN_MACHINE_NAME = (CLIPFORMAT) RegisterClipboardFormat(_T("MMC_SNAPIN_MACHINE_NAME"));
}
//+---------------------------------------------------------------------------
//
// Function: CMachineNode::InitDataClass
//
// Synopsis: gets passed the IDataObject sent to the extension snapin for this
// node, queries this IDataObject for the name of the machine
// which this snapin is extending
//
// Arguments: None
//
// Returns: Nothing
//
// History: Created Header mmaguire 2/25/98 9:07 PM
//
//+---------------------------------------------------------------------------
void CMachineNode::InitDataClass(IDataObject* pDataObject, CSnapInItem* pDefault)
{
TRACE_FUNCTION("CMachineNode::InitDataClass");
// Check for preconditions.
if( m_fAlreadyAnalyzedDataClass )
{
// We have already performed any work we needed to do with the dataobject here.
return;
}
if (pDataObject == NULL)
{
return;
}
HRESULT hr;
// OLECHAR szMachineName[IAS_MAX_COMPUTERNAME_LENGTH];
// Try a large size because RRAS seems to want 2048
OLECHAR szMachineName[4000];
// Fill the structures which will tell the IDataObject what information
// we want it to give us.
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { m_CCF_MMC_SNAPIN_MACHINE_NAME,
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL
};
// Allocate enough global memory for the IDataObject to write
// the max computer name length.
stgmedium.hGlobal = GlobalAlloc(0, sizeof(OLECHAR)*(IAS_MAX_COMPUTERNAME_LENGTH) );
if (stgmedium.hGlobal == NULL)
{
return;
}
// Ask the IDataObject for the computer name.
hr = pDataObject->GetDataHere(&formatetc, &stgmedium);
if (SUCCEEDED(hr))
{
// Parse the data given back to us.
// Create a stream on HGLOBAL
CComPtr<IStream> spStream;
hr = CreateStreamOnHGlobal(stgmedium.hGlobal, FALSE, &spStream);
if (SUCCEEDED(hr))
{
// Read from the stream.
unsigned long uWritten;
hr = spStream->Read(szMachineName, sizeof(OLECHAR)*(IAS_MAX_COMPUTERNAME_LENGTH), &uWritten);
if( SUCCEEDED(hr) )
{
m_bstrServerAddress = szMachineName;
// check to see if we are configuring the local machine
CString strLocalMachine;
DWORD dwSize = MAX_COMPUTERNAME_LENGTH;
::GetComputerName(strLocalMachine.GetBuffer(dwSize), &dwSize);
strLocalMachine.ReleaseBuffer();
// If the machine name we read was either an empty string,
// or it equals the name of the current computer,
// then we are configuring the local machine.
if ( ! szMachineName[0] || strLocalMachine.CompareNoCase(szMachineName) == 0)
{
m_bConfigureLocal = TRUE;
}
else
m_bConfigureLocal = FALSE;
}
else
{
ShowErrorDialog( NULL, USE_DEFAULT, NULL, S_OK, USE_DEFAULT, GetComponentData()->m_spConsole );
}
}
}
GlobalFree(stgmedium.hGlobal);
if( SUCCEEDED( hr ) )
{
// If we made it to here with an successful HRESULT, we have successfully analyzed
// the IDataObject and we set this flag so that we don't do this work again.
m_fAlreadyAnalyzedDataClass = TRUE;
}
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::TaskNotify
See CSnapinNode::TaskNotify (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CMachineNode::TaskNotify(
IDataObject * pDataObject
, VARIANT * pvarg
, VARIANT * pvparam
)
{
TRACE_FUNCTION("CMachineNode::TaskNotify");
// Check for preconditions:
// None.
if ( !m_fSdoConnected )
{
return S_OK;
}
HRESULT hr = S_FALSE;
if (pvarg->vt == VT_I4)
{
switch (pvarg->lVal)
{
case MACHINE_TASK__DEFINE_NETWORK_ACCESS_POLICY:
hr = OnTaskPadDefineNetworkAccessPolicy( pDataObject, pvarg, pvparam );
break;
default:
break;
}
}
// ISSUE: What should I be returning here?
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::EnumTasks
See CSnapinNode::EnumTasks (which this method overrides) for detailed info.
--*/
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CMachineNode::EnumTasks(
IDataObject * pDataObject
, BSTR szTaskGroup
, IEnumTASK** ppEnumTASK
)
{
TRACE_FUNCTION("CMachineNode::EnumTasks");
// Check for preconditions:
// None.
if ( !m_fSdoConnected )
{
return S_OK;
}
HRESULT hr = S_OK;
CMachineEnumTask * pMachineEnumTask = new CMachineEnumTask( this );
if ( pMachineEnumTask == NULL )
{
hr = E_OUTOFMEMORY;
}
else
{
// Make sure release works properly on failure.
pMachineEnumTask ->AddRef ();
hr = pMachineEnumTask ->Init( pDataObject, szTaskGroup);
if( hr == S_OK )
{
hr = pMachineEnumTask->QueryInterface( IID_IEnumTASK, (void **)ppEnumTASK );
}
pMachineEnumTask->Release();
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::OnTaskPadDefineNetworkAccessPolicy
Respond to the Define Network Access Policy taskpad command.
--*/
//////////////////////////////////////////////////////////////////////////////
HRESULT CMachineNode::OnTaskPadDefineNetworkAccessPolicy(
IDataObject * pDataObject
, VARIANT * pvarg
, VARIANT * pvparam
)
{
TRACE_FUNCTION("CMachineNode::OnTaskPadDefineNetworkAccessPolicy");
// Check for preconditions:
// None.
if ( !m_fSdoConnected )
{
return S_OK;
}
HRESULT hr = S_OK ;
bool bDummy = TRUE;
// Simulate a call to the OnNewPolicy message on the CPoliciesNode object,
// just as if the user had clicked on New Policy
_ASSERTE( m_pPoliciesNode != NULL );
// The process command message will need a pointer to CSnapInObjectRoot
CComponentData *pComponentData = GetComponentData();
_ASSERTE( pComponentData != NULL );
hr = m_pPoliciesNode->OnNewPolicy(
bDummy // Not needed.
, (CSnapInObjectRootBase *) pComponentData
);
return hr;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CMachineNode::BeginConnectAction
--*/
//////////////////////////////////////////////////////////////////////////////
HRESULT CMachineNode::BeginConnectAction( void )
{
TRACE_FUNCTION("CMachineNode::BeginConnectAction");
HRESULT hr;
if( NULL != m_pConnectionToServer )
{
// Already begun.
return S_FALSE;
}
m_pConnectionToServer = new CConnectionToServer(
this,
m_bstrServerAddress,
m_enumExtendedSnapin == INTERNET_AUTHENTICATION_SERVICE_SNAPIN
);
if( NULL == m_pConnectionToServer )
{
ShowErrorDialog( NULL, IDS_ERROR_CANT_CREATE_OBJECT, NULL, S_OK, USE_DEFAULT, GetComponentData()->m_spConsole );
return E_OUTOFMEMORY;
}
m_pConnectionToServer->AddRef();
// This starts the connect action off in another thread.
CComponentData * pComponentData = GetComponentData();
_ASSERTE( pComponentData != NULL );
_ASSERTE( pComponentData->m_spConsole != NULL );
HWND hWndMainWindow;
hr = pComponentData->m_spConsole->GetMainWindow( &hWndMainWindow );
_ASSERTE( SUCCEEDED( hr ) );
_ASSERTE( NULL != hWndMainWindow );
// This modeless dialog will take care of calling InitSdoPointers
// when it is notified by the worker thread it creates that
// the connect action got an SDO pointer.
HWND hWndConnectDialog = m_pConnectionToServer->Create( hWndMainWindow );
if( NULL == hWndConnectDialog )
{
// Error -- couldn't create window.
ShowErrorDialog( NULL, USE_DEFAULT, NULL, S_OK, USE_DEFAULT, GetComponentData()->m_spConsole );
return E_FAIL;
}
if ( m_enumExtendedSnapin != INTERNET_AUTHENTICATION_SERVICE_SNAPIN )
{
//
// don't show the "Connecting ... " window for IAS, because IAS UI
// already does that
//
// MAM 07/27/98 -- Don't show any connection window at all -- we will
// change the policies icon to an hourglass.
//pConnectionToServer->ShowWindow(SW_SHOW);
}
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: CMachineNode::LoadSdoData
//
// Synopsis: load data from SDO
//
// Arguments: BOOL fDSAvailable -- is DS service available for this machine?
//
// Returns: HRESULT -
//
// History: Created Header byao 6/11/98 3:17:21 PM
// Created for asynchrnous connect call
//+---------------------------------------------------------------------------
HRESULT CMachineNode::LoadSdoData(BOOL fDSAvailable)
{
TRACE_FUNCTION("CMachineNode::LoadSdoData");
HRESULT hr = S_OK;
m_fDSAvailable = fDSAvailable;
// Retrieve the SDO interfaces that we obtained during the
// connect action.
// No smart pointers here -- prevents needless AddRefing and Releasing.
ISdo* pSdoService;
hr = m_pConnectionToServer->GetSdoService( &pSdoService );
if( FAILED( hr ) || ! pSdoService )
{
ErrorTrace(ERROR_NAPMMC_MACHINENODE, "Can't get service Sdo");
return hr;
}
ISdoDictionaryOld * pSdoDictionaryOld;
hr = m_pConnectionToServer->GetSdoDictionaryOld( &pSdoDictionaryOld );
if( FAILED( hr ) || ! pSdoDictionaryOld )
{
ErrorTrace(ERROR_NAPMMC_MACHINENODE, "Can't get dictionary Sdo");
return hr;
}
#ifdef STORE_DATA_IN_DIRECTORY_SERVICE
//
// Is the server using Active Directory or the local machine?
//
CComVariant var;
hr = spMachineSdo->GetProperty(PROPERTY_SERVER_USE_ACTIVE_DIRECTORY, &var);
if ( FAILED(hr) )
{
ErrorTrace(ERROR_NAPMMC_MACHINENODE, "Can't get Server_Use_Active_Directory property, err = %x", hr);
return hr;
}
_ASSERTE( V_VT(&var) == VT_BOOL );
m_fUseActiveDirectory = (V_BOOL(&var)==VARIANT_TRUE);
#endif // STORE_DATA_IN_DIRECTORY_SERVICE
// Give the policies node the pointer to the policies sdo collection.
if ( m_pPoliciesNode )
{
hr = m_pPoliciesNode->SetSdo(pSdoService,
pSdoDictionaryOld,
TRUE, // fSdoConnected,
m_fUseActiveDirectory,
m_fDSAvailable // fDSAvailable,
);
}
m_fSdoConnected = TRUE;
// We want to make sure all views get updated.
CChangeNotification *pChangeNotification = new CChangeNotification();
pChangeNotification->m_dwFlags = CHANGE_UPDATE_CHILDREN_OF_SELECTED_NODE;
hr = GetComponentData()->m_spConsole->UpdateAllViews( NULL, (LPARAM) pChangeNotification, 0);
pChangeNotification->Release();
return hr;
}
Reference in a new issue Copy permalink