////////////////////////////////////////////////////////////////////////////// /*++ 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::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 spConsole; CComPtr 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( 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 spSdo; CComPtr 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 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 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; }