windows-server-2003/net/mmc/ipxsnap/summary.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	summary.cpp
		IPX summary node implementation.
		
    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "util.h"
#include "summary.h"
#include "reg.h"
#include "ipxadmin.h"
#include "rtrutil.h"	// smart MPR handle pointers
#include "ipxstrm.h"		// IPXAdminConfigStream
#include "strmap.h"		// XXXtoCString functions
#include "service.h"	// TFS service APIs
#include "format.h"		// FormatNumber function
#include "coldlg.h"		// columndlg
#include "column.h"	// ComponentConfigStream
#include "rtrui.h"
#include "sumprop.h"	// IP Summary property page
#include "ipxutil.h"	// IPX formatting helper functions
#include "routprot.h"
#include "ipxrtdef.h"
#include "rtrerr.h"     // FormatRasErrorMessage


/*---------------------------------------------------------------------------
	Keep this in sync with the column ids in summary.h
 ---------------------------------------------------------------------------*/
extern const ContainerColumnInfo	s_rgIfViewColumnInfo[];

const ContainerColumnInfo	s_rgIfViewColumnInfo[] = 
{
	{ IDS_IPX_COL_NAME,				CON_SORT_BY_STRING,	TRUE, COL_IF_NAME },
	{ IDS_IPX_COL_TYPE,				CON_SORT_BY_STRING, TRUE, COL_STRING },
	{ IDS_IPX_COL_ADMINSTATE,		CON_SORT_BY_STRING, TRUE, COL_STATUS },
	{ IDS_IPX_COL_OPERSTATE,		CON_SORT_BY_STRING, TRUE, COL_STATUS },
	{ IDS_IPX_COL_NETWORK,			CON_SORT_BY_STRING,	TRUE, COL_IPXNET },
	{ IDS_IPX_COL_PACKETS_SENT,		CON_SORT_BY_DWORD,	TRUE, COL_LARGE_NUM },
	{ IDS_IPX_COL_PACKETS_RCVD,		CON_SORT_BY_DWORD,	TRUE, COL_LARGE_NUM },
	{ IDS_IPX_COL_OUT_FILTERED,		CON_SORT_BY_DWORD,	FALSE, COL_LARGE_NUM },
	{ IDS_IPX_COL_OUT_DROPPED,		CON_SORT_BY_DWORD,	FALSE, COL_LARGE_NUM },
	{ IDS_IPX_COL_IN_FILTERED,		CON_SORT_BY_DWORD,	FALSE, COL_LARGE_NUM },
	{ IDS_IPX_COL_IN_NOROUTES,		CON_SORT_BY_DWORD,	FALSE, COL_LARGE_NUM },
	{ IDS_IPX_COL_IN_DROPPED,		CON_SORT_BY_DWORD,	FALSE, COL_LARGE_NUM },
};


/*---------------------------------------------------------------------------
	IPXSummaryHandler implementation
 ---------------------------------------------------------------------------*/

IPXSummaryHandler::IPXSummaryHandler(ITFSComponentData *pCompData)
	: BaseContainerHandler(pCompData, COLUMNS_SUMMARY,
						   s_rgIfViewColumnInfo),
	m_ulConnId(0),
	m_ulRefreshConnId(0),
	m_ulStatsConnId(0)
{

	// Setup the verb states

	m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
	m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
	
}


STDMETHODIMP IPXSummaryHandler::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // Is the pointer bad?
    if (ppv == NULL)
		return E_INVALIDARG;

    //  Place NULL in *ppv in case of failure
    *ppv = NULL;

    //  This is the non-delegating IUnknown implementation
    if (riid == IID_IUnknown)
		*ppv = (LPVOID) this;
	else if (riid == IID_IRtrAdviseSink)
		*ppv = &m_IRtrAdviseSink;
	else
		return BaseContainerHandler::QueryInterface(riid, ppv);

    //  If we're going to return an interface, AddRef it first
    if (*ppv)
	{
	((LPUNKNOWN) *ppv)->AddRef();
		return hrOK;
	}
    else
		return E_NOINTERFACE;	
}



/*!--------------------------------------------------------------------------
	IPXSummaryHandler::DestroyHandler
		Implementation of ITFSNodeHandler::DestroyHandler
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::DestroyHandler(ITFSNode *pNode)
{
	IPXConnection *	pIpxConn;

	pIpxConn = GET_IPXSUMMARY_NODEDATA(pNode);
	pIpxConn->Release();

	if (m_ulRefreshConnId)
	{
		SPIRouterRefresh	spRefresh;
		if (m_spRouterInfo)
			m_spRouterInfo->GetRefreshObject(&spRefresh);
		if (spRefresh)
			spRefresh->UnadviseRefresh(m_ulRefreshConnId);
	}
	m_ulRefreshConnId = 0;

	if (m_ulStatsConnId)
	{
		SPIRouterRefresh	spRefresh;
		if (m_spRouterInfo)
			m_spRouterInfo->GetRefreshObject(&spRefresh);
		if (spRefresh)
			spRefresh->UnadviseRefresh(m_ulStatsConnId);		
	}
	m_ulStatsConnId = 0;
	
	if (m_ulConnId)
		m_spRtrMgrInfo->RtrUnadvise(m_ulConnId);
	m_ulConnId = 0;
	m_spRtrMgrInfo.Release();

//	WaitForStatisticsWindow(&m_IpxStats);

	m_spRouterInfo.Release();
	return hrOK;
}

/*---------------------------------------------------------------------------
	Menu data structure for our menus
 ---------------------------------------------------------------------------*/

static const SRouterNodeMenu s_rgIfNodeMenu[] =
{
	{ IDS_MENU_IPXSUM_NEW_INTERFACE, 0,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },

	{ IDS_MENU_SEPARATOR, 0,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },
};

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnAddMenuItems
		Implementation of ITFSNodeHandler::OnAddMenuItems
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::OnAddMenuItems(
	ITFSNode *pNode,
	LPCONTEXTMENUCALLBACK pContextMenuCallback, 
	LPDATAOBJECT lpDataObject, 
	DATA_OBJECT_TYPES type, 
	DWORD dwType,
	long *pInsertionAllowed)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	HRESULT hr = S_OK;
    IPXSummaryHandler::SMenuData    menuData;
	
	COM_PROTECT_TRY
	{
        menuData.m_spNode.Set(pNode);
        
		hr = AddArrayOfMenuItems(pNode, s_rgIfNodeMenu,
								 DimensionOf(s_rgIfNodeMenu),
								 pContextMenuCallback,
								 *pInsertionAllowed,
                                 reinterpret_cast<INT_PTR>(&menuData));
	}
	COM_PROTECT_CATCH;
		
	return hr; 
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnCommand
		Implementation of ITFSNodeHandler::OnCommand
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::OnCommand(ITFSNode *pNode, long nCommandId, 
										   DATA_OBJECT_TYPES	type, 
										   LPDATAOBJECT pDataObject, 
										   DWORD	dwType)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	HRESULT hr = S_OK;

	COM_PROTECT_TRY
	{
		switch (nCommandId)
		{
			case IDS_MENU_IPXSUM_NEW_INTERFACE:
				hr = OnNewInterface();
				if (!FHrSucceeded(hr))
					DisplayErrorMessage(NULL, hr);
 				break;

			case IDS_MENU_SYNC:
				SynchronizeNodeData(pNode);
				break;
		}
	}
	COM_PROTECT_CATCH;

	return hrOK;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnExpand
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::OnExpand(ITFSNode *pNode,
									LPDATAOBJECT pDataObject,
									DWORD dwType,
									LPARAM arg,
									LPARAM lParam)
{
	HRESULT	hr = hrOK;
	SPIEnumInterfaceInfo	spEnumIf;
	SPIInterfaceInfo		spIf;
	SPIRtrMgrInterfaceInfo	spRmIf;
	
    // Windows NT Bug: 288427
    // This flag may also get set inside of the OnChange() call.
    // The OnChange() will enumerate and all interfaces.
    // They may have been added as the result of an OnChange()
    // because they were added before the OnExpand() was called.
    //
    // WARNING!  Be careful about adding anything to this function,
    //  since the m_bExpanded can be set in another function.
    // ----------------------------------------------------------------
	if (m_bExpanded)
		return hrOK;

	COM_PROTECT_TRY
	{
		
		CORg( m_spRouterInfo->EnumInterface(&spEnumIf) );

		while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
		{
			if (spIf->FindRtrMgrInterface(PID_IPX, &spRmIf) == hrOK)
			{
				// Now we create an interface node for this interface
				AddInterfaceNode(pNode, spIf, FALSE, NULL);
			}
			spRmIf.Release();
			spIf.Release();
		}

		//$CLIENT: Add the client interface (setup default data)
		// the only thing that we can do in synchronize is to
		// get the Administrative status
		AddInterfaceNode(pNode, NULL, TRUE, NULL);

		m_bExpanded = TRUE;

		// Now that we have all of the nodes, update the data for
		// all of the nodes
		SynchronizeNodeData(pNode);

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;



	m_bExpanded = TRUE;

	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::GetString
		Implementation of ITFSNodeHandler::GetString
		We don't need to do anything, since our root node is an extension
		only and thus can't do anything to the node text.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) IPXSummaryHandler::GetString(ITFSNode *pNode, int nCol)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());

	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		if (m_stTitle.IsEmpty())
			m_stTitle.LoadString(IDS_IPXSUMMARY_TITLE);
	}
	COM_PROTECT_CATCH;

	return m_stTitle;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnCreateDataObject
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{

		Assert(m_spRtrMgrInfo);
		
		CORg( CreateDataObjectFromRtrMgrInfo(m_spRtrMgrInfo,
											 type, cookie, m_spTFSCompData,
											 ppDataObject) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryHandler::Init
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::Init(IRtrMgrInfo *pRmInfo, IPXAdminConfigStream *pConfigStream)
{
    

	m_spRtrMgrInfo.Set(pRmInfo);
	if (pRmInfo)
		pRmInfo->GetParentRouterInfo(&m_spRouterInfo);
	m_pConfigStream = pConfigStream;
	
	// Also need to register for change notifications
	Assert(m_ulConnId == 0);
	m_spRtrMgrInfo->RtrAdvise(&m_IRtrAdviseSink, &m_ulConnId, 0);


//	m_IpxStats.SetConfigInfo(pConfigStream, IPXSTRM_STATS_IPX);

	return hrOK;
}

HRESULT IPXSummaryHandler::OnResultRefresh(ITFSComponent * pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
	HRESULT  hr = hrOK;
	SPITFSNode spNode, spParent;
    SPITFSResultHandler spParentRH;

	m_spNodeMgr->FindNode(cookie, &spNode);

    // forward this command to the parent to handle
    CORg (spNode->GetParent(&spParent));
	CORg (spParent->GetResultHandler(&spParentRH));

	CORg (spParentRH->Notify(pComponent, spParent->GetData(TFS_DATA_COOKIE), pDataObject, MMCN_REFRESH, arg, lParam));

Error:
    return hrOK;

}


/*!--------------------------------------------------------------------------
	IPXSummaryHandler::ConstructNode
		Initializes the root node (sets it up).
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::ConstructNode(ITFSNode *pNode, LPCTSTR pszName,
										IPXConnection *pIpxConn)
{
	Assert(pIpxConn);
	HRESULT			hr = hrOK;
	
	if (pNode == NULL)
		return hrOK;

	COM_PROTECT_TRY
	{
		// Need to initialize the data for the root node
		pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_IPX_NODE_GENERAL);
		pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_IPX_NODE_GENERAL);
		pNode->SetData(TFS_DATA_SCOPEID, 0);

        // This is a leaf node in the scope pane
        pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);

		m_cookie = reinterpret_cast<DWORD_PTR>(pNode);
		pNode->SetData(TFS_DATA_COOKIE, m_cookie);

		pNode->SetNodeType(&GUID_IPXSummaryNodeType);

		// Setup the node data
		pIpxConn->AddRef();
		SET_IPXSUMMARY_NODEDATA(pNode, pIpxConn);

//		m_IpxStats.SetConnectionData(pIpxConn);
	}
	COM_PROTECT_CATCH;

	if (!FHrSucceeded(hr))
	{
		SET_IPXSUMMARY_NODEDATA(pNode, NULL);
	}

	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryHandler::AddInterfaceNode
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	IPXSummaryHandler::AddInterfaceNode(ITFSNode *pParent, IInterfaceInfo *pIf, BOOL fClient, ITFSNode **ppNewNode)
{
	IPXSummaryInterfaceHandler *	pHandler;
	SPITFSResultHandler		spHandler;
	SPITFSNode				spNode;
	HRESULT					hr = hrOK;
	IPXConnection *			pIPXConn;
	BaseIPXResultNodeData *	pResultData = NULL;
	int						cBlocks = 0;
	SPIInfoBase				spInfoBase;
	SPIRtrMgrInterfaceInfo	spRmIf;

	// Create the handler for this node 
	pHandler = new IPXSummaryInterfaceHandler(m_spTFSCompData);
	spHandler = pHandler;
	CORg( pHandler->Init(m_spRtrMgrInfo, pIf, pParent) );
		
	pIPXConn = GET_IPXSUMMARY_NODEDATA(pParent);

	// Create a result item node (or a leaf node)
	CORg( CreateLeafTFSNode(&spNode,
							NULL,
							static_cast<ITFSNodeHandler *>(pHandler),
							static_cast<ITFSResultHandler *>(pHandler),
							m_spNodeMgr) );
	CORg( pHandler->ConstructNode(spNode, pIf, pIPXConn) );

	pResultData = GET_BASEIPXRESULT_NODEDATA(spNode);
	Assert(pResultData);
	ASSERT_BASEIPXRESULT_NODEDATA(pResultData);

	pResultData->m_fClient = fClient;

	if (pIf)
	{
		pIf->FindRtrMgrInterface(PID_IPX, &spRmIf);
		
		if (spRmIf)
			spRmIf->GetInfoBase(NULL, NULL, NULL, &spInfoBase);
		
		if (spInfoBase)
			spInfoBase->GetInfo(NULL, &cBlocks);
	}
	else
	{
		// This is a client, make it visible
		cBlocks = 1;
	}
	//Set the infobase here
	if ( !pResultData->m_fClient )
        pHandler->SetInfoBase (spInfoBase );
	// Make the node immediately visible
	if (cBlocks)
	{
		CORg( spNode->SetVisibilityState(TFS_VIS_SHOW) );
		CORg( spNode->Show() );
	}
	else
		CORg( spNode->SetVisibilityState(TFS_VIS_HIDE) );
	CORg( pParent->AddChild(spNode) );

	if (ppNewNode)
		*ppNewNode = spNode.Transfer();

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::SynchronizeNodeData
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::SynchronizeNodeData(ITFSNode *pThisNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	HRESULT				hr = hrOK;
	BOOL				fIsServiceRunning;
	SPITFSNodeEnum		spEnum;
	SPITFSNode			spNode;
	BaseIPXResultNodeData *	pResultData = NULL;
	IPXSummaryList		IPXSumList;
	IPXSummaryListEntry *pIPXSum = NULL;
	POSITION			pos;
	CString				st;
	SPIInterfaceInfo	spIf;
	int					i;
	SPIInfoBase			spInfoBase;
	SPIRtrMgrInterfaceInfo	spRmIf;
	InfoBlock *			pBlock;
	IPXSummaryListEntry	clientIPX;
	TCHAR				szNumber[32];
	CString				stNotAvailable;

	COM_PROTECT_TRY
	{
		//
		// If the service is started, retrieve the IP interface-stats table
		// and update the stats for each node.
		//
		CORg( IsRouterServiceRunning(m_spRouterInfo->GetMachineName(), NULL) );
		
		fIsServiceRunning = (hr == hrOK);

		// Gather all of the data
		GetIPXSummaryData(pThisNode, &IPXSumList);

		stNotAvailable.LoadString(IDS_IPX_NOT_AVAILABLE);
		
		// Now match the data up to the nodes
		pThisNode->GetEnum(&spEnum);
		spEnum->Reset();
		
		for ( ; spEnum->Next(1, &spNode, NULL) == hrOK; spNode.Release())
		{
			pResultData = GET_BASEIPXRESULT_NODEDATA(spNode);
			Assert(pResultData);
			ASSERT_BASEIPXRESULT_NODEDATA(pResultData);
			
			spIf.Release();
			spIf.Set(pResultData->m_spIf);
			spRmIf.Release();
			spInfoBase.Release();

			// If we don't have an spIf, then this HAS to be the
			// client interface
			if (pResultData->m_fClient)
			{
				GetClientInterfaceData(&clientIPX, m_spRtrMgrInfo);
				pIPXSum = &clientIPX;
			}
			else
			{
				// Look for this interface in the IPXSummaryList
				pIPXSum = NULL;
				pos = IPXSumList.GetHeadPosition();
				while (pos)
				{
					pIPXSum = IPXSumList.GetNext(pos);
					
					if (StriCmp(pIPXSum->m_stId, spIf->GetId()) == 0)
						break;
					pIPXSum = NULL;
				}
				
				// Update the interface type and administrative state
				spIf->FindRtrMgrInterface(PID_IPX, &spRmIf);
				spRmIf->GetInfoBase(NULL, NULL, NULL, &spInfoBase);

				pBlock = NULL;
				if (spInfoBase)
					spInfoBase->GetBlock(IPX_INTERFACE_INFO_TYPE, &pBlock, 0);

				if (pIPXSum)
				{
					if (pBlock)
						pIPXSum->m_dwAdminState =
							((PIPX_IF_INFO)pBlock->pData)->AdminState;

					pIPXSum->m_dwIfType = spIf->GetInterfaceType();
					pIPXSum->m_stTitle = spIf->GetTitle();
				}

			}

			// As a default fill in all of the strings with a '-'
			for (i=0; i<IPXSUM_MAX_COLUMNS; i++)
			{
				pResultData->m_rgData[i].m_stData = stNotAvailable;
				pResultData->m_rgData[i].m_dwData = 0;
			}

			if (spIf)
			{
				pResultData->m_rgData[IPXSUM_SI_NAME].m_stData = spIf->GetTitle();
				pResultData->m_rgData[IPXSUM_SI_TYPE].m_stData =
					IpxTypeToCString(spIf->GetInterfaceType());
			}
			else if (pIPXSum)
			{
				pResultData->m_rgData[IPXSUM_SI_NAME].m_stData = pIPXSum->m_stTitle;
			
				pResultData->m_rgData[IPXSUM_SI_TYPE].m_stData =
					IpxTypeToCString(pIPXSum->m_dwIfType);
			}
				
			// Did we find an entry for this interface?
			if (pIPXSum)
			{
				pResultData->m_rgData[IPXSUM_SI_ADMINSTATE].m_stData =
					IpxAdminStateToCString(pIPXSum->m_dwAdminState);
				pResultData->m_rgData[IPXSUM_SI_ADMINSTATE].m_dwData =
					pIPXSum->m_dwAdminState;
				
				pResultData->m_rgData[IPXSUM_SI_OPERSTATE].m_stData =
					IpxOperStateToCString(pIPXSum->m_dwOperState);

				if (!pResultData->m_fClient)
				{
					FormatIpxNetworkNumber(szNumber,
										   DimensionOf(szNumber),
										   pIPXSum->m_network,
										   DimensionOf(pIPXSum->m_network));
					st = szNumber;

					pResultData->m_rgData[IPXSUM_SI_NETWORK].m_stData = st;
					memcpy(&pResultData->m_rgData[IPXSUM_SI_NETWORK].m_dwData,
						   pIPXSum->m_network, sizeof(DWORD));
					FillInNumberData(pResultData, IPXSUM_SI_PACKETS_SENT,
									 pIPXSum->m_dwSent);
					FillInNumberData(pResultData, IPXSUM_SI_PACKETS_RCVD,
									 pIPXSum->m_dwRcvd);
					FillInNumberData(pResultData, IPXSUM_SI_OUT_FILTERED,
									 pIPXSum->m_dwOutFiltered);
					FillInNumberData(pResultData, IPXSUM_SI_OUT_DROPPED,
									 pIPXSum->m_dwOutDropped);
					FillInNumberData(pResultData, IPXSUM_SI_IN_FILTERED,
									 pIPXSum->m_dwInFiltered);
					FillInNumberData(pResultData, IPXSUM_SI_IN_NOROUTES,
									 pIPXSum->m_dwInNoRoutes);
					FillInNumberData(pResultData, IPXSUM_SI_IN_DROPPED,
									 pIPXSum->m_dwInDropped);
				}
				else
					pResultData->m_rgData[IPXSUM_SI_NETWORK].m_dwData = (DWORD) -1;

				
			}
			
			// Force MMC to redraw the nodes
			spNode->ChangeNode(RESULT_PANE_CHANGE_ITEM_DATA);

		}

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
		
	while (!IPXSumList.IsEmpty())
		delete IPXSumList.RemoveHead();
	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::GetClientInterfaceData
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::GetClientInterfaceData(IPXSummaryListEntry *pClient,
											   IRtrMgrInfo *pRm)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	SPIInfoBase	spInfoBase;
	InfoBlock *	pIpxBlock;
	InfoBlock *	pWanBlock;
	HRESULT		hr = hrOK;
	BOOL		fSave = FALSE;
	
	pRm->GetInfoBase(NULL, NULL, NULL, &spInfoBase);
	if (spInfoBase == NULL)
	{
		CORg( CreateInfoBase(&spInfoBase) );
	}
	
	if (spInfoBase->GetBlock(IPX_INTERFACE_INFO_TYPE, &pIpxBlock, 0) != hrOK)
	{
		// We couldn't find the block, add it in
		IPX_IF_INFO	ipx;

		ipx.AdminState = ADMIN_STATE_ENABLED;
		ipx.NetbiosAccept = ADMIN_STATE_DISABLED;
		ipx.NetbiosDeliver = ADMIN_STATE_DISABLED;

		CORg( spInfoBase->AddBlock(IPX_INTERFACE_INFO_TYPE,
								   sizeof(ipx),
								   (PBYTE) &ipx,
								   1,
								   0) );
		CORg( spInfoBase->GetBlock(IPX_INTERFACE_INFO_TYPE,
								   &pIpxBlock, 0) );
		fSave = TRUE;
	}

	
	if (spInfoBase->GetBlock(IPXWAN_INTERFACE_INFO_TYPE, &pWanBlock, 0) != hrOK)
	{
		// We couldn't find the block, add it in
		IPXWAN_IF_INFO	wan;

		wan.AdminState = ADMIN_STATE_ENABLED;

		CORg( spInfoBase->AddBlock(IPXWAN_INTERFACE_INFO_TYPE,
								   sizeof(wan),
								   (PBYTE) &wan,
								   1,
								   0) );
		CORg( spInfoBase->GetBlock(IPXWAN_INTERFACE_INFO_TYPE,
								   &pWanBlock, 0) );
		fSave = TRUE;
	}	

	pClient->m_stTitle.LoadString(IDS_IPX_DIAL_IN_CLIENTS);
	pClient->m_dwAdminState = ((PIPX_IF_INFO)pIpxBlock->pData)->AdminState;
	pClient->m_dwIfType = ROUTER_IF_TYPE_CLIENT;
	pClient->m_dwOperState = (DWORD) -1;
	pClient->m_dwSent = (DWORD) -1;
	pClient->m_dwRcvd = (DWORD) -1;
	pClient->m_dwOutFiltered = (DWORD) -1;
	pClient->m_dwOutDropped = (DWORD) -1;
	pClient->m_dwInFiltered = (DWORD) -1;
	pClient->m_dwInNoRoutes = (DWORD) -1;
	pClient->m_dwInDropped = (DWORD) -1;

	if (fSave)
	{
		pRm->Save(NULL,			// pszMachine
				  NULL,			// hMachine
				  NULL,			// hTransport
				  NULL,			// pGlobalInfo
				  spInfoBase,	// pClientInfo
				  0);			// dwDeleteProtocolId
	}

Error:
	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryHandler::GetIPXSummaryData
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	IPXSummaryHandler::GetIPXSummaryData(ITFSNode *pThisNode,
											 IPXSummaryList *pIpxSumList)
{
	HRESULT	hr = hrOK;
	IPXConnection *	pIPXConn;
	IPX_MIB_GET_INPUT_DATA	MibGetInputData;
	DWORD				IfSize = sizeof(IPX_INTERFACE);
	PIPX_INTERFACE		pIpxIf = NULL;
	SPMprMibBuffer		spMib;
	IPXSummaryListEntry *pEntry = NULL;
	DWORD				dwErr;

	pIPXConn = GET_IPXSUMMARY_NODEDATA(pThisNode);

	// Enumerate through all of the interfaces and grab the data
	// Get the interface table
	MibGetInputData.TableId = IPX_INTERFACE_TABLE;
	dwErr = ::MprAdminMIBEntryGetFirst(pIPXConn->GetMibHandle(),
									   PID_IPX,
									   IPX_PROTOCOL_BASE,
									   &MibGetInputData,
									   sizeof(IPX_MIB_GET_INPUT_DATA),
									   (LPVOID *) &pIpxIf,
									   &IfSize);
	hr = HRESULT_FROM_WIN32(dwErr);
	spMib = (LPBYTE) pIpxIf;

	while (FHrSucceeded(hr))
	{
		pEntry = new IPXSummaryListEntry;

		pEntry->m_stId = pIpxIf->InterfaceName;

		memcpy(pEntry->m_network, pIpxIf->NetNumber,
			   sizeof(pEntry->m_network));
		
		pEntry->m_dwOperState = pIpxIf->IfStats.IfOperState;
		pEntry->m_dwSent = pIpxIf->IfStats.OutDelivers;
		pEntry->m_dwRcvd = pIpxIf->IfStats.InDelivers;
		pEntry->m_dwOutFiltered = pIpxIf->IfStats.OutFiltered;
		pEntry->m_dwOutDropped = pIpxIf->IfStats.OutDiscards;
		pEntry->m_dwInFiltered = pIpxIf->IfStats.InFiltered;
		pEntry->m_dwInNoRoutes = pIpxIf->IfStats.InNoRoutes;
		pEntry->m_dwInDropped = pIpxIf->IfStats.InDiscards;

		pIpxSumList->AddTail(pEntry);
		pEntry = NULL;

		// Get the next data set
		MibGetInputData.MibIndex.InterfaceTableIndex.InterfaceIndex =
			pIpxIf->InterfaceIndex;
		spMib.Free();
		pIpxIf = NULL;

		dwErr = ::MprAdminMIBEntryGetNext(pIPXConn->GetMibHandle(),
										  PID_IPX,
										  IPX_PROTOCOL_BASE,
										  &MibGetInputData,
										  sizeof(IPX_MIB_GET_INPUT_DATA),
										  (LPVOID *) &pIpxIf,
										  &IfSize);
		hr = HRESULT_FROM_WIN32(dwErr);
		spMib = (PBYTE) pIpxIf;
	}

//Error:
	if (pEntry)
		delete pEntry;

	if (!FHrSucceeded(hr) && (hr != HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS)))
	{
		// clean out the list
		while (!pIpxSumList->IsEmpty())
			delete pIpxSumList->RemoveHead();
	}
	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryHandler::AddMenuItems
		Implementation of ITFSResultHandler::AddMenuItems
		Use this to add commands to the context menu of the blank areas
		of the result pane.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::AddMenuItems(ITFSComponent *pComponent,
											  MMC_COOKIE cookie,
											  LPDATAOBJECT pDataObject,
											  LPCONTEXTMENUCALLBACK pCallback,
											  long *pInsertionAllowed)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr = hrOK;
    SPITFSNode  spNode;

    m_spNodeMgr->FindNode(cookie, &spNode);
    
    // Call through to the regular OnAddMenuItems
    hr = OnAddMenuItems(spNode,
                        pCallback,
                        pDataObject,
                        CCT_RESULT,
                        TFS_COMPDATA_CHILD_CONTEXTMENU,
                        pInsertionAllowed);
    return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::Command
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryHandler::Command(ITFSComponent *pComponent,
									   MMC_COOKIE cookie,
									   int nCommandID,
									   LPDATAOBJECT pDataObject)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	SPITFSNode	spNode;
	HRESULT		hr = hrOK;

    m_spNodeMgr->FindNode(cookie, &spNode);
    hr = OnCommand(spNode,
                   nCommandID,
                   CCT_RESULT,
                   pDataObject,
                   TFS_COMPDATA_CHILD_CONTEXTMENU);
	return hr;
}



/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnNewInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::OnNewInterface()
{
	SPIRtrMgrInterfaceInfo	spRmIf;
	SPIInterfaceInfo		spIf;
	SPITFSNode				spNode;
	SPITFSNode				spSummaryNode;
	SPITFSNode				spNewNode;
	SPIComponentData		spComponentData;
	HRESULT					hr = hrOK;
	SPITFSNodeEnum			spEnumNode;
	BaseIPXResultNodeData *		pData;
	CWnd *					pWnd;
	CString					stIfTitle;

	m_spNodeMgr->FindNode(m_cookie, &spSummaryNode);
	spSummaryNode->Notify(TFS_NOTIFY_REMOVE_DELETED_NODES, 0);

	//
	// Retrieve the IPX router-manager info object
	// We already have this in m_spRtrMgrInfo
	//
	Assert(m_spRtrMgrInfo);

	// Display the UI for adding interfaces
	pWnd = CWnd::FromHandle(::FindMMCMainWindow());
	if (!AddRmInterfacePrompt(m_spRouterInfo, m_spRtrMgrInfo, &spRmIf, pWnd))
		return hrOK;

	//
	// Get the interface which we are adding IPX to.
	//
	CORg( m_spRouterInfo->FindInterface(spRmIf->GetInterfaceId(),
										&spIf) );
	Assert(spIf);

	//
	// Add the interface to the IPX router-manager
	//
	CORg( spIf->AddRtrMgrInterface(spRmIf, NULL /* pInfoBase */) );

	// We need to add an interface node (do it manually rather
	// than through the refresh mechanism).
	CORg( AddInterfaceNode(spSummaryNode, spIf, FALSE, &spNewNode) );

	// Show IPX interface configuration
	spComponentData.HrQuery(m_spTFSCompData);
	stIfTitle.Format(IDS_IPX_INTERFACE_TITLE, spIf->GetTitle());
	DoPropertiesOurselvesSinceMMCSucks(spNewNode,
									   spComponentData,
									   stIfTitle);

	
Error:
	return hr;
}
ImplementEmbeddedUnknown(IPXSummaryHandler, IRtrAdviseSink)

STDMETHODIMP IPXSummaryHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
	DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	InitPThis(IPXSummaryHandler, IRtrAdviseSink);
	SPITFSNode				spThisNode;
	SPITFSNode				spNode;
	SPITFSNodeEnum			spEnumNode;
	SPIEnumInterfaceInfo	spEnumIf;
	SPIInterfaceInfo		spIf;
	BOOL					fFound;
	BOOL					fPleaseAdd;
	BaseIPXResultNodeData *	pData;
	HRESULT					hr = hrOK;
	

	pThis->m_spNodeMgr->FindNode(pThis->m_cookie, &spThisNode);
	
	if (dwObjectType == ROUTER_OBJ_RmIf)
	{
		if (dwChangeType == ROUTER_CHILD_ADD)
		{
			// Enumerate through the list of interfaces looking for
			// the interfaces that have this protocol.  If we find
			// one, look for this interface in our list of nodes.
			spThisNode->GetEnum(&spEnumNode);

			CORg( pThis->m_spRouterInfo->EnumInterface(&spEnumIf) );

			spEnumIf->Reset();

			fPleaseAdd = FALSE;

			for (; spEnumIf->Next(1, &spIf, NULL) == hrOK; spIf.Release())
			{
				// Look for this interface in our list of nodes
				// If it's there than continue on
				fFound = FALSE;
				spEnumNode->Reset();
				spNode.Release();

				for (; spEnumNode->Next(1, &spNode, NULL) == hrOK; spNode.Release())
				{
					pData = GET_BASEIPXRESULT_NODEDATA(spNode);
					Assert(pData);
					ASSERT_BASEIPXRESULT_NODEDATA(pData);

					if (!pData->m_fClient && StriCmpW(pData->m_spIf->GetId(), spIf->GetId()) == 0)
					{
						fFound = TRUE;
						break;
					}
				}

				// If the interface was not found in the list of nodes,
				// then it is a candidate.  Now we have to see if the
				// interface supports this transport.
				if (!fFound && (spIf->FindRtrMgrInterface(pThis->m_spRtrMgrInfo->GetTransportId(), NULL) == hrOK))
				{
					// If this interface has this transport, and is NOT in
					// the current list of nodes then add this interface
					// to the UI
					pThis->AddInterfaceNode(spThisNode, spIf, FALSE, NULL);
					fPleaseAdd = TRUE;
				}
			}

            // If it's not expanded, then we haven't added
            // the dial-in clients node.    
            if (!pThis->m_bExpanded)
            {
                //$CLIENT: Add the client interface (setup default data)
                // the only thing that we can do in synchronize is to
                // get the Administrative status
                pThis->AddInterfaceNode(spThisNode, NULL, TRUE, NULL);

                fPleaseAdd = TRUE;
            }

			// Now that we have all of the nodes, update the data for
			// all of the nodes
			if (fPleaseAdd)
				pThis->SynchronizeNodeData(spThisNode);
			
            // Windows NT Bug : 288247
            // Set this here, so that we can avoid the nodes being
            // added in the OnExpand().
            pThis->m_bExpanded = TRUE;
		}
		else if (dwChangeType == ROUTER_CHILD_DELETE)
		{
			// Go through the list of nodes, if we cannot find the
			// node in the list of interfaces, delete the node
			spThisNode->GetEnum(&spEnumNode);
			spEnumNode->Reset();
			while (spEnumNode->Next(1, &spNode, NULL) == hrOK)
			{
				// Get the node data, look for the interface
				pData = GET_BASEIPXRESULT_NODEDATA(spNode);
				ASSERT_BASEIPXRESULT_NODEDATA(pData);
				
				//$CLIENT: if this is a client interface, we can't
				// delete the node
					
				if (!pData->m_fClient &&
					(LookupRtrMgrInterface(pThis->m_spRouterInfo,
										  pData->m_spIf->GetId(),
										  pThis->m_spRtrMgrInfo->GetTransportId(),
										  NULL) != hrOK))
				{
					// cannot find the interface, release this node!
					spThisNode->RemoveChild(spNode);
					spNode->Destroy();
				}
				spNode.Release();
				spIf.Release();
			}
			
		}
	}
	else if (dwChangeType == ROUTER_REFRESH)
	{
		if (ulConn == pThis->m_ulStatsConnId)
		{
//			pThis->m_IpxStats.PostRefresh();
		}
		else
		{
			pThis->SynchronizeNodeData(spThisNode);
		}
	}
	
Error:
	return hrOK;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::OnResultShow
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryHandler::OnResultShow(ITFSComponent *pTFSComponent, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
{
	BOOL	bSelect = (BOOL) arg;
	HRESULT	hr = hrOK;
	SPIRouterRefresh	spRefresh;
	SPITFSNode	spNode;

	BaseContainerHandler::OnResultShow(pTFSComponent, cookie, arg, lParam);

	if (bSelect)
	{
		// Call synchronize on this node
		m_spNodeMgr->FindNode(cookie, &spNode);
		if (spNode)
			SynchronizeNodeData(spNode);
	}

	// Un/Register for refresh advises
	if (m_spRouterInfo)
		m_spRouterInfo->GetRefreshObject(&spRefresh);

	if (spRefresh)
	{
		if (bSelect)
		{
			if (m_ulRefreshConnId == 0)
				spRefresh->AdviseRefresh(&m_IRtrAdviseSink, &m_ulRefreshConnId, 0);

			if (m_ulStatsConnId == 0)
				spRefresh->AdviseRefresh(&m_IRtrAdviseSink, &m_ulStatsConnId, 0);

		}
		else
		{
			if (m_ulRefreshConnId)
				spRefresh->UnadviseRefresh(m_ulRefreshConnId);
			m_ulRefreshConnId = 0;

			// We do not clean up the stats refresh on not show, since the
			// dialogs may still be up.
		}
	}
	
	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryHandler::CompareItems
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int) IPXSummaryHandler::CompareItems(
								ITFSComponent * pComponent,
								MMC_COOKIE cookieA,
								MMC_COOKIE cookieB,
								int nCol)
{
	// Get the strings from the nodes and use that as a basis for
	// comparison.
	SPITFSNode	spNode;
	SPITFSResultHandler	spResult;

	m_spNodeMgr->FindNode(cookieA, &spNode);
	spNode->GetResultHandler(&spResult);
	return spResult->CompareItems(pComponent, cookieA, cookieB, nCol);
}


/*---------------------------------------------------------------------------
	Class: IPXSummaryInterfaceHandler
 ---------------------------------------------------------------------------*/

IPXSummaryInterfaceHandler::IPXSummaryInterfaceHandler(ITFSComponentData *pCompData)
	: BaseIPXResultHandler(pCompData, COLUMNS_SUMMARY),
	m_ulConnId(0)
{
 	m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
	m_bState[MMC_VERB_PROPERTIES_INDEX] = TRUE;
	
 	m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
	m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
	
	m_verbDefault = MMC_VERB_PROPERTIES;
}

static const DWORD s_rgInterfaceImageMap[] =
	 {
	 ROUTER_IF_TYPE_HOME_ROUTER,	IMAGE_IDX_WAN_CARD,
	 ROUTER_IF_TYPE_FULL_ROUTER,	IMAGE_IDX_WAN_CARD,
	 ROUTER_IF_TYPE_CLIENT,			IMAGE_IDX_WAN_CARD,
	 ROUTER_IF_TYPE_DEDICATED,		IMAGE_IDX_LAN_CARD,
	 ROUTER_IF_TYPE_INTERNAL,		IMAGE_IDX_LAN_CARD,
	 ROUTER_IF_TYPE_LOOPBACK,		IMAGE_IDX_LAN_CARD,
	 -1,							IMAGE_IDX_WAN_CARD,	// sentinel value
	 };

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::ConstructNode
		Initializes the Domain node (sets it up).
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryInterfaceHandler::ConstructNode(ITFSNode *pNode, IInterfaceInfo *pIfInfo, IPXConnection *pIPXConn)
{
	HRESULT			hr = hrOK;
	int				i;
	
	if (pNode == NULL)
		return hrOK;

	COM_PROTECT_TRY
	{
		// Find the right image index for this type of node
		if (pIfInfo)
		{
			for (i=0; i<DimensionOf(s_rgInterfaceImageMap); i+=2)
			{
				if ((pIfInfo->GetInterfaceType() == s_rgInterfaceImageMap[i]) ||
					(-1 == s_rgInterfaceImageMap[i]))
					break;
			}
		}
		else
		{
			i = 2;	// if no interface, assume this is a client interface
		}

		// We allow deleting of demand-dial nodes only (not on
		// interfaces or the client node).
		if (pIfInfo &&
			(pIfInfo->GetInterfaceType() == ROUTER_IF_TYPE_FULL_ROUTER))
		{
			m_rgButtonState[MMC_VERB_DELETE_INDEX] = ENABLED;
			m_bState[MMC_VERB_DELETE_INDEX] = TRUE;
		}
		
		pNode->SetData(TFS_DATA_IMAGEINDEX, s_rgInterfaceImageMap[i+1]);
		pNode->SetData(TFS_DATA_OPENIMAGEINDEX, s_rgInterfaceImageMap[i+1]);
		
		pNode->SetData(TFS_DATA_SCOPEID, 0);

		pNode->SetData(TFS_DATA_COOKIE, reinterpret_cast<DWORD_PTR>(pNode));

		//$ Review: kennt, what are the different type of interfaces
		// do we distinguish based on the same list as above? (i.e. the
		// one for image indexes).
		pNode->SetNodeType(&GUID_IPXSummaryInterfaceNodeType);

		BaseIPXResultNodeData::Init(pNode, pIfInfo, pIPXConn);
		//now load the info base for this object
		hr = LoadInfoBase(pIPXConn);
	}
	COM_PROTECT_CATCH
	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::OnCreateDataObject
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		CORg( CreateDataObjectFromInterfaceInfo(m_spInterfaceInfo,
											 type, cookie, m_spTFSCompData,
											 ppDataObject) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::OnCreateDataObject
		Implementation of ITFSResultHandler::OnCreateDataObject
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::OnCreateDataObject(ITFSComponent *pComp, MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
{
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		CORg( CreateDataObjectFromInterfaceInfo(m_spInterfaceInfo,
											 type, cookie, m_spTFSCompData,
											 ppDataObject) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}



/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::RefreshInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
void IPXSummaryInterfaceHandler::RefreshInterface(MMC_COOKIE cookie)
{
	SPITFSNode	spNode;

	m_spNodeMgr->FindNode(cookie, &spNode);
	
	// Can't do it for a single node at this time, just refresh the
	// whole thing.
	ForwardCommandToParent(spNode, IDS_MENU_SYNC,
						   CCT_RESULT, NULL, 0);
}


/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::Init
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryInterfaceHandler::Init(IRtrMgrInfo *pRm, IInterfaceInfo *pIfInfo, ITFSNode *pParent)
{
	m_spRm.Set(pRm);
	m_spInterfaceInfo.Set(pIfInfo);
	if (pRm)
		pRm->GetParentRouterInfo(&m_spRouterInfo);


	BaseIPXResultHandler::Init(pIfInfo, pParent);
	return hrOK;
}


/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::DestroyResultHandler
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::DestroyResultHandler(MMC_COOKIE cookie)
{
	m_spInterfaceInfo.Release();
	m_spRouterInfo.Release();
	BaseIPXResultHandler::DestroyResultHandler(cookie);
	return hrOK;
}


/*---------------------------------------------------------------------------
	This is the list of commands that will show up for the result pane
	nodes.
 ---------------------------------------------------------------------------*/
static const SRouterNodeMenu	s_rgIfMenu[] =
{
	// Add items that go at the top here
	{ IDS_MENU_IPX_IF_ENABLE, IPXSummaryInterfaceHandler::GetEnableFlags,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },

	{ IDS_MENU_IPX_IF_DISABLE, IPXSummaryInterfaceHandler::GetDisableFlags,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },

	{ IDS_MENU_SEPARATOR, 0,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },

	{ IDS_MENU_UPDATE_ROUTES, IPXSummaryInterfaceHandler::GetUpdateRoutesFlags,
		CCM_INSERTIONPOINTID_PRIMARY_TOP },

};

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::AddMenuItems
		Implementation of ITFSResultHandler::AddMenuItems
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::AddMenuItems(
	ITFSComponent *pComponent,
	MMC_COOKIE cookie,
	LPDATAOBJECT lpDataObject, 
	LPCONTEXTMENUCALLBACK pContextMenuCallback, 
	long *pInsertionAllowed)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	HRESULT hr = S_OK;
	ULONG	ulFlags;
	UINT			i;
	CString		stMenu;
	SPITFSNode	spNode;
	IPXSummaryInterfaceHandler::SMenuData * pmenuData = new IPXSummaryInterfaceHandler::SMenuData;
		
	COM_PROTECT_TRY
	{
		m_spNodeMgr->FindNode(cookie, &spNode);
		
		// Now go through and add our menu items
		pmenuData->m_spNode.Set(spNode);
        pmenuData->m_spInterfaceInfo.Set(m_spInterfaceInfo);
        //Reload the infobase in case it has changed
        LoadInfoBase(NULL);
		pmenuData->m_spInfoBaseCopy = m_spInfoBase;
		hr = AddArrayOfMenuItems(spNode, s_rgIfMenu,
								 DimensionOf(s_rgIfMenu),
								 pContextMenuCallback,
								 *pInsertionAllowed,
                                 reinterpret_cast<INT_PTR>(pmenuData));
        
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

ULONG IPXSummaryInterfaceHandler::GetUpdateRoutesFlags(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
   DWORD dwIfType;
   SMenuData *  pData = reinterpret_cast<SMenuData *>(pUserData);

   if (pData->m_spInterfaceInfo)
	   dwIfType = pData->m_spInterfaceInfo->GetInterfaceType();
   else
	   dwIfType = ROUTER_IF_TYPE_INTERNAL;

   if ((dwIfType == ROUTER_IF_TYPE_LOOPBACK) ||
      (dwIfType == ROUTER_IF_TYPE_INTERNAL))
      return 0xFFFFFFFF;
   else
      return 0;
}


ULONG IPXSummaryInterfaceHandler::GetEnableFlags(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
	SMenuData *  pData = reinterpret_cast<SMenuData *>(pUserData);
	//BOOL bInterfaceIsEnabled = pData->m_spInterfaceInfo->IsInterfaceEnabled();


    IPX_IF_INFO *   pIpxIf = NULL;

    (pData->m_spInfoBaseCopy)->GetData(IPX_INTERFACE_INFO_TYPE, 0, (BYTE **) &pIpxIf);

	if ( pIpxIf )
		return (pIpxIf->AdminState == ADMIN_STATE_DISABLED ? 0: 0xFFFFFFFF );
	else
		return 0xFFFFFFFF;

    //if the interface is enabled then dont add the enable menu item
	//if (pData->m_spInterfaceInfo)
	   //return pData->m_spInterfaceInfo->IsInterfaceEnabled() ? 0xFFFFFFFF : 0;
	//else
	   //return 0xFFFFFFFF;
}

ULONG IPXSummaryInterfaceHandler::GetDisableFlags(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
	SMenuData *  pData = reinterpret_cast<SMenuData *>(pUserData);
    IPX_IF_INFO *   pIpxIf = NULL;

    (pData->m_spInfoBaseCopy)->GetData(IPX_INTERFACE_INFO_TYPE, 0, (BYTE **) &pIpxIf);

	if ( pIpxIf )
		return (pIpxIf->AdminState == ADMIN_STATE_ENABLED ? 0: 0xFFFFFFFF );
	else
		return 0xFFFFFFFF;

/*
	SMenuData *  pData = reinterpret_cast<SMenuData *>(pUserData);
	BOOL bInterfaceIsEnabled = pData->m_spInterfaceInfo->IsInterfaceEnabled();

	ATLASSERT("This is wrong!");
      
	if (pData->m_spInterfaceInfo)
		return pData->m_spInterfaceInfo->IsInterfaceEnabled() ? 0: 0xFFFFFFFF;
	else
		return 0xFFFFFFFF;
*/
}

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::Command
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::Command(ITFSComponent *pComponent,
									   MMC_COOKIE cookie,
									   int nCommandID,
									   LPDATAOBJECT pDataObject)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	HRESULT		hr = hrOK;

	switch (nCommandID)
	{
		case IDS_MENU_UPDATE_ROUTES:
			hr = OnUpdateRoutes(cookie);
			break;
        case IDS_MENU_IPX_IF_ENABLE:
            hr = OnEnableDisableIPX ( TRUE, cookie );
            break;
        case IDS_MENU_IPX_IF_DISABLE:
            hr = OnEnableDisableIPX ( FALSE, cookie );
            break;
        
	}

	if (!FHrSucceeded(hr))
		DisplayTFSErrorMessage(NULL);
    else
        RefreshInterface(cookie);
	return hr;
}




HRESULT IPXSummaryInterfaceHandler::SaveChanges()
{
    HRESULT     hr = hrOK;
    HANDLE      hTransport = NULL, hInterface = NULL;
    DWORD       dwErr = NO_ERROR;

    // By this time each page should have written its information out
    // to the infobase

    if (m_spInfoBase)
    {
        if (m_bClientInfoBase)
        {
            Assert(m_spRm);
            CORg( m_spRm->Save(m_spRm->GetMachineName(), 0, 0, NULL,
                         m_spInfoBase, 0));
        }
        else
        {
            // For IPX, we need to have the protocol information in the
            // infobase, BEFORE we add the interface to the running router.

            Assert(m_spRmIf);

            //
            // Need to set the infobase back to the registry
            //
            m_pIPXConn->DisconnectFromConfigServer();

            CWRg( ::MprConfigInterfaceGetHandle(
                                                m_pIPXConn->GetConfigHandle(),
                                                (LPTSTR) m_spRmIf->GetInterfaceId(),
                                                &hInterface) );

            // Get the transport handle
            dwErr = ::MprConfigInterfaceTransportGetHandle(
                m_pIPXConn->GetConfigHandle(),
                hInterface,// need hInterface
                PID_IPX,
                &hTransport);
            if (dwErr != ERROR_SUCCESS)
            {
                RtrMgrInterfaceCB   rmIfCB;

                m_spRmIf->CopyCB(&rmIfCB);

                dwErr = ::MprConfigInterfaceTransportAdd(
                    m_pIPXConn->GetConfigHandle(),
                    hInterface,
                    m_spRmIf->GetTransportId(),
                    rmIfCB.szId,
                    NULL, 0, &hTransport);
            }
            CWRg( dwErr );

            m_spRmIf->SetInfoBase(NULL, hInterface, hTransport, m_spInfoBase);


            //
            // Reload the infobase (to get the new data before calling
            // the final save).
            //
            m_spInfoBase.Release();
            m_spRmIf->GetInfoBase(NULL, hInterface, hTransport, &m_spInfoBase);

            //
            // Perform the final save (since we are passing in a non-NULL
            // infobase pointer) this will commit the information back
            // to the running router.
            //
            CORg( m_spRmIf->Save(m_spInterfaceInfo->GetMachineName(),
                           NULL, hInterface, hTransport, m_spInfoBase, 0));
        }

    }


Error:
	return hr;

}

HRESULT IPXSummaryInterfaceHandler::LoadInfoBase( IPXConnection *pIPXConn)
{
    Assert(pIPXConn);

    HRESULT         hr = hrOK;
    HANDLE          hTransport = NULL;
    LPCOLESTR       pszInterfaceId = NULL;
    SPIInfoBase     spInfoBase;
    BYTE *          pDefault;
    int             cBlocks = 0;
    if ( pIPXConn )
    {
        m_pIPXConn = pIPXConn;
        pIPXConn->AddRef();
    }

    // If configuring the client-interface, load the client-interface info,
    // otherwise, retrieve the interface being configured and load
    // its info.

    // The client interface doesn't have an ID
    if (m_spInterfaceInfo)
        pszInterfaceId = m_spInterfaceInfo->GetId();


    if ((pszInterfaceId == NULL) || (StrLenW(pszInterfaceId) == 0))
    {
        // Get the transport handle
        CWRg( ::MprConfigTransportGetHandle(m_pIPXConn->GetConfigHandle(),
                                            PID_IPX,
                                            &hTransport) );

        // Load the client interface info
        CORg( m_spRm->GetInfoBase(m_pIPXConn->GetConfigHandle(),
                                  hTransport,
                                  NULL,
                                  &spInfoBase) );
        m_bClientInfoBase = TRUE;
    }
    else
    {
        m_spRmIf.Release();

        CORg( m_spInterfaceInfo->FindRtrMgrInterface(PID_IPX,
            &m_spRmIf) );

        //
        //$ Opt: This should be made into a sync call rather
        // than a Load.

        //
        // Reload the information for this router-manager interface
        // This call could fail for valid reasons (if we are creating
        // a new interface, for example).
        //
        m_spRmIf->Load(m_spInterfaceInfo->GetMachineName(), NULL, NULL, NULL);

        //
        // The parameters are all NULL so that we can use the
        // default RPC handles.
        //
        m_spRmIf->GetInfoBase(NULL, NULL, NULL, &spInfoBase);
        m_bClientInfoBase = FALSE;
    }

    if (!spInfoBase)
    {
        // No info was found for the inteface
        // allocate a new InfoBase instead
        CORg( CreateInfoBase(&spInfoBase) );
    }

	m_spInfoBase.Release();
    CORg( AddIpxPerInterfaceBlocks(m_spInterfaceInfo, spInfoBase) );

    m_spInfoBase = spInfoBase.Transfer();

Error:
    return hr;
}

HRESULT IPXSummaryInterfaceHandler::OnEnableDisableIPX(BOOL fEnable, 
                                                        MMC_COOKIE cookie)
{	
    HRESULT hr = hrOK;
    IPX_IF_INFO *   pIpxIf = NULL;
    CORg( m_spInfoBase->GetData(IPX_INTERFACE_INFO_TYPE, 0, (BYTE **) &pIpxIf) );	
    pIpxIf->AdminState = (fEnable ? ADMIN_STATE_ENABLED: ADMIN_STATE_DISABLED);
	//now save the change here
	hr = SaveChanges();
	
Error:
    return hr;

}
/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::HasPropertyPages
		- 
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::HasPropertyPages 
(
	ITFSNode *			pNode,
	LPDATAOBJECT		pDataObject, 
	DATA_OBJECT_TYPES   type, 
	DWORD               dwType
)
{
	return hrTrue;
}

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::CreatePropertyPages
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::CreatePropertyPages
(
	ITFSNode *				pNode,
	LPPROPERTYSHEETCALLBACK lpProvider,
	LPDATAOBJECT			pDataObject, 
	LONG_PTR					handle, 
	DWORD					dwType
)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	HRESULT		hr = hrOK;
	IPXSummaryInterfaceProperties *	pProperties = NULL;
	SPIComponentData spComponentData;
	CString		stTitle;

	CORg( m_spNodeMgr->GetComponentData(&spComponentData) );

	if (m_spInterfaceInfo)
		stTitle.Format(IDS_IPXSUMMARY_IF_PAGE_TITLE,
					   m_spInterfaceInfo->GetTitle());
	else
		stTitle.LoadString(IDS_IPXSUMMARY_CLIENT_IF_PAGE_TITLE);
	
	pProperties = new IPXSummaryInterfaceProperties(pNode, spComponentData,
		m_spTFSCompData, stTitle);

	CORg( pProperties->Init(m_spRm, m_spInterfaceInfo) );

	if (lpProvider)
		hr = pProperties->CreateModelessSheet(lpProvider, handle);
	else
		hr = pProperties->DoModelessSheet();

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::CreatePropertyPages
		Implementation of ResultHandler::CreatePropertyPages
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP IPXSummaryInterfaceHandler::CreatePropertyPages
(
    ITFSComponent *         pComponent, 
	MMC_COOKIE				cookie,
	LPPROPERTYSHEETCALLBACK	lpProvider, 
	LPDATAOBJECT			pDataObject, 
	LONG_PTR					handle
)
{
	// Forward this call onto the NodeHandler::CreatePropertyPages
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	HRESULT	hr = hrOK;
	SPITFSNode	spNode;

	Assert( m_spNodeMgr );

	CORg( m_spNodeMgr->FindNode(cookie, &spNode) );

	// Call the ITFSNodeHandler::CreatePropertyPages
	hr = CreatePropertyPages(spNode, lpProvider, pDataObject, handle, 0);
	
Error:
	return hr;
}


/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::OnResultDelete
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryInterfaceHandler::OnResultDelete(ITFSComponent *pComponent,
	LPDATAOBJECT pDataObject,
	MMC_COOKIE cookie,
	LPARAM arg,
	LPARAM param)
{
	return OnRemoveInterface();
}

/*!--------------------------------------------------------------------------
	IPXSummaryInterfaceHandler::OnRemoveInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT IPXSummaryInterfaceHandler::OnRemoveInterface()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	// Prompt the user to make certain that IPX should be removed
	// from this interface

	SPIRouterInfo	spRouterInfo;
	HRESULT			hr = hrOK;
	SPITFSNodeHandler	spHandler;

	// Addref this node so that it won't get deleted before we're out
	// of this function
	spHandler.Set(this);
	
	if (AfxMessageBox(IDS_PROMPT_VERIFY_REMOVE_INTERFACE, MB_YESNO|MB_DEFBUTTON2) == IDNO)
		return HRESULT_FROM_WIN32(ERROR_CANCELLED);

	// Remove IPX from the interface
	hr = m_spInterfaceInfo->DeleteRtrMgrInterface(PID_IPX, TRUE);

	if (!FHrSucceeded(hr))
	{
		AfxMessageBox(IDS_ERR_DELETE_INTERFACE);
	}
	return hr;

}

HRESULT IPXSummaryInterfaceHandler::OnUpdateRoutes(MMC_COOKIE cookie)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState());
   
   BaseIPXResultNodeData *  pData;
   SPITFSNode     spNode;
   DWORD		dwErr = ERROR_SUCCESS;
   HRESULT        hr = hrOK;
   CString        stServiceDesc;

   m_spNodeMgr->FindNode(cookie, &spNode);

   pData = GET_BASEIPXRESULT_NODEDATA(spNode);
   ASSERT_BASEIPXRESULT_NODEDATA(pData);
   
   // Check to see if the service is started, if it isn't
   // start it

   CORg( IsRouterServiceRunning(m_spInterfaceInfo->GetMachineName(), NULL) );

   if (hr != hrOK)
   {
      // Ask the user if they want to start the service
      if (AfxMessageBox(IDS_PROMPT_SERVICESTART, MB_YESNO) != IDYES)
         CWRg( ERROR_CANCELLED );

      // Else start the service
      stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
      dwErr = TFSStartService(m_spInterfaceInfo->GetMachineName(), c_szRouter, stServiceDesc);
      if (dwErr != NO_ERROR)
      {
         CWRg( dwErr );
      }
   }


   // Update the routes

   CWRg( UpdateRoutes(m_spInterfaceInfo->GetMachineName(),
					  m_spInterfaceInfo->GetId(),
					  PID_IPX,
					  NULL) );

Error:
	AddRasErrorMessage(hr);
	return hr;
}