able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/ipxsnap/summary.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1884 lines
52 KiB
C++
Raw Blame History

/**********************************************************************/
/** 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;
}
Reference in a new issue View git blame Copy permalink