able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/dfsadmin/dfsgui/mmcroot.cpp

2757 lines
76 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Module Name:
MmcRoot.cpp
Abstract:
This module contains the implementation for CMmcDfsRoot. This is an class
for MMC display related calls for the first level node(the DfsRoot nodes)
Also contains members and method to be able to manipulate IDfsRoot object
and add the same to the MMC Console
--*/
#include "stdafx.h"
#include <winuser.h>
#include "DfsGUI.h"
#include "Utils.h" // For the LoadStringFromResource method
#include "MenuEnum.h" // Contains the menu and toolbar command ids
#include "resource.h" // For the Resource ID for strings, etc.
#include "MmcAdmin.h" // For class CMmcDfsAdmin
#include "MmcRoot.h"
#include "MmcJP.h" // For deleteing the child Junction points in the destructor of the root object
#include "MmcRep.h"
#include "DfsEnums.h" // For DFS_TYPE_STANDALONE and other DfsRoot declarations
#include "AddToDfs.h"
#include "LinkFilt.h"
#include "DfsNodes.h" // For Node GUIDs
#include "DfsWiz.h" // For the wizard pages, CCreateDfsRootWizPage1, 2, ...
#include <lmdfs.h>
#include "permpage.h"
#include "ldaputils.h"
const int CMmcDfsRoot::m_iIMAGEINDEX = 0;
const int CMmcDfsRoot::m_iOPENIMAGEINDEX = 0;
//////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor For _JUNCTION_LIST
JP_LIST_NODE :: JP_LIST_NODE (CMmcDfsJunctionPoint* i_pMmcJP)
{
pJPoint = i_pMmcJP;
}
//////////////////////////////////////////////////////////////////////////////////////////////////
// destructor
JP_LIST_NODE :: ~JP_LIST_NODE ()
{
SAFE_RELEASE(pJPoint);
}
CMmcDfsRoot::CMmcDfsRoot(
IN IDfsRoot* i_pDfsRoot,
IN CMmcDfsAdmin* i_pMmcDfsAdmin,
IN LPCONSOLE2 i_lpConsole,
IN ULONG i_ulLinkFilterMaxLimit, // = FILTERDFSLINKS_MAXLIMIT_DEFAULT,
IN FILTERDFSLINKS_TYPE i_lLinkFilterType, // = FILTERDFSLINKS_TYPE_NO_FILTER,
IN BSTR i_bstrLinkFilterName // = NULL
)
{
dfsDebugOut((_T("CMmcDfsRoot::CMmcDfsRoot this=%p\n"), this));
MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pDfsRoot);
MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pMmcDfsAdmin);
MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_lpConsole);
HRESULT hr = S_OK;
m_DfsRoot = i_pDfsRoot; // Save the IDfsRoot pointer
m_pParent = i_pMmcDfsAdmin; // Save the parent pointer
m_lpConsole = i_lpConsole; // Save the console pointer
hr = m_DfsRoot->get_RootEntryPath(&m_bstrRootEntryPath); // Get the Root entrypath.
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
hr = m_DfsRoot->get_DfsType((long *)&m_lDfsRootType); // Get dfsroot type from the IDfsRoot
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
if (DFS_TYPE_FTDFS == m_lDfsRootType)
{
CComBSTR bstrDomainName;
CComBSTR bstrDfsName;
hr = m_DfsRoot->get_DomainName(&bstrDomainName);
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
hr = m_DfsRoot->get_DfsName(&bstrDfsName);
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
hr = GetDfsRootDisplayName(bstrDomainName, bstrDfsName, &m_bstrDisplayName);
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
m_bNewSchema = (S_OK == GetSchemaVersionEx(bstrDomainName, FALSE));
} else
{
m_bstrDisplayName = m_bstrRootEntryPath;
MMC_DISP_CTOR_RETURN_OUTOFMEMORY_IF_NULL((BSTR)m_bstrDisplayName);
CComBSTR bstrServer, bstrShare;
hr = m_DfsRoot->GetOneDfsHost(&bstrServer, &bstrShare);
MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
m_bNewSchema = (S_OK == GetSchemaVersionEx(bstrServer));
}
m_lpConsoleNameSpace = NULL;
m_CLSIDNodeType = s_guidDfsRootNodeType;
m_bstrDNodeType = s_tchDfsRootNodeType;
m_lRootJunctionState = DFS_JUNCTION_STATE_UNASSIGNED;
m_ulLinkFilterMaxLimit = i_ulLinkFilterMaxLimit;
m_lLinkFilterType = i_lLinkFilterType;
if (i_bstrLinkFilterName)
m_bstrLinkFilterName = i_bstrLinkFilterName;
else
m_bstrLinkFilterName.Empty();
m_bShowFRS = FALSE;
}
CMmcDfsRoot::~CMmcDfsRoot(
)
{
// Silently close all outstanding property sheets.
CloseAllPropertySheets(TRUE);
// Clean up display objects of children and result pane.
CleanScopeChildren();
CleanResultChildren();
if ((IReplicaSet *)m_piReplicaSet)
m_piReplicaSet.Release();
dfsDebugOut((_T("CMmcDfsRoot::~CMmcDfsRoot this=%p\n"), this));
}
STDMETHODIMP
CMmcDfsRoot::AddItemToScopePane(
IN LPCONSOLENAMESPACE i_lpConsoleNameSpace,
IN HSCOPEITEM i_hItemParent
)
/*++
Routine Description:
This routine adds the current item(itself) to the Scope pane.
Arguments:
lpConsoleNameSpace - The interface which tells add item to the scope pane. A callback
hItemParent - The handle of the parent. The current item is added as this
item's child
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpConsoleNameSpace);
RETURN_INVALIDARG_IF_NULL(i_hItemParent);
HRESULT hr = S_OK;
BOOL bReplicaSetExist = FALSE;
hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
if (SUCCEEDED(hr))
{
SCOPEDATAITEM ScopeItemDfsRoot;
ZeroMemory(&ScopeItemDfsRoot, sizeof(ScopeItemDfsRoot));
ScopeItemDfsRoot.mask = SDI_IMAGE | SDI_OPENIMAGE | SDI_PARAM | SDI_STR | SDI_PARENT;
ScopeItemDfsRoot.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
ScopeItemDfsRoot.nOpenImage = CMmcDfsRoot::m_iOPENIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
ScopeItemDfsRoot.lParam = reinterpret_cast<LPARAM>(this);
ScopeItemDfsRoot.displayname = (unsigned short *) MMC_CALLBACK;
ScopeItemDfsRoot.relativeID = i_hItemParent;
hr = i_lpConsoleNameSpace->InsertItem(&ScopeItemDfsRoot);
RETURN_IF_FAILED(hr);
m_hScopeItem = ScopeItemDfsRoot.ID;
m_lpConsoleNameSpace = i_lpConsoleNameSpace;
}
return S_OK;
}
STDMETHODIMP
CMmcDfsRoot::AddMenuItems(
IN LPCONTEXTMENUCALLBACK i_lpContextMenuCallback,
IN LPLONG i_lpInsertionAllowed
)
/*++
Routine Description:
This routine adds a context menu using the ContextMenuCallback provided.
Arguments:
lpContextMenuCallback - A callback(function pointer) that is used to add the menu items
lpInsertionAllowed - Specifies what menus can be added and where they can be added.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpContextMenuCallback);
// select the node to populate m_MmcRepList
m_lpConsole->SelectScopeItem(m_hScopeItem);
enum
{
IDM_CONTEXTMENU_COMMAND_MAX = IDM_ROOT_MAX,
IDM_CONTEXTMENU_COMMAND_MIN = IDM_ROOT_MIN
};
LONG lInsertionPoints [IDM_CONTEXTMENU_COMMAND_MAX - IDM_CONTEXTMENU_COMMAND_MIN + 1] = {
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
CCM_INSERTIONPOINTID_PRIMARY_TOP
};
BOOL bReplicaSetExist = FALSE;
HRESULT hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
RETURN_IF_FAILED(hr);
for (int iCommandID = IDM_CONTEXTMENU_COMMAND_MIN,iMenuResource = IDS_MENUS_ROOT_TOP_NEW_DFS_LINK;
iCommandID <= IDM_CONTEXTMENU_COMMAND_MAX;
iCommandID++,iMenuResource++ )
{
CONTEXTMENUITEM ContextMenuItem; // The structure which contains menu information
ZeroMemory(&ContextMenuItem, sizeof(ContextMenuItem));
switch (iCommandID)
{
case IDM_ROOT_TOP_NEW_ROOT_REPLICA:
{
if (DFS_TYPE_STANDALONE == m_lDfsRootType)
continue;
break;
}
case IDM_ROOT_TOP_DELETE_DISPLAYED_DFS_LINKS:
{
if (m_MmcJPList.empty())
continue;
break;
}
case IDM_ROOT_TOP_REPLICATION_TOPOLOGY:
{
if (bReplicaSetExist || (1 >= m_MmcRepList.size()) || (DFS_TYPE_STANDALONE == m_lDfsRootType))
continue;
break;
}
case IDM_ROOT_TOP_SHOW_REPLICATION:
{
if (!bReplicaSetExist || m_bShowFRS)
continue;
break;
}
case IDM_ROOT_TOP_HIDE_REPLICATION:
{
if (!bReplicaSetExist || !m_bShowFRS)
continue;
break;
}
case IDM_ROOT_TOP_STOP_REPLICATION:
{
if (!bReplicaSetExist)
continue;
break;
}
case IDM_ROOT_TOP_NEW_DFS_LINK:
case IDM_ROOT_TOP_CHECK_STATUS:
case IDM_ROOT_TOP_FILTER_DFS_LINKS:
{ // excluded when empty root container
if (m_MmcRepList.empty())
continue;
break;
}
}
CComBSTR bstrMenuText;
CComBSTR bstrStatusBarText;
hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, NULL, &bstrStatusBarText);
RETURN_IF_FAILED(hr);
ContextMenuItem.strName = bstrMenuText; // Assign the menu text
ContextMenuItem.strStatusBarText = bstrStatusBarText; // Assign the menu help text
ContextMenuItem.lInsertionPointID = lInsertionPoints[iCommandID - IDM_CONTEXTMENU_COMMAND_MIN];
ContextMenuItem.lCommandID = iCommandID;
LONG lInsertionFlag = 0;
switch(ContextMenuItem.lInsertionPointID) // Checking for permission to add menus
{
case CCM_INSERTIONPOINTID_PRIMARY_TOP:
lInsertionFlag = CCM_INSERTIONALLOWED_TOP;
break;
case CCM_INSERTIONPOINTID_PRIMARY_NEW:
lInsertionFlag = CCM_INSERTIONALLOWED_NEW;
break;
case CCM_INSERTIONPOINTID_PRIMARY_TASK:
lInsertionFlag = CCM_INSERTIONALLOWED_TASK;
break;
case CCM_INSERTIONPOINTID_PRIMARY_VIEW:
lInsertionFlag = CCM_INSERTIONALLOWED_VIEW;
break;
default:
break;
}
if (*i_lpInsertionAllowed & lInsertionFlag)
{
hr = i_lpContextMenuCallback->AddItem(&ContextMenuItem);
RETURN_IF_FAILED(hr);
}
} // for
return hr;
}
STDMETHODIMP
CMmcDfsRoot::GetScopeDisplayInfo(
IN OUT LPSCOPEDATAITEM io_pScopeDataItem
)
/*++
Routine Description:
Returns the information required for MMC display for this item.
Arguments:
i_pScopeDataItem - The ScopeItem which specifies what display information is required
--*/
{
RETURN_INVALIDARG_IF_NULL(io_pScopeDataItem);
HRESULT hr = S_OK;
if (SDI_STR & io_pScopeDataItem->mask) // MMC wants the displaystring
{
ULONG ulTotalNumOfJPs = 0;
hr = m_DfsRoot->get_CountOfDfsJunctionPoints((long*)&ulTotalNumOfJPs);
RETURN_IF_FAILED(hr);
if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER ||
m_MmcJPList.size() < ulTotalNumOfJPs)
{
m_bstrFullDisplayName.Empty();
hr = FormatMessageString(&m_bstrFullDisplayName,
0,
IDS_DFSROOT_DISPLAY_STRING,
m_bstrDisplayName);
RETURN_IF_FAILED(hr);
io_pScopeDataItem->displayname = m_bstrFullDisplayName;
} else
{
io_pScopeDataItem->displayname = m_bstrDisplayName;
}
}
if (SDI_IMAGE & io_pScopeDataItem->mask) // MMC wants the image index for the item
io_pScopeDataItem->nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;
if (SDI_OPENIMAGE & io_pScopeDataItem->mask) // MMC wants the image index for the item
io_pScopeDataItem->nOpenImage = CMmcDfsRoot::m_iOPENIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;
return hr;
}
STDMETHODIMP
CMmcDfsRoot::GetResultDisplayInfo(
IN OUT LPRESULTDATAITEM io_pResultDataItem
)
/*++
Routine Description:
Returns the information required for MMC display for this item.
Arguments:
io_pResultDataItem - The ResultItem which specifies what display information is required
--*/
{
RETURN_INVALIDARG_IF_NULL(io_pResultDataItem);
if (RDI_IMAGE & io_pResultDataItem->mask) // MMC wants the image index for the item
io_pResultDataItem->nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + m_lRootJunctionState;
if (RDI_STR & io_pResultDataItem->mask) // MMC wants the text for the item
{
if (0 == io_pResultDataItem->nCol) // Return the Dfs Root display name
io_pResultDataItem->str = m_bstrDisplayName;
}
return S_OK;
}
STDMETHODIMP
CMmcDfsRoot::Command(
IN LONG i_lCommandID
)
/*++
Routine Description:
Action to be taken on a context menu selection or click is takes place.
Arguments:
lCommandID - The Command ID of the menu for which action has to be taken
--*/
{
HRESULT hr = S_OK;
switch (i_lCommandID)
{
case IDM_ROOT_TOP_NEW_DFS_LINK:
hr = OnCreateNewJunctionPoint ();
break;
case IDM_ROOT_TOP_NEW_ROOT_REPLICA:
hr = OnNewRootReplica();
break;
case IDM_ROOT_TOP_CHECK_STATUS:
hr = OnCheckStatus();
break;
case IDM_ROOT_TOP_DELETE_DISPLAYED_DFS_LINKS:
hr = OnDeleteDisplayedDfsLinks();
break;
case IDM_ROOT_TOP_DELETE_DFS_ROOT: // Delete the Current dfs root
hr = OnDeleteDfsRoot();
break;
case IDM_ROOT_TOP_DELETE_CONNECTION_TO_DFS_ROOT: // "Delete Connection to Dfs Root"
hr = OnDeleteConnectionToDfsRoot();
break;
case IDM_ROOT_TOP_FILTER_DFS_LINKS:
hr = OnFilterDfsLinks();
break;
case IDM_ROOT_TOP_REPLICATION_TOPOLOGY:
hr = OnNewReplicaSet();
break;
case IDM_ROOT_TOP_SHOW_REPLICATION:
case IDM_ROOT_TOP_HIDE_REPLICATION:
m_bShowFRS = !m_bShowFRS;
hr = OnShowReplication();
break;
case IDM_ROOT_TOP_STOP_REPLICATION:
hr = OnStopReplication(TRUE);
if (FAILED(hr))
DisplayMessageBoxForHR(hr);
break;
default:
hr = E_INVALIDARG;
break;
}
return hr;
}
HRESULT CMmcDfsRoot::_InitReplicaSet()
{
HRESULT hr = S_OK;
if (m_lDfsRootType != DFS_TYPE_FTDFS)
return S_FALSE; // no replica set associate with standalone root
BOOL bReplicaSetExist = FALSE;
CComBSTR bstrDC;
hr = m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);
RETURN_IF_FAILED(hr);
if (!bReplicaSetExist)
{
if ((IReplicaSet *)m_piReplicaSet)
m_piReplicaSet.Release();
return S_FALSE; // no replica set associate with it
}
if ((IReplicaSet *)m_piReplicaSet)
{
CComBSTR bstrTargetedDC;
hr = m_piReplicaSet->get_TargetedDC(&bstrTargetedDC);
if (FAILED(hr) || lstrcmpi(bstrTargetedDC, bstrDC))
{
// something is wrong or we're using a different DC, re-init m_piReplicaSet
m_piReplicaSet.Release();
}
}
if (!m_piReplicaSet)
{
CComBSTR bstrDomain;
hr = m_DfsRoot->get_DomainName(&bstrDomain);
RETURN_IF_FAILED(hr);
CComBSTR bstrReplicaSetDN;
hr = m_DfsRoot->get_ReplicaSetDN(&bstrReplicaSetDN);
RETURN_IF_FAILED(hr);
//
// read info of the replica set from DS
//
hr = CoCreateInstance(CLSID_ReplicaSet, NULL, CLSCTX_INPROC_SERVER, IID_IReplicaSet, (void**) &m_piReplicaSet);
RETURN_IF_FAILED(hr);
hr = m_piReplicaSet->Initialize(bstrDomain, bstrReplicaSetDN);
if (FAILED(hr))
{
m_piReplicaSet.Release();
return hr;
}
}
return hr;
}
HRESULT CMmcDfsRoot::OnNewReplicaSet()
{
//
// refresh to pick up possible namespace updates on targets by others
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
BOOL bReplicaSetExist = FALSE;
m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
if (bReplicaSetExist) // replica set exist, return
return S_OK;
CComBSTR bstrDomain;
hr = m_DfsRoot->get_DomainName(&bstrDomain);
RETURN_IF_FAILED(hr);
CComBSTR bstrReplicaSetDN;
hr = m_DfsRoot->get_ReplicaSetDN(&bstrReplicaSetDN);
RETURN_IF_FAILED(hr);
CNewReplicaSet ReplicaSetInfo;
hr = ReplicaSetInfo.Initialize(bstrDomain, bstrReplicaSetDN, &m_MmcRepList);
RETURN_IF_FAILED(hr);
CNewReplicaSetPage0 WizPage0;
CNewReplicaSetPage1 WizPage1(&ReplicaSetInfo);
CNewReplicaSetPage2 WizPage2(&ReplicaSetInfo, IsNewSchema());
//CNewReplicaSetPage3 WizPage3(&ReplicaSetInfo);
CComPtr<IPropertySheetCallback> pPropSheetCallback; // MMC Callback used to add pages
hr = m_lpConsole->QueryInterface(IID_IPropertySheetCallback, reinterpret_cast<void**>(&pPropSheetCallback));
RETURN_IF_FAILED(hr);
CComPtr<IPropertySheetProvider> pPropSheetProvider; // MMC callback used to handle wizard
hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
RETURN_IF_FAILED(hr);
//
// Create the wizard
//
hr = pPropSheetProvider->CreatePropertySheet(
_T(""), // title
FALSE, // Wizard and not property sheet.
0, // Cookie
NULL, // IDataobject
MMC_PSO_NEWWIZARDTYPE); // Creation flags
RETURN_IF_FAILED(hr);
hr = pPropSheetCallback->AddPage(WizPage0.Create());
RETURN_IF_FAILED(hr);
hr = pPropSheetCallback->AddPage(WizPage1.Create());
RETURN_IF_FAILED(hr);
hr = pPropSheetCallback->AddPage(WizPage2.Create());
RETURN_IF_FAILED(hr);
/*hr = pPropSheetCallback->AddPage(WizPage3.Create());
RETURN_IF_FAILED(hr); */
// Ask the provider to use the pages from the callback
hr = pPropSheetProvider->AddPrimaryPages(
//(IComponentData *)(m_pParent->m_pScopeManager),
NULL,
TRUE, // Don't create a notify handle
NULL,
TRUE // Scope pane (not result pane)
);
RETURN_IF_FAILED(hr);
//
// Display the wizard
//
HWND hwndParent = NULL;
hr = m_lpConsole->GetMainWindow(&hwndParent);
RETURN_IF_FAILED(hr);
hr = pPropSheetProvider->Show((LONG_PTR)hwndParent, 0);
RETURN_IF_FAILED(hr);
//
// handle th result
//
if (S_OK == ReplicaSetInfo.m_hr)
{
//
// store the interface pointer
//
m_piReplicaSet = ReplicaSetInfo.m_piReplicaSet;
m_DfsRoot->put_ReplicaSetExist(TRUE);
//
// update icon
//
SCOPEDATAITEM ScopeDataItem;
ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
ScopeDataItem.ID = m_hScopeItem;
hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
RETURN_IF_FAILED(hr);
if (SUCCEEDED(hr))
{
ScopeDataItem.nImage += 4;
ScopeDataItem.nOpenImage += 4;
hr = m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
}
m_lpConsole->SelectScopeItem(m_hScopeItem);
}
return hr;
}
HRESULT CMmcDfsRoot::OnShowReplication()
{
BOOL bShowFRS = m_bShowFRS; // save it because refresh will reset it to FALSE
//
// refresh to pick up possible namespace updates on targets by others
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
DFS_REPLICA_LIST::iterator i;
if (bShowFRS)
{
//
// init m_piReplicaSet
//
hr = _InitReplicaSet();
if (S_OK != hr) // no replica set, do nothing and return
return S_OK;
//
// fill in each alternate m_bstrFRSColumnText and m_bstrStatusText
//
for (i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
((*i)->pReplica)->ShowReplicationInfo(m_piReplicaSet);
}
m_bShowFRS = TRUE;
}
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
m_lpConsole->SelectScopeItem(m_hScopeItem);
return hr;
}
HRESULT
CMmcDfsRoot::OnStopReplication(BOOL bConfirm /* = FALSE */)
{
//
// refresh to pick up possible namespace updates on targets by others
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
BOOL bReplicaSetExist = FALSE;
m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
if (!bReplicaSetExist) // replica set doesn't exist, return
return S_OK;
if (bConfirm)
{
hr = ConfirmOperationOnDfsRoot(IDS_MSG_STOP_REPLICATION);
if (S_OK != hr) return hr;
}
//
// init m_piReplicaSet
//
hr = _InitReplicaSet();
if (S_OK != hr) // no replica set, return
return hr;
hr = m_piReplicaSet->Delete();
if (SUCCEEDED(hr))
{
m_piReplicaSet.Release();
hr = m_DfsRoot->put_ReplicaSetExist(FALSE);
SCOPEDATAITEM ScopeDataItem;
ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
ScopeDataItem.ID = m_hScopeItem;
hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
if (SUCCEEDED(hr))
{
ScopeDataItem.nImage -= 4;
ScopeDataItem.nOpenImage -= 4;
(void) m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
}
m_lpConsole->SelectScopeItem(m_hScopeItem);
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot::OnNewRootReplica(
)
/*++
Routine Description:
Action to be taken on menu command "New Root Replica Member".
Here is a wizard is used to guide the user through the process of
Deciding a new server and share.
--*/
{
// Select this node to make sure m_MmcRepList populated
m_lpConsole->SelectScopeItem(m_hScopeItem);
RETURN_INVALIDARG_IF_NULL((IConsole*)m_lpConsole);
CREATEDFSROOTWIZINFO CreateWizInfo; // 0 initializes all members to 0. Necessary
CreateWizInfo.pMMCAdmin = m_pParent;
CreateWizInfo.bRootReplica = true; // Set the flag that says this is for root replica
// Set the domain name and the dfs type
HRESULT hr = m_DfsRoot->get_DomainName(&CreateWizInfo.bstrSelectedDomain);
RETURN_IF_FAILED(hr);
CreateWizInfo.DfsType = DFS_TYPE_FTDFS;
hr = m_DfsRoot->get_DfsName(&CreateWizInfo.bstrDfsRootName);
RETURN_IF_FAILED(hr);
CCreateDfsRootWizPage4 WizPage4(&CreateWizInfo);
CCreateDfsRootWizPage5 WizPage5(&CreateWizInfo);
CCreateDfsRootWizPage7 WizPage7(&CreateWizInfo);
// Get the required interfaces from IConsole2.
CComPtr<IPropertySheetCallback> pPropSheetCallback; // MMC Callback used to add pages
hr = m_lpConsole->QueryInterface(IID_IPropertySheetCallback, reinterpret_cast<void**>(&pPropSheetCallback));
RETURN_IF_FAILED(hr);
CComPtr<IPropertySheetProvider> pPropSheetProvider; // MMC callback used to handle wizard
hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
RETURN_IF_FAILED(hr);
// Create the wizard
hr = pPropSheetProvider->CreatePropertySheet(
_T(""), // Property sheet title. Should not be null so send empty string.
FALSE, // Wizard and not property sheet.
0, // Cookie
NULL, // IDataobject
MMC_PSO_NEWWIZARDTYPE); // Creation flags
RETURN_IF_FAILED(hr);
// Create the pages for the wizard. Use the handle return to add to our wizard
hr = pPropSheetCallback->AddPage(WizPage4.Create());
RETURN_IF_FAILED(hr);
hr = pPropSheetCallback->AddPage(WizPage5.Create());
RETURN_IF_FAILED(hr);
hr = pPropSheetCallback->AddPage(WizPage7.Create());
RETURN_IF_FAILED(hr);
_ASSERT(NULL != (m_pParent->m_pScopeManager));
// Ask the provider to use the pages from the callback
hr = pPropSheetProvider->AddPrimaryPages( (IComponentData *)(m_pParent->m_pScopeManager),
TRUE, // Don't create a notify handle
NULL,
TRUE // Scope pane (not result pane)
);
RETURN_IF_FAILED(hr);
HWND hwndMainWin = 0; // MMC main window. Used to make it modal
hr = m_lpConsole->GetMainWindow(&hwndMainWin); // Get the main MMC window
RETURN_IF_FAILED(hr);
// Display the wizard
hr = pPropSheetProvider->Show((LONG_PTR)hwndMainWin, // Parent window of the wizard
0 // Starting page
);
RETURN_IF_FAILED(hr);
if (CreateWizInfo.bDfsSetupSuccess)
{
return OnRefresh(); // to pick the most recent root targets and links
}
return (S_OK);
}
STDMETHODIMP
CMmcDfsRoot::SetColumnHeader(
IN LPHEADERCTRL2 i_piHeaderControl
)
{
RETURN_INVALIDARG_IF_NULL(i_piHeaderControl);
CComBSTR bstrColumn0;
HRESULT hr = LoadStringFromResource(IDS_RESULT_COLUMN_ROOTREPLICA, &bstrColumn0);
RETURN_IF_FAILED(hr);
i_piHeaderControl->InsertColumn(0, bstrColumn0, LVCFMT_LEFT, DFS_NAME_COLUMN_WIDTH);
if (m_bShowFRS)
{
CComBSTR bstrColumn1;
hr = LoadStringFromResource(IDS_RESULT_COLUMN_FRS, &bstrColumn1);
RETURN_IF_FAILED(hr);
i_piHeaderControl->InsertColumn(1, bstrColumn1, LVCFMT_LEFT, MMCLV_AUTO);
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot::OnDeleteConnectionToDfsRoot(
BOOLEAN i_bForRemoveDfs
)
/*++
Routine Description:
Used to delete the current object. Both to remove from Scope and from list
--*/
{
// check outstanding property sheet, discontinue if any.
HRESULT hr = CloseAllPropertySheets(FALSE);
if (S_OK != hr)
return hr;
// Confirm with the user, if he wants to delete this connection
hr = ConfirmOperationOnDfsRoot(i_bForRemoveDfs ? IDS_MSG_DELETE_DFSROOT : IDS_MSG_DELETE_CONNECTION_TO_DFSROOT);
if (S_OK != hr) return hr;
// select the root node
m_lpConsole->SelectScopeItem(m_hScopeItem);
CWaitCursor wait;
CleanScopeChildren();
// Delete the item from Scope Pane
hr = m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);
RETURN_IF_FAILED(hr);
// Delete it from the internal list
hr = m_pParent->DeleteMmcRootNode(this);
RETURN_IF_FAILED(hr);
Release(); // delete this CMmcDfsRoot object
return S_OK;
}
// Delete the node from m_MmcJPList
STDMETHODIMP
CMmcDfsRoot::DeleteMmcJPNode(
IN CMmcDfsJunctionPoint* i_pJPoint
)
{
RETURN_INVALIDARG_IF_NULL(i_pJPoint);
dfsDebugOut((_T("CMmcDfsRoot::DeleteMmcJPNode %p, size=%d\n"), i_pJPoint, m_MmcJPList.size()));
for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
{
if ((*i)->pJPoint == i_pJPoint)
{
m_MmcJPList.erase(i);
break;
}
}
return(S_OK);
}
HRESULT
CMmcDfsRoot::ConfirmOperationOnDfsRoot(int idString)
/*++
Routine Description:
Used to confirm with the user, if he wants to delete the connection to the Dfs Root
Return value:
S_OK, if the user wants to delete.
S_FALSE, if the user decided not to continue with the operation.
--*/
{
// Confirm delete operation
CComBSTR bstrAppName;
HRESULT hr = LoadStringFromResource(IDS_APPLICATION_NAME, &bstrAppName);
RETURN_IF_FAILED(hr);
CComBSTR bstrFormattedMessage;
hr = FormatResourceString(idString, m_bstrDisplayName, &bstrFormattedMessage);
RETURN_IF_FAILED(hr);
// Return now, if the user doesn't want to continue
CThemeContextActivator activator;
if (IDYES != ::MessageBox(::GetActiveWindow(), bstrFormattedMessage, bstrAppName, MB_YESNO | MB_ICONEXCLAMATION | MB_APPLMODAL))
{
return S_FALSE;
}
return S_OK;
}
HRESULT
CMmcDfsRoot::ConfirmDeleteDisplayedDfsLinks(
)
{
// Confirm delete operation
CComBSTR bstrAppName;
HRESULT hr = LoadStringFromResource(IDS_APPLICATION_NAME, &bstrAppName);
RETURN_IF_FAILED(hr);
CComBSTR bstrMessage;
hr = LoadStringFromResource(IDS_MSG_DELETE_DISPLAYEDDFSLINKS, &bstrMessage);
RETURN_IF_FAILED(hr);
// Return now, if the user doesn't want to continue
CThemeContextActivator activator;
if (IDYES != ::MessageBox(::GetActiveWindow(), bstrMessage, bstrAppName, MB_YESNO | MB_ICONEXCLAMATION | MB_APPLMODAL))
{
return S_FALSE;
}
return S_OK;
}
STDMETHODIMP
CMmcDfsRoot::EnumerateScopePane(
IN LPCONSOLENAMESPACE i_lpConsoleNameSpace,
IN HSCOPEITEM i_hParent
)
/*++
Routine Description:
To eumerate(add) items in the scope pane. Junction points in this case
Arguments:
i_lpConsoleNameSpace - The callback used to add items to the Scope pane
i_hParent - HSCOPEITEM of the parent under which all the items will be added.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpConsoleNameSpace);
RETURN_INVALIDARG_IF_NULL(i_hParent);
HRESULT hr = m_DfsRoot->put_EnumFilterType(m_lLinkFilterType);
RETURN_IF_FAILED(hr);
if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
{
hr = m_DfsRoot->put_EnumFilter(m_bstrLinkFilterName);
RETURN_IF_FAILED(hr);
}
CComPtr<IEnumVARIANT> pJPEnum;
hr = m_DfsRoot->get__NewEnum((IUnknown**) (&pJPEnum));
RETURN_IF_FAILED(hr);
hr = m_DfsRoot->get_CountOfDfsJunctionPointsFiltered((long*)&m_ulCountOfDfsJunctionPointsFiltered);
RETURN_IF_FAILED(hr);
VARIANT varJPObject;
VariantInit(&varJPObject);
ULONG ulCount = 0;
while ( ulCount < m_ulLinkFilterMaxLimit && S_OK == (hr = pJPEnum->Next(1, &varJPObject, NULL)) )
{
CComPtr<IDfsJunctionPoint> pDfsJPObject;
pDfsJPObject = (IDfsJunctionPoint*) varJPObject.pdispVal;
// Create the object to be used for MMC display
CMmcDfsJunctionPoint* pMMCJPObject = new CMmcDfsJunctionPoint (pDfsJPObject, this, i_lpConsoleNameSpace);
if (!pMMCJPObject)
{
hr = E_OUTOFMEMORY;
} else
{
hr = pMMCJPObject->m_hrValueFromCtor;
if (SUCCEEDED(hr))
hr = pMMCJPObject->AddItemToScopePane(i_hParent);
if (SUCCEEDED(hr))
{
JP_LIST_NODE *pJPList = new JP_LIST_NODE (pMMCJPObject);
if (!pJPList)
hr = E_OUTOFMEMORY;
else
m_MmcJPList.push_back(pJPList);
}
if (FAILED(hr))
delete pMMCJPObject;
}
VariantClear(&varJPObject);
if (FAILED(hr))
break;
ulCount++;
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot::SetConsoleVerbs(
IN LPCONSOLEVERB i_lpConsoleVerb
)
/*++
Routine Description:
Routine used to set the console verb settings.
Sets all of them except Open off.
For all scope pane items, default verb is "open'. For result items,
it is "properties"
Arguments:
i_lpConsoleVerb - The callback used to handle console verbs
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpConsoleVerb);
i_lpConsoleVerb->SetVerbState(MMC_VERB_COPY, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_PASTE, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_RENAME, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_DELETE, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_OPEN, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_REFRESH, ENABLED, TRUE);
i_lpConsoleVerb->SetDefaultVerb(MMC_VERB_OPEN); //For scope items, default verb is "open"
return S_OK;
}
STDMETHODIMP
CMmcDfsRoot :: OnCreateNewJunctionPoint(
)
/*++
Routine Description:
This method handles the creation of new Junction Points.
Display a dialog box to get the user input.
--*/
{
CAddToDfs AddToDfsDlg; //Add To Dfs Dialog Object
HRESULT hr = AddToDfsDlg.put_ParentPath(m_bstrRootEntryPath);
RETURN_IF_FAILED(hr);
hr = AddToDfsDlg.DoModal(); // Display the dialog box
RETURN_IF_NOT_S_OK(hr);
hr = OnRefresh();
if (S_FALSE == hr)
{
//
// this root has been deleted by other means, scope pane has been refreshed,
// ask user to retry
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
CComBSTR bstrJPName;
hr = AddToDfsDlg.get_JPName(&bstrJPName);
RETURN_IF_FAILED(hr);
CComBSTR bstrServerName;
hr = AddToDfsDlg.get_Server(&bstrServerName);
RETURN_IF_FAILED(hr);
CComBSTR bstrShareName;
hr = AddToDfsDlg.get_Share(&bstrShareName);
RETURN_IF_FAILED(hr);
CComBSTR bstrComment;
hr = AddToDfsDlg.get_Comment(&bstrComment);
RETURN_IF_FAILED(hr);
long lTimeout = 0;
hr = AddToDfsDlg.get_Time(&lTimeout);
RETURN_IF_FAILED(hr);
/* we allow interlink at the junction level
// Is it a Dfs based path? These are not allowed.
if (IsDfsPath(bstrSharePath))
{
DisplayMessageBoxWithOK(IDS_MSG_MID_JUNCTION, bstrSharePath);
return(S_OK);
}
*/
hr = OnCreateNewJunctionPoint(bstrJPName, bstrServerName, bstrShareName, bstrComment, lTimeout);
if (FAILED(hr))
{
DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_FAILED_TO_CREATE_JUNCTION_POINT);
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot :: OnCreateNewJunctionPoint(
IN LPCTSTR i_szJPName,
IN LPCTSTR i_szServerName,
IN LPCTSTR i_szShareName,
IN LPCTSTR i_szComment,
IN long i_lTimeout
)
/*++
Routine Description:
This method handles the creation of new Junction Points.
It is called by the method that display the message box
--*/
{
RETURN_INVALIDARG_IF_NULL(i_szJPName);
RETURN_INVALIDARG_IF_NULL(i_szServerName);
RETURN_INVALIDARG_IF_NULL(i_szShareName);
RETURN_INVALIDARG_IF_NULL(i_szComment);
VARIANT varJPObject;
VariantInit(&varJPObject);
HRESULT hr = m_DfsRoot->CreateJunctionPoint(
(LPTSTR)i_szJPName,
(LPTSTR)i_szServerName,
(LPTSTR)i_szShareName,
(LPTSTR)i_szComment,
i_lTimeout,
&varJPObject);
RETURN_IF_FAILED(hr);
// Add the newly created junction point to scope pane if matches the filter
if ( m_MmcJPList.size() < m_ulLinkFilterMaxLimit &&
FilterMatch(i_szJPName, m_lLinkFilterType, m_bstrLinkFilterName) )
{
m_ulCountOfDfsJunctionPointsFiltered++;
CComPtr<IDfsJunctionPoint> pDfsJPObject = (IDfsJunctionPoint*)varJPObject.pdispVal;
// Create the object to be used for MMC display
CMmcDfsJunctionPoint* pMMCJPObject = new CMmcDfsJunctionPoint(pDfsJPObject, this, m_lpConsoleNameSpace);
if (!pMMCJPObject)
{
hr = E_OUTOFMEMORY;
} else
{
hr = pMMCJPObject->m_hrValueFromCtor;
if (SUCCEEDED(hr))
hr = pMMCJPObject->AddItemToScopePane(m_hScopeItem);
if (SUCCEEDED(hr))
{
JP_LIST_NODE* pJPList = new JP_LIST_NODE(pMMCJPObject);
if (!pJPList)
hr = E_OUTOFMEMORY;
else
m_MmcJPList.push_back(pJPList);
}
// Select the newly added scope item.
if (SUCCEEDED(hr))
{
m_lpConsole->SelectScopeItem(pMMCJPObject->m_hScopeItem);
} else
delete pMMCJPObject;
}
}
VariantClear(&varJPObject);
return hr;
}
STDMETHODIMP
CMmcDfsRoot::DoDelete()
/*++
Routine Description:
This method allows the item to delete itself.
Called when DEL key is pressed or when the "Delete" context menu
item is selected.
--*/
{
return OnDeleteConnectionToDfsRoot();
}
STDMETHODIMP CMmcDfsRoot::OnDeleteDfsRoot()
{
// Select this node to make sure m_MmcRepList populated
m_lpConsole->SelectScopeItem(m_hScopeItem);
// check outstanding property sheet, discontinue if any.
HRESULT hr = CloseAllPropertySheets(FALSE);
if (S_OK != hr)
return hr;
if (DFS_TYPE_STANDALONE == m_lDfsRootType)
{
hr = OnDeleteConnectionToDfsRoot(true);
if (S_OK == hr)
{
CComBSTR bstrDfsServer;
CComBSTR bstrRootShare;
hr = m_DfsRoot->GetOneDfsHost(&bstrDfsServer, &bstrRootShare);
if (SUCCEEDED(hr))
return _DeleteDfsRoot(bstrDfsServer, bstrRootShare, NULL);
}
if (FAILED(hr))
DisplayMessageBoxForHR(hr);
return hr;
}
// Confirm with the user, if he wants to delete this dfs root
hr = ConfirmOperationOnDfsRoot(IDS_MSG_DELETE_DFSROOT);
if (S_OK != hr) return hr;
//
// delete the replica set associated with the root (the internal link)
//
hr = OnStopReplication();
if (S_FALSE == hr)
{
// this root has already been deleted by others, no more reference
// OnStopReplication has already called OnRefresh and popped up the msgbox
return hr;
}
//
// delete the rest of replica sets related to this Dfs root
//
(void)m_DfsRoot->DeleteAllReplicaSets();
//
// remove root alternates
//
UINT nSize = m_MmcRepList.size();
DFS_REPLICA_LIST::iterator i;
while (nSize >= 1)
{
i = m_MmcRepList.begin();
hr = (*i)->pReplica->RemoveReplica();
BREAK_IF_FAILED(hr);
nSize--;
}
if (FAILED(hr))
DisplayMessageBoxForHR(hr);
return hr;
}
STDMETHODIMP CMmcDfsRoot::OnDeleteDisplayedDfsLinks()
{
// make sure all property pages are closed
HRESULT hr = ClosePropertySheetsOfAllLinks(FALSE);
if (S_OK != hr)
return hr; // property page found, discontinue
// Confirm with the user, if he wants to delete all the displayed dfs links
hr = ConfirmDeleteDisplayedDfsLinks();
if (S_OK != hr) return hr;
//
// refresh to pick up possible namespace updates by other means on root targets
//
hr = OnRefresh();
if (S_FALSE == hr)
{
//
// this root has been deleted by other means, scope pane has been refreshed,
// ask user to retry
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
ULONG ulSize = m_MmcJPList.size();
BOOL bSetNoFilter = TRUE;
if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
{
ULONG ulNumOfJPsFiltered = 0;
m_DfsRoot->get_CountOfDfsJunctionPointsFiltered((long*)&ulNumOfJPsFiltered);
if (ulNumOfJPsFiltered > ulSize)
bSetNoFilter = FALSE;
}
DFS_JUNCTION_LIST::iterator i;
while (ulSize >= 1)
{
i = m_MmcJPList.begin();
hr = ((*i)->pJPoint)->OnRemoveJP(FALSE);
BREAK_IF_FAILED(hr);
ulSize--;
}
if (FAILED(hr))
{
DisplayMessageBoxForHR(hr);
} else
{
if (bSetNoFilter)
m_lLinkFilterType = FILTERDFSLINKS_TYPE_NO_FILTER;
// Enumerate Junction points
(void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
m_lpConsole->SelectScopeItem(m_hScopeItem);
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot :: OnFilterDfsLinks(
)
/*++
Routine Description:
This method handles the link filter options.
Display a dialog box to get the user input.
--*/
{
HRESULT hr = ClosePropertySheetsOfAllLinks(FALSE);
if (S_OK != hr)
return hr; // property sheet found, discontinue
CFilterDfsLinks FilterDfsLinksDlg;
hr = FilterDfsLinksDlg.put_EnumFilterType(m_lLinkFilterType);
RETURN_IF_FAILED(hr);
if (m_lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
{
hr = FilterDfsLinksDlg.put_EnumFilter(m_bstrLinkFilterName);
RETURN_IF_FAILED(hr);
}
hr = FilterDfsLinksDlg.put_MaxLimit(m_ulLinkFilterMaxLimit);
RETURN_IF_FAILED(hr);
hr = FilterDfsLinksDlg.DoModal();
RETURN_IF_NOT_S_OK(hr);
CWaitCursor wait;
ULONG ulMaxLimit = 0;
hr = FilterDfsLinksDlg.get_MaxLimit(&ulMaxLimit);
RETURN_IF_FAILED(hr);
FILTERDFSLINKS_TYPE lLinkFilterType = FILTERDFSLINKS_TYPE_NO_FILTER;
hr = FilterDfsLinksDlg.get_EnumFilterType(&lLinkFilterType);
RETURN_IF_FAILED(hr);
CComBSTR bstrFilterName;
if (lLinkFilterType != FILTERDFSLINKS_TYPE_NO_FILTER)
{
hr = FilterDfsLinksDlg.get_EnumFilter(&bstrFilterName);
RETURN_IF_FAILED(hr);
}
m_lLinkFilterType = lLinkFilterType;
m_bstrLinkFilterName = bstrFilterName;
m_ulLinkFilterMaxLimit = ulMaxLimit;
dfsDebugOut((_T("m_lLinkFilterType=%d, m_bstrLinkFilterName=%s, m_ulLinkFilterMaxLimit=%d\n"),
m_lLinkFilterType,
m_bstrLinkFilterName,
m_ulLinkFilterMaxLimit));
return OnRefresh();
}
HRESULT
CMmcDfsRoot::SetDescriptionBarText(
IN LPRESULTDATA i_lpResultData
)
/*++
Routine Description:
A routine used set the text in the Description bar above
the result view.
Arguments:
i_lpResultData - Pointer to the IResultData callback which is
used to set the description text
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpResultData);
CComBSTR bstrTextForDescriptionBar;
HRESULT hr = FormatResourceString(IDS_DESCRIPTION_BAR_TEXT_ROOT, m_bstrDisplayName, &bstrTextForDescriptionBar);
if (SUCCEEDED(hr))
hr = i_lpResultData->SetDescBarText(bstrTextForDescriptionBar);
return hr;
}
HRESULT
CMmcDfsRoot::SetStatusText(
IN LPCONSOLE2 i_lpConsole
)
/*++
Routine Description:
Set the text in the Status bar.
Arguments:
i_lpConsole - IConsole2 from IComponent
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpConsole);
HRESULT hr = S_OK;
ULONG ulTotalNumOfJPs = 0;
hr = m_DfsRoot->get_CountOfDfsJunctionPoints((long*)&ulTotalNumOfJPs);
RETURN_IF_FAILED(hr);
ULONG ulDisplayedNumOfJPs = m_MmcJPList.size();
CComBSTR bstrText;
hr = FormatMessageString(&bstrText, 0,
IDS_STATUS_BAR_TEXT_ROOT, ulDisplayedNumOfJPs, ulTotalNumOfJPs);
if (SUCCEEDED(hr))
hr = i_lpConsole->SetStatusText(bstrText);
return hr;
}
STDMETHODIMP
CMmcDfsRoot::EnumerateResultPane(
IN OUT IResultData* io_pResultData
)
/*++
Routine Description:
To eumerate(add) items in the result pane. Root level Replicas in this case
Arguments:
io_pResultData - The callback used to add items to the Result pane
--*/
{
RETURN_INVALIDARG_IF_NULL(io_pResultData);
HRESULT hr = S_OK;
if (m_MmcRepList.empty())
{
CComPtr<IEnumVARIANT> pRepEnum;
hr = m_DfsRoot->get_RootReplicaEnum((IUnknown**) &pRepEnum);
RETURN_IF_FAILED(hr);
VARIANT varReplicaObject;
VariantInit(&varReplicaObject);
while ( S_OK == (hr = pRepEnum->Next(1, &varReplicaObject, NULL)) )
{
CComPtr<IDfsReplica> pReplicaObject = (IDfsReplica*) varReplicaObject.pdispVal;
CMmcDfsReplica* pMMCReplicaObject = new CMmcDfsReplica(pReplicaObject, this);
if (!pMMCReplicaObject)
{
hr = E_OUTOFMEMORY;
} else
{
hr = pMMCReplicaObject->m_hrValueFromCtor;
if (SUCCEEDED(hr))
hr = pMMCReplicaObject->AddItemToResultPane(io_pResultData);
if (SUCCEEDED(hr))
{
REP_LIST_NODE* pRepNode = new REP_LIST_NODE (pMMCReplicaObject);
if (!pRepNode)
hr = E_OUTOFMEMORY;
else
m_MmcRepList.push_back(pRepNode);
}
if (FAILED(hr))
delete pMMCReplicaObject;
}
VariantClear(&varReplicaObject);
if (FAILED(hr))
break;
} // while
}
else
{
// The replicas of this junction are already enumerated,
// and the list exists, just add result items.
for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
hr = ((*i)->pReplica)->AddItemToResultPane(io_pResultData);
BREAK_IF_FAILED(hr);
}
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot::QueryPagesFor(
)
/*++
Routine Description:
Used to decide whether the object wants to display property pages.
Returning S_OK typically results in a call to CreatePropertyPages.
--*/
{
//
// refresh to pick up possible namespace updates by others
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr; // no property page
}
return S_OK; // since we want to display a propertysheet.
}
// Creates and passes back the pages to be displayed
STDMETHODIMP
CMmcDfsRoot::CreatePropertyPages(
IN LPPROPERTYSHEETCALLBACK i_lpPropSheetCallback,
IN LONG_PTR i_lNotifyHandle
)
/*++
Routine Description:
Used to display the property sheet pages
Arguments:
i_lpPropSheetCallback - The callback used to create the propertysheet.
i_lNotifyHandle - Notify handle used by the property page
Return value:
S_OK since we want to display a propertysheet.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_lpPropSheetCallback);
m_lpConsole->SelectScopeItem(m_hScopeItem);
CWaitCursor WaitCursor;
HRESULT hr = S_OK;
do {
hr = m_PropPage.Initialize((IDfsRoot*)m_DfsRoot, NULL);
BREAK_IF_FAILED(hr);
// Create the page for the replica set.
// Pass it to the Callback
HPROPSHEETPAGE h_proppage = m_PropPage.Create();
if (!h_proppage)
hr = HRESULT_FROM_WIN32(::GetLastError());
BREAK_IF_FAILED(hr);
// Pass on the notify data to the Property Page
hr = m_PropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
BREAK_IF_FAILED(hr);
hr = i_lpPropSheetCallback->AddPage(h_proppage);
BREAK_IF_FAILED(hr);
//
// Create "Replica Set" page
//
hr = CreateFrsPropertyPage(i_lpPropSheetCallback, i_lNotifyHandle);
if (FAILED(hr))
{
DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_REPPAGE_ERROR);
hr = S_OK; // allow the other tabs to be brought up
}
//
// Create "Publish" page
//
hr = CreatePublishPropertyPage(i_lpPropSheetCallback, i_lNotifyHandle);
if (FAILED(hr))
{
DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_PUBLISHPAGE_ERROR);
hr = S_OK; // allow the other tabs to be brought up
}
/*
//
// Create Security property page for Fault Tolerance DFS root
//
if (DFS_TYPE_FTDFS == m_lDfsRootType)
{
LPTSTR lpszLDAPRoot = NULL;
PLDAP pldap = NULL;
do {
CComBSTR bstrDomainName;
hr = m_DfsRoot->get_DomainName(&bstrDomainName);
BREAK_IF_FAILED(hr);
CComBSTR bstrDfsName;
hr = m_DfsRoot->get_DfsName(&bstrDfsName);
BREAK_IF_FAILED(hr);
CComBSTR bstrServerName;
hr = ConnectToDS(bstrDomainName, &pldap, &bstrServerName);
BREAK_IF_FAILED(hr);
hr = GetLDAPRootPath(pldap, &lpszLDAPRoot);
BREAK_IF_FAILED(hr);
CComBSTR bstrSystemDN;
CComBSTR bstrDfsConfigDN;
CComBSTR bstrFTRootDN;
if (FAILED(hr = ExtendDN(CN_SYSTEM, lpszLDAPRoot, &bstrSystemDN)) ||
FAILED(hr = ExtendDN(CN_DFSCONFIGURATION, bstrSystemDN, &bstrDfsConfigDN)) ||
FAILED(hr = ExtendDN(bstrDfsName, bstrDfsConfigDN, &bstrFTRootDN)) )
break;
CComBSTR bstrObjectPath;
bstrObjectPath = _T("LDAP://");
bstrObjectPath += bstrServerName;
bstrObjectPath += _T("/");
bstrObjectPath += bstrFTRootDN;
hr = CreateDfsSecurityPage(
i_lpPropSheetCallback,
bstrObjectPath,
NULL,
DSSI_IS_ROOT);
} while (0);
if (pldap) CloseConnectionToDS(pldap);
if (lpszLDAPRoot) free(lpszLDAPRoot);
}
*/
} while (0);
if (FAILED(hr))
DisplayMessageBoxForHR(hr);
return hr;
}
STDMETHODIMP
CMmcDfsRoot::CreateFrsPropertyPage
(
IN LPPROPERTYSHEETCALLBACK i_lpPropSheetCallback,
IN LONG_PTR i_lNotifyHandle
)
{
//
// init m_piReplicaSet
//
HRESULT hr = _InitReplicaSet();
if (S_OK != hr) return hr;
CComBSTR bstrType;
hr = m_piReplicaSet->get_Type(&bstrType);
RETURN_IF_FAILED(hr);
if (lstrcmpi(bstrType, FRS_RSTYPE_DFS))
return hr;
//
// set initial values on the property page
//
hr = m_frsPropPage.Initialize(m_piReplicaSet);
RETURN_IF_FAILED(hr);
//
// create the property page
//
HPROPSHEETPAGE h_frsproppage = m_frsPropPage.Create();
if (!h_frsproppage)
return HRESULT_FROM_WIN32(::GetLastError());
//
// pass on the notify data to the Property Page
//
hr = m_frsPropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
RETURN_IF_FAILED(hr);
//
// AddPage
//
return i_lpPropSheetCallback->AddPage(h_frsproppage);
}
STDMETHODIMP
CMmcDfsRoot::CreatePublishPropertyPage
(
IN LPPROPERTYSHEETCALLBACK i_lpPropSheetCallback,
IN LONG_PTR i_lNotifyHandle
)
{
//
// check schema version
//
if (!m_bNewSchema)
return S_FALSE;
//
// check group policy
//
if (!CheckPolicyOnSharePublish())
return S_FALSE;
//
// create the property page
//
HPROPSHEETPAGE hpage = m_publishPropPage.Create();
if (!hpage)
return HRESULT_FROM_WIN32(::GetLastError());
m_publishPropPage.Initialize(m_DfsRoot);
//
// pass on the notify data to the Property Page
//
HRESULT hr = m_publishPropPage.SetNotifyData(i_lNotifyHandle, (LPARAM)this);
RETURN_IF_FAILED(hr);
//
// AddPage
//
return i_lpPropSheetCallback->AddPage(hpage);
}
STDMETHODIMP
CMmcDfsRoot::PropertyChanged(
)
/*++
Routine Description:
Used to update the properties.
--*/
{
return S_OK;
}
HRESULT
CMmcDfsRoot::ToolbarSelect(
IN const LONG i_lArg,
IN IToolbar* i_pToolBar
)
/*++
Routine Description:
Handle a select event for a toolbar
Create a toolbar, it it doesn't exist.
Attach the toolbar and enable the buttons, if the event for a selection.
Disable the buttons, if the event was for a deselection
Arguments:
i_lArg - The argument passed to the actual method.
i_pToolBar - Pointer to Toolbar.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_pToolBar);
BOOL bSelect = (BOOL) HIWORD(i_lArg); // Is the event for selection?
EnableToolbarButtons(i_pToolBar, IDT_ROOT_MIN, IDT_ROOT_MAX, bSelect);
if (bSelect) // Should we disable or enable the toolbar?
{
BOOL bReplicaSetExist = FALSE;
HRESULT hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
RETURN_IF_FAILED(hr);
if(DFS_TYPE_STANDALONE == m_lDfsRootType)
{
i_pToolBar->SetButtonState(IDT_ROOT_NEW_ROOT_REPLICA, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_NEW_ROOT_REPLICA, HIDDEN, TRUE);
}
if (m_MmcJPList.empty())
{
i_pToolBar->SetButtonState(IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS, HIDDEN, TRUE);
}
if (bReplicaSetExist || 1 >= m_MmcRepList.size())
{
i_pToolBar->SetButtonState(IDT_ROOT_REPLICATION_TOPOLOGY, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_REPLICATION_TOPOLOGY, HIDDEN, TRUE);
}
if (!bReplicaSetExist)
{
i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, HIDDEN, TRUE);
i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, HIDDEN, TRUE);
i_pToolBar->SetButtonState(IDT_ROOT_STOP_REPLICATION, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_STOP_REPLICATION, HIDDEN, TRUE);
} else
{
if (m_bShowFRS)
{
i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_SHOW_REPLICATION, HIDDEN, TRUE);
} else
{
i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_HIDE_REPLICATION, HIDDEN, TRUE);
}
}
// excluded when empty root container
if (m_MmcRepList.empty())
{
i_pToolBar->SetButtonState(IDT_ROOT_NEW_DFS_LINK, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_NEW_DFS_LINK, HIDDEN, TRUE);
i_pToolBar->SetButtonState(IDT_ROOT_CHECK_STATUS, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_CHECK_STATUS, HIDDEN, TRUE);
i_pToolBar->SetButtonState(IDT_ROOT_FILTER_DFS_LINKS, ENABLED, FALSE);
i_pToolBar->SetButtonState(IDT_ROOT_FILTER_DFS_LINKS, HIDDEN, TRUE);
}
}
return S_OK;
}
HRESULT
CMmcDfsRoot::CreateToolbar(
IN const LPCONTROLBAR i_pControlbar,
IN const LPEXTENDCONTROLBAR i_lExtendControlbar,
OUT IToolbar** o_ppToolBar
)
/*++
Routine Description:
Create the toolbar.
Involves the actual toolbar creation call, creating the bitmap and adding it
and finally adding the buttons to the toolbar
Arguments:
i_pControlbar - The controlbar used to create toolbar.
i_lExtendControlbar - The object implementing IExtendControlbar. This is
the class exposed to MMC.
o_ppToolBar - The Toolbar pointer.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_pControlbar);
RETURN_INVALIDARG_IF_NULL(i_lExtendControlbar);
RETURN_INVALIDARG_IF_NULL(o_ppToolBar);
// Create the toolbar
HRESULT hr = i_pControlbar->Create(TOOLBAR, i_lExtendControlbar, reinterpret_cast<LPUNKNOWN*>(o_ppToolBar));
RETURN_IF_FAILED(hr);
// Add the bitmap to the toolbar
hr = AddBitmapToToolbar(*o_ppToolBar, IDB_ROOT_TOOLBAR);
RETURN_IF_FAILED(hr);
int iButtonPosition = 0; // The first button position
for (int iCommandID = IDT_ROOT_MIN, iMenuResource = IDS_MENUS_ROOT_TOP_NEW_DFS_LINK;
iCommandID <= IDT_ROOT_MAX;
iCommandID++,iMenuResource++,iButtonPosition++)
{
CComBSTR bstrMenuText;
CComBSTR bstrToolTipText;
hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, &bstrToolTipText, NULL);
RETURN_IF_FAILED(hr);
MMCBUTTON ToolbarButton;
ZeroMemory(&ToolbarButton, sizeof ToolbarButton);
ToolbarButton.nBitmap = iButtonPosition;
ToolbarButton.idCommand = iCommandID;
ToolbarButton.fsState = TBSTATE_ENABLED;
ToolbarButton.fsType = TBSTYLE_BUTTON;
ToolbarButton.lpButtonText = bstrMenuText; // not used anyway
ToolbarButton.lpTooltipText = bstrToolTipText;
// Add the button to the toolbar
hr = (*o_ppToolBar)->InsertButton(iButtonPosition, &ToolbarButton);
BREAK_IF_FAILED(hr);
}
return hr;
}
STDMETHODIMP
CMmcDfsRoot::ToolbarClick(
IN const LPCONTROLBAR i_pControlbar,
IN const LPARAM i_lParam
)
/*++
Routine Description:
Action to take on a click on a toolbar
Arguments:
i_pControlbar - The controlbar used to create toolbar.
i_lParam - The lparam to the actual notify. This is the command id of
the button on which a click occurred.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_pControlbar);
HRESULT hr = S_OK;
switch(i_lParam)
{
case IDT_ROOT_NEW_DFS_LINK:
hr = OnCreateNewJunctionPoint ();
break;
case IDT_ROOT_NEW_ROOT_REPLICA:
hr = OnNewRootReplica();
break;
case IDT_ROOT_CHECK_STATUS:
hr = OnCheckStatus();
break;
case IDT_ROOT_DELETE_DISPLAYED_DFS_LINKS:
hr = OnDeleteDisplayedDfsLinks();
break;
case IDT_ROOT_DELETE_CONNECTION_TO_DFS_ROOT:
hr = OnDeleteConnectionToDfsRoot();
break;
case IDT_ROOT_DELETE_DFS_ROOT:
hr = OnDeleteDfsRoot();
break;
case IDT_ROOT_FILTER_DFS_LINKS:
hr = OnFilterDfsLinks();
break;
case IDT_ROOT_REPLICATION_TOPOLOGY:
hr = OnNewReplicaSet();
break;
case IDT_ROOT_SHOW_REPLICATION:
case IDT_ROOT_HIDE_REPLICATION:
m_bShowFRS = !m_bShowFRS;
hr = OnShowReplication();
break;
case IDT_ROOT_STOP_REPLICATION:
hr = OnStopReplication(TRUE);
if (FAILED(hr))
DisplayMessageBoxForHR(hr);
break;
default:
hr = E_INVALIDARG;
break;
};
return hr;
}
HRESULT
CMmcDfsRoot::ClosePropertySheet(BOOL bSilent)
{
if (!m_PropPage.m_hWnd && !m_frsPropPage.m_hWnd && !m_publishPropPage.m_hWnd)
return S_OK; // no outstanding property sheet, return S_OK;
//
// handle property sheet for the root
//
CComPtr<IPropertySheetProvider> pPropSheetProvider;
HRESULT hr = m_lpConsole->QueryInterface(IID_IPropertySheetProvider, reinterpret_cast<void**>(&pPropSheetProvider));
if (FAILED(hr))
{
hr = S_OK; // ignore the QI failure
} else
{
//
// find outstanding property sheet and bring it to foreground
//
hr = pPropSheetProvider->FindPropertySheet((MMC_COOKIE)m_hScopeItem, NULL, this);
if (S_OK == hr)
{
if (!bSilent)
{
//
// ask user to close it, return S_FALSE to quit user's operation
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_PROPERTYPAGE_NOTCLOSED);
return S_FALSE;
} else
{
//
// silently close the property sheet, return S_OK
//
if (m_PropPage.m_hWnd)
::SendMessage(m_PropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);
if (m_frsPropPage.m_hWnd)
::SendMessage(m_frsPropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);
if (m_publishPropPage.m_hWnd)
::SendMessage(m_publishPropPage.m_hWnd, WM_PARENT_NODE_CLOSING, 0, 0);
}
} else
{
hr = S_OK; // no outstanding property sheet, return S_OK
}
}
//
// reset HWND
//
m_PropPage.m_hWnd = NULL;
m_frsPropPage.m_hWnd = NULL;
m_publishPropPage.m_hWnd = NULL;
return hr;
}
HRESULT
CMmcDfsRoot::ClosePropertySheetsOfAllLinks(BOOL bSilent)
{
HRESULT hr = S_OK;
//
// handle property sheets for its links
//
if (!m_MmcJPList.empty())
{
for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
{
hr = ((*i)->pJPoint)->ClosePropertySheet(bSilent);
if (!bSilent && S_FALSE == hr)
return S_FALSE; // found an outstanding one for a link, return S_FALSE to quit user's operation
}
}
return S_OK;
}
// Close all outstanding property sheets for its own and its links
// Return: S_OK if there is no open property sheet, or they have all been closed silently
// Return: S_FALSE if an open sheet is found and msgbox poped up to remind user of closing it
HRESULT
CMmcDfsRoot::CloseAllPropertySheets(BOOL bSilent)
{
//
// handle property sheet for the root
//
HRESULT hr = ClosePropertySheet(bSilent);
if (!bSilent && S_FALSE == hr)
return S_FALSE;
//
// handle property sheets for its links
//
return ClosePropertySheetsOfAllLinks(bSilent);
}
HRESULT
CMmcDfsRoot::OnRefresh()
{
// Select this node first
m_lpConsole->SelectScopeItem(m_hScopeItem);
CWaitCursor wait;
HRESULT hr = S_OK;
// silently close outstanding property sheet.
CloseAllPropertySheets(TRUE);
CleanScopeChildren();
CleanResultChildren();
m_bShowFRS = FALSE;
if ((IReplicaSet *)m_piReplicaSet)
m_piReplicaSet.Release();
// Re-Initialize!
hr = m_DfsRoot->Initialize(m_bstrRootEntryPath);
if (S_OK != hr) // failt to init the root, or no such root any more, we have to stop managing the root
{
if (FAILED(hr))
DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_STOP_MANAGING_ROOT);
// Delete the item from Scope Pane
(void)m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);
// Delete it from the internal list
(void)m_pParent->DeleteMmcRootNode(this);
Release(); // delete this CMmcDfsRoot object
return S_FALSE;
}
BOOL bReplicaSetExist = FALSE;
CComBSTR bstrDC;
(void)m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);
// Enumerate Junction points
(void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);
// set the root icon
if (m_lpConsoleNameSpace != NULL)
{
SCOPEDATAITEM ScopeDataItem;
ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
ScopeDataItem.ID = m_hScopeItem;
hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
if (SUCCEEDED(hr))
{
ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
}
}
// Re-Display Result Pane.
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
// Set the selected item in scope pane to this node
m_lpConsole->SelectScopeItem(m_hScopeItem);
return S_OK;
}
HRESULT
CMmcDfsRoot::OnRefreshFilteredLinks()
{
// Select this node first
m_lpConsole->SelectScopeItem(m_hScopeItem);
CWaitCursor wait;
HRESULT hr = S_OK;
CleanScopeChildren();
CleanResultChildren();
m_bShowFRS = FALSE;
if ((IReplicaSet *)m_piReplicaSet)
m_piReplicaSet.Release();
BOOL bReplicaSetExist = FALSE;
CComBSTR bstrDC;
hr = m_DfsRoot->get_ReplicaSetExistEx(&bstrDC, &bReplicaSetExist);
if (FAILED(hr))
{
return OnRefresh(); // fail to access info, see if the root can be contacted or not
}
// Enumerate Junction points
(void)EnumerateScopePane(m_lpConsoleNameSpace, m_hScopeItem);
// set the root icon
if (m_lpConsoleNameSpace != NULL)
{
SCOPEDATAITEM ScopeDataItem;
ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
ScopeDataItem.ID = m_hScopeItem;
hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);
if (SUCCEEDED(hr))
{
ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE;
ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0);
m_lpConsoleNameSpace->SetItem(&ScopeDataItem);
}
}
// re-display the result pane items
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
// Set the selected item in scope pane to this node
m_lpConsole->SelectScopeItem(m_hScopeItem);
return S_OK;
}
HRESULT
CMmcDfsRoot::_DeleteDfsRoot(
IN BSTR i_bstrServerName,
IN BSTR i_bstrShareName,
IN BSTR i_bstrFtDfsName
)
{
/*++
Routine Description:
Helper member function to actually delete (Stop hosting) the Dfs Root.
This is also called to delete root level replica.
Arguments:
i_bstrServerName - The server on which the Dfs has to be torn down.
i_bRootReplica - This DfsRoot is been torn down as Root Replica.
i_bstrFtDfsName - The FtDfs name of the Dfs. NULL for Standalone Dfs.
--*/
RETURN_INVALIDARG_IF_NULL(i_bstrServerName);
RETURN_INVALIDARG_IF_NULL(i_bstrShareName);
CWaitCursor WaitCursor; // Display the wait cursor
HRESULT hr = m_DfsRoot->DeleteDfsHost(i_bstrServerName, i_bstrShareName, FALSE);
BOOL bFTDfs = (i_bstrFtDfsName && *i_bstrFtDfsName);
if (bFTDfs)
{
if (FAILED(hr) && HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) != hr)
{
if (IDYES == DisplayMessageBox(
GetActiveWindow(),
MB_YESNO | MB_ICONEXCLAMATION,
hr,
IDS_MSG_WIZ_DELETE_FAILURE_RETRY,
i_bstrServerName))
{
// force delete
hr = m_DfsRoot->DeleteDfsHost(i_bstrServerName, i_bstrShareName, TRUE);
} else
{
// leave it alone
hr = S_FALSE;
}
}
}
if (FAILED(hr))
DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_WIZ_DELETE_FAILURE, i_bstrServerName);
//
// delete volume object if it's standalone
//
if (SUCCEEDED(hr) && !bFTDfs)
{
(void) ModifySharePublishInfoOnSARoot(
i_bstrServerName,
i_bstrShareName,
FALSE,
NULL,
NULL,
NULL,
NULL
);
}
return hr;
}
STDMETHODIMP CMmcDfsRoot::CleanScopeChildren()
{
HRESULT hr = S_OK;
if (!m_MmcJPList.empty())
{
// clean up the display objects
for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
{
delete (*i);
}
m_MmcJPList.erase(m_MmcJPList.begin(), m_MmcJPList.end());
// Delete all child items from scope pane.
if (m_lpConsoleNameSpace)
{
HSCOPEITEM hChild = NULL;
MMC_COOKIE lCookie = 0;
while (SUCCEEDED(hr = m_lpConsoleNameSpace->GetChildItem(m_hScopeItem, &hChild, &lCookie)) && hChild)
{
(void)m_lpConsoleNameSpace->DeleteItem(hChild, TRUE);
}
}
}
return S_OK;
}
STDMETHODIMP CMmcDfsRoot::CleanResultChildren(
)
{
if (!m_MmcRepList.empty())
{
// delete display object
for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
delete (*i);
}
m_MmcRepList.erase(m_MmcRepList.begin(), m_MmcRepList.end());
// delete result pane items
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 0);
}
return(S_OK);
}
STDMETHODIMP CMmcDfsRoot::RefreshResultChildren(
)
{
CleanResultChildren();
m_DfsRoot->RefreshRootReplicas();
// Send View change notification for all veiws.
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
return(S_OK);
}
STDMETHODIMP CMmcDfsRoot::ViewChange(
IResultData* i_pResultData,
LONG_PTR i_lHint
)
/*++
Routine Description:
This method handles the MMCN_VIEW_CHANGE notification.
This updates the result view for the scope node on which the
UpdateAllViews was called.
if (0 == i_lHint) clean result pane only.
--*/
{
RETURN_INVALIDARG_IF_NULL(i_pResultData);
i_pResultData->DeleteAllRsltItems();
if (i_lHint)
EnumerateResultPane(i_pResultData);
return(S_OK);
}
STDMETHODIMP CMmcDfsRoot::AddResultPaneItem(
CMmcDfsReplica* i_pReplicaDispObject
)
/*++
Routine Description:
This method adds a new replica object to the list of replicas displayed
in the result view.
Arguments:
i_pReplicaDispObject - The CMmcReplica display object pointer..
--*/
{
REP_LIST_NODE* pNewReplica = new REP_LIST_NODE(i_pReplicaDispObject);
if (!pNewReplica)
return E_OUTOFMEMORY;
m_MmcRepList.push_back(pNewReplica);
// Re-display to display this item.
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
return S_OK;
}
//
// This function is called when deleting a link from the scope pane
//
STDMETHODIMP CMmcDfsRoot::RemoveJP(LPCTSTR i_pszDisplayName)
{
if (!i_pszDisplayName)
return E_INVALIDARG;
//
// refresh to pick up possible namespace updates on links by other means
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has already been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
//
// locate the correct link to remove, then call back.
//
for (DFS_JUNCTION_LIST::iterator i = m_MmcJPList.begin(); i != m_MmcJPList.end(); i++)
{
if (!lstrcmpi((*i)->pJPoint->m_bstrDisplayName, i_pszDisplayName))
{
hr = (*i)->pJPoint->OnRemoveJP();
break;
}
}
return hr;
}
//
// This function is called when removing a target from the result pane
//
STDMETHODIMP CMmcDfsRoot::RemoveReplica(LPCTSTR i_pszDisplayName)
{
if (!i_pszDisplayName)
return E_INVALIDARG;
//
// refresh to pick up possible namespace updates on root targets by other means
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has already been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
//
// locate the correct target to remove, then call back
//
for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
if (!lstrcmpi((*i)->pReplica->m_bstrDisplayName, i_pszDisplayName))
{
hr = (*i)->pReplica->RemoveReplica();
break;
}
}
return hr;
}
STDMETHODIMP CMmcDfsRoot::RemoveResultPaneItem(
CMmcDfsReplica* i_pReplicaDispObject
)
/*++
Routine Description:
This method removes a replica object from the list of replicas displayed
in the result view.
Arguments:
i_pReplicaDispObject - The CMmcReplica display object pointer..
--*/
{
dfsDebugOut((_T("CMmcDfsRoot::RemoveResultPaneItem jplist=%d, replist=%d\n"),
m_MmcJPList.size(), m_MmcRepList.size()));
// Remove item from list.
for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
if ((*i)->pReplica == i_pReplicaDispObject)
{
delete (*i);
m_MmcRepList.erase(i);
break;
}
}
// Last node is removed.
if (m_MmcRepList.empty())
{
// silently close any open property sheet
CloseAllPropertySheets(TRUE);
CleanScopeChildren();
// Delete the item from Scope Pane
HRESULT hr = m_lpConsoleNameSpace->DeleteItem(m_hScopeItem, TRUE);
RETURN_IF_FAILED(hr);
// Delete it from the internal list
hr = m_pParent->DeleteMmcRootNode(this);
RETURN_IF_FAILED(hr);
Release(); // delete this CMmsDfsRoot object
}
else
{
// Re-display to remove this item.
m_lpConsole->UpdateAllViews((IDataObject*)this, 0, 1);
}
return S_OK;
}
STDMETHODIMP
CMmcDfsRoot::OnCheckStatus()
{
//
// refresh to pick up possible namespace updates on targets by others
//
HRESULT hr = OnRefresh();
if (S_FALSE == hr)
{
// this root has been deleted by others, no more reference
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_ROOT);
return hr;
}
CWaitCursor wait;
UINT nTotal = m_MmcRepList.size();
_ASSERT(nTotal != 0);
UINT nMappingOn = 0;
UINT nMappingOff = 0;
UINT nUnreachable = 0;
// Update state of all replicas also.
for (DFS_REPLICA_LIST::iterator i = m_MmcRepList.begin(); i != m_MmcRepList.end(); i++)
{
(*i)->pReplica->OnCheckStatus();
switch ((*i)->pReplica->m_lReplicaState)
{
case DFS_REPLICA_STATE_ONLINE:
nMappingOn++;
break;
case DFS_REPLICA_STATE_OFFLINE:
nMappingOff++;
break;
case DFS_REPLICA_STATE_UNREACHABLE:
nUnreachable++;
break;
default:
_ASSERT(FALSE);
break;
}
}
long lDfsState = DFS_STATE_REACHABLE;
hr = m_DfsRoot->get_State(&lDfsState);
RETURN_IF_FAILED(hr);
if (DFS_STATE_REACHABLE == lDfsState)
{
if (nTotal == nMappingOn)
{
m_lRootJunctionState = DFS_JUNCTION_STATE_ALL_REP_OK;
} else if (nTotal != (nMappingOff + nUnreachable))
{
m_lRootJunctionState = DFS_JUNCTION_STATE_NOT_ALL_REP_OK;
} else
{
m_lRootJunctionState = DFS_JUNCTION_STATE_UNREACHABLE;
}
} else
{
m_lRootJunctionState = DFS_JUNCTION_STATE_UNREACHABLE;
}
BOOL bReplicaSetExist = FALSE;
hr = m_DfsRoot->get_ReplicaSetExist(&bReplicaSetExist);
RETURN_IF_FAILED(hr);
if (m_lpConsoleNameSpace)
{
SCOPEDATAITEM ScopeDataItem;
ZeroMemory(&ScopeDataItem, sizeof(SCOPEDATAITEM));
ScopeDataItem.ID = m_hScopeItem;
hr = m_lpConsoleNameSpace->GetItem(&ScopeDataItem);// Get the item data
RETURN_IF_FAILED(hr);
ScopeDataItem.mask = SDI_IMAGE | SDI_OPENIMAGE; // Set the image flag
ScopeDataItem.nImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0) + m_lRootJunctionState; // Specify the bitmap to use
ScopeDataItem.nOpenImage = CMmcDfsRoot::m_iIMAGEINDEX + ((DFS_TYPE_FTDFS == m_lDfsRootType)? 4 : 0) + (bReplicaSetExist ? 4 : 0) + m_lRootJunctionState; // Specify the bitmap to use
hr = m_lpConsoleNameSpace->SetItem(&ScopeDataItem); // set the updated item data
RETURN_IF_FAILED(hr);
}
return hr;
}
HRESULT CMmcDfsRoot::GetIReplicaSetPtr(IReplicaSet** o_ppiReplicaSet)
{
RETURN_INVALIDARG_IF_NULL(o_ppiReplicaSet);
HRESULT hr = _InitReplicaSet();
if (S_OK == hr)
{
m_piReplicaSet->AddRef();
*o_ppiReplicaSet = m_piReplicaSet;
}
return hr;
}
Reference in a new issue Copy permalink