You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
354 lines
10 KiB
354 lines
10 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
root.cpp
|
|
Root node information (the root node is not displayed
|
|
in the MMC framework but contains information such as
|
|
all of the subnodes in this snapin).
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "util.h"
|
|
#include "riproot.h"
|
|
#include "reg.h"
|
|
#include "ripview.h" // RIP handlers
|
|
#include "ripstats.h"
|
|
#include "routprot.h" // IP_BOOTP
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
RipRootHandler implementation
|
|
---------------------------------------------------------------------------*/
|
|
|
|
DEBUG_DECLARE_INSTANCE_COUNTER(RipRootHandler)
|
|
|
|
extern const ContainerColumnInfo s_rgRIPParamsStatsColumnInfo[];
|
|
|
|
struct _ViewInfoColumnEntry
|
|
{
|
|
UINT m_ulId;
|
|
UINT m_cColumns;
|
|
const ContainerColumnInfo *m_prgColumn;
|
|
};
|
|
|
|
static const struct _ViewInfoColumnEntry s_rgViewColumnInfo[] =
|
|
{
|
|
{ RIPSTRM_STATS_RIPPARAMS, MVR_RIPPARAMS_COUNT, s_rgRIPParamsStatsColumnInfo },
|
|
};
|
|
|
|
RipRootHandler::RipRootHandler(ITFSComponentData *pCompData)
|
|
: RootHandler(pCompData)
|
|
{
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(RipRootHandler)
|
|
|
|
m_ConfigStream.Init(DimensionOf(s_rgViewColumnInfo));
|
|
|
|
// This will initialize the view information for the statistics
|
|
// dialogs. (which is why the fConfigurableColumns is set to TRUE).
|
|
for (int i=0; i<DimensionOf(s_rgViewColumnInfo); i++)
|
|
{
|
|
m_ConfigStream.InitViewInfo(s_rgViewColumnInfo[i].m_ulId,
|
|
TRUE /*fConfigurableColumns*/,
|
|
s_rgViewColumnInfo[i].m_cColumns,
|
|
TRUE,
|
|
s_rgViewColumnInfo[i].m_prgColumn);
|
|
}
|
|
}
|
|
|
|
|
|
STDMETHODIMP RipRootHandler::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 RootHandler::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;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//// IPersistStream interface members
|
|
|
|
STDMETHODIMP RipRootHandler::GetClassID
|
|
(
|
|
CLSID *pClassID
|
|
)
|
|
{
|
|
ASSERT(pClassID != NULL);
|
|
|
|
// Copy the CLSID for this snapin
|
|
*pClassID = CLSID_IPXRipExtension;
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RipRootHandler::OnExpand
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT RipRootHandler::OnExpand(ITFSNode *pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DWORD dwType,
|
|
LPARAM arg,
|
|
LPARAM lParam)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spNode;
|
|
SPIRtrMgrProtocolInfo spRmProt;
|
|
SPIRtrMgrInfo spRm;
|
|
SPIRouterInfo spRouterInfo;
|
|
LONG_PTR ulConnId;
|
|
|
|
// Grab the router info from the dataobject
|
|
spRm.Query(pDataObject);
|
|
Assert(spRm);
|
|
|
|
spRm->GetParentRouterInfo(&spRouterInfo);
|
|
|
|
// Setup the advise on the RtrMgr (to see when BootP is added/removed)
|
|
spRm->RtrAdvise(&m_IRtrAdviseSink, &ulConnId, 0);
|
|
|
|
// add things to our map for later
|
|
AddRtrObj(ulConnId, IID_IRtrMgrInfo, spRm);
|
|
AddScopeItem(spRm->GetMachineName(), (HSCOPEITEM) lParam);
|
|
|
|
hr = spRm->FindRtrMgrProtocol(IPX_PROTOCOL_RIP, &spRmProt);
|
|
if (!FHrOK(hr))
|
|
{
|
|
// Treat this as an already expanded node, we depend on
|
|
// the notification mechanism to let us know if something
|
|
// changes
|
|
goto Error;
|
|
}
|
|
|
|
CORg( AddProtocolNode(pNode, spRouterInfo) );
|
|
|
|
SetProtocolAdded(ulConnId, TRUE);
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RipRootHandler::OnCreateDataObject
|
|
Implementation of ITFSNodeHandler::OnCreateDataObject
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP RipRootHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPIRouterInfo spRouterInfo;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// this will always be NULL
|
|
if (spRouterInfo == NULL)
|
|
{
|
|
// If we haven't created the sub nodes yet, we still have to
|
|
// create a dataobject.
|
|
CDataObject * pObject = NULL;
|
|
SPIDataObject spDataObject;
|
|
SPITFSNode spNode;
|
|
SPITFSNodeHandler spHandler;
|
|
|
|
pObject = new CDataObject;
|
|
spDataObject = pObject; // do this so that it gets released correctly
|
|
Assert(pObject != NULL);
|
|
|
|
// Save cookie and type for delayed rendering
|
|
pObject->SetType(type);
|
|
pObject->SetCookie(cookie);
|
|
|
|
// Store the coclass with the data object
|
|
pObject->SetClsid(*(m_spTFSCompData->GetCoClassID()));
|
|
|
|
pObject->SetTFSComponentData(m_spTFSCompData);
|
|
|
|
hr = pObject->QueryInterface(IID_IDataObject,
|
|
reinterpret_cast<void**>(ppDataObject));
|
|
|
|
}
|
|
else
|
|
hr = CreateDataObjectFromRouterInfo(spRouterInfo,
|
|
type, cookie, m_spTFSCompData,
|
|
ppDataObject);
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
ImplementEmbeddedUnknown(RipRootHandler, IRtrAdviseSink)
|
|
|
|
STDMETHODIMP RipRootHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
|
|
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
|
|
{
|
|
InitPThis(RipRootHandler, IRtrAdviseSink);
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spNode;
|
|
SPIRtrMgrInfo spRm;
|
|
SPIRouterInfo spRouterInfo;
|
|
|
|
if (dwObjectType != ROUTER_OBJ_RmProt)
|
|
return hr;
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
CORg (pThis->GetRtrObj(ulConn, (IUnknown **) &spRm));
|
|
|
|
if (dwChangeType == ROUTER_CHILD_ADD)
|
|
{
|
|
// check to see if BootP is in the current list
|
|
if (spRm->FindRtrMgrProtocol(IPX_PROTOCOL_RIP, NULL) == hrOK)
|
|
{
|
|
// We found Bootp, add our child node if we
|
|
// don't have a child node
|
|
if (!pThis->IsProtocolAdded(ulConn))
|
|
{
|
|
spRm->GetParentRouterInfo(&spRouterInfo);
|
|
pThis->m_spNodeMgr->GetRootNode(&spNode);
|
|
pThis->AddProtocolNode(spNode, spRouterInfo);
|
|
pThis->SetProtocolAdded(ulConn, TRUE);
|
|
}
|
|
}
|
|
}
|
|
else if (dwChangeType == ROUTER_CHILD_DELETE)
|
|
{
|
|
if (spRm->FindRtrMgrProtocol(IPX_PROTOCOL_RIP, NULL) == hrFalse)
|
|
{
|
|
// couldn't find Bootp, delete all of our child nodes
|
|
pThis->m_spNodeMgr->GetRootNode(&spNode);
|
|
pThis->RemoveNode(spNode, spRm->GetMachineName());
|
|
pThis->SetProtocolAdded(ulConn, FALSE);
|
|
}
|
|
}
|
|
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RipRootHandler::DestroyHandler
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP RipRootHandler::DestroyHandler(ITFSNode *pNode)
|
|
{
|
|
RemoveAllNodes(pNode);
|
|
RemoveAllRtrObj();
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RipRootHandler::AddProtocolNode
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT RipRootHandler::AddProtocolNode(ITFSNode *pNode, IRouterInfo * pRouterInfo)
|
|
{
|
|
SPITFSNodeHandler spHandler;
|
|
RipNodeHandler * pHandler = NULL;
|
|
HRESULT hr = hrOK;
|
|
SPITFSNode spNode;
|
|
HSCOPEITEM hScopeItem, hOldScopeItem;
|
|
|
|
// Windows NT Bug : 246822
|
|
// Due to the server list programming model, we need to setup
|
|
// the proper scopeitem (so that MMC adds this to the proper
|
|
// node).
|
|
|
|
|
|
// Get the proper scope item for this node.
|
|
// ----------------------------------------------------------------
|
|
Verify( GetScopeItem(pRouterInfo->GetMachineName(), &hScopeItem) == hrOK);
|
|
|
|
|
|
// Get the old one and save it. place the new one in the node.
|
|
// ----------------------------------------------------------------
|
|
hOldScopeItem = pNode->GetData(TFS_DATA_SCOPEID);
|
|
pNode->SetData(TFS_DATA_SCOPEID, hScopeItem);
|
|
|
|
pHandler = new RipNodeHandler(m_spTFSCompData);
|
|
spHandler = pHandler;
|
|
CORg( pHandler->Init(pRouterInfo, &m_ConfigStream) );
|
|
|
|
CreateContainerTFSNode(&spNode,
|
|
&GUID_IPXRipNodeType,
|
|
static_cast<ITFSNodeHandler *>(pHandler),
|
|
static_cast<ITFSResultHandler *>(pHandler),
|
|
m_spNodeMgr);
|
|
|
|
// Call to the node handler to init the node data
|
|
pHandler->ConstructNode(spNode);
|
|
|
|
// Make the node immediately visible
|
|
spNode->SetVisibilityState(TFS_VIS_SHOW);
|
|
pNode->AddChild(spNode);
|
|
|
|
Error:
|
|
// Restore the scope item
|
|
pNode->SetData(TFS_DATA_SCOPEID, hOldScopeItem);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
RipRootHandler::CompareNodeToMachineName
|
|
This function is used by the RemoveNode() function.
|
|
|
|
Returns hrOK if this node is a DHCP relay node and corresponds
|
|
to the pszMachineName.
|
|
Returns hrFalse if this is not the indicated node.
|
|
Returns errors otherwise.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT RipRootHandler::CompareNodeToMachineName(ITFSNode *pNode,
|
|
LPCTSTR pszMachineName)
|
|
{
|
|
HRESULT hr = hrFalse;
|
|
|
|
// Should check that this is a RIP node
|
|
if (*(pNode->GetNodeType()) != GUID_IPXRipNodeType)
|
|
hr = hrFalse;
|
|
else
|
|
{
|
|
IPXConnection * pIPXConn;
|
|
|
|
pIPXConn = GET_RIP_NODEDATA(pNode);
|
|
if (StriCmp(pszMachineName, pIPXConn->GetMachineName()) == 0)
|
|
hr = hrOK;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|