windows-xp/Source/XPSP1/NT/net/mmc/mprsnap/atlkview.cpp

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

/*
    ATLKview.cpp
        
    FILE HISTORY:
        
*/

#include "stdafx.h"
#include "atlkprop.h"
#include "atlkview.h"
#include "atlkstrm.h"   // 
#include "atlkenv.h"
#include "coldlg.h"     // columndlg
#include "column.h"     // ComponentConfigStream
#include "rtrui.h"
#include "globals.h" // IP CB defaults
#include "infoi.h"      // InterfaceInfo
#include "cfgmgr32.h"   // for CM_ calls


static const GUID GUID_DevClass_Net = {0x4D36E972,0xE325,0x11CE,{0xBF,0xC1,0x08,0x00,0x2B,0xE1,0x03,0x18}};



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

const ContainerColumnInfo   s_rgATLKViewColumnInfo[] = 
{
    { IDS_ATLK_COL_ADAPTERS, CON_SORT_BY_STRING, TRUE, COL_IF_NAME },
    { IDS_ATLK_COL_STATUS, CON_SORT_BY_STRING, TRUE,    COL_STATUS },
    { IDS_ATLK_COL_NETRANGE, CON_SORT_BY_STRING, TRUE,  COL_SMALL_NUM},
};


/*---------------------------------------------------------------------------
    ATLKNodeHandler implementation
 ---------------------------------------------------------------------------*/

ATLKNodeHandler::ATLKNodeHandler(ITFSComponentData *pCompData)
    : BaseContainerHandler(pCompData, ATLK_COLUMNS, s_rgATLKViewColumnInfo),
    m_ulConnId(0),
    m_ulRefreshConnId(0),
    m_ulStatsConnId(0),
    m_hDevInfo(INVALID_HANDLE_VALUE)
{
    // Setup the verb states
    m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
    m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;

	m_nTaskPadDisplayNameId = IDS_ATLK_DISPLAY_NAME;
}


ATLKNodeHandler::~ATLKNodeHandler()
{
	if (m_hDevInfo != INVALID_HANDLE_VALUE)
	{
		SetupDiDestroyDeviceInfoList(m_hDevInfo);
		m_hDevInfo = INVALID_HANDLE_VALUE;
	}
}


STDMETHODIMP ATLKNodeHandler::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;   
}



/*!--------------------------------------------------------------------------
    ATLKNodeHandler::DestroyHandler
        Implementation of ITFSNodeHandler::DestroyHandler
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKNodeHandler::DestroyHandler(ITFSNode *pNode)
{
    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_spRmProt->RtrUnadvise(m_ulConnId);
    m_ulConnId = 0;
    m_spRmProt.Release();

    m_spRm.Release();

    m_spRouterInfo.Release();
    
	if (m_hDevInfo != INVALID_HANDLE_VALUE)
	{
		SetupDiDestroyDeviceInfoList(m_hDevInfo);
		m_hDevInfo = INVALID_HANDLE_VALUE;
	}
    return hrOK;
}

/*!--------------------------------------------------------------------------
    ATLKNodeHandler::HasPropertyPages
        Implementation of ITFSNodeHandler::HasPropertyPages
    NOTE: the root node handler has to over-ride this function to 
    handle the snapin manager property page (wizard) case!!!
    
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP 
ATLKNodeHandler::HasPropertyPages
(
ITFSNode *          pNode,
LPDATAOBJECT        pDataObject, 
DATA_OBJECT_TYPES   type, 
DWORD               dwType
)
{
    return hrOK;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::CreatePropertyPages
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP
ATLKNodeHandler::CreatePropertyPages
(
ITFSNode *              pNode,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT            pDataObject, 
LONG_PTR                    handle, 
DWORD                   dwType
)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT     hr = hrOK;
    return hr;
}


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

static const SRouterNodeMenu  s_rgIfNodeMenu[] =
{
    // Add items that go on the top menu here
    { IDS_MENU_ATLK_ENABLE, ATLKNodeHandler::ATLKEnableFlags,
        CCM_INSERTIONPOINTID_PRIMARY_TOP},
    {IDS_MENU_ATLK_DISABLE, ATLKNodeHandler::ATLKEnableFlags,
        CCM_INSERTIONPOINTID_PRIMARY_TOP},
};

bool IfATLKRoutingEnabled()
{
    RegKey regkey;
    DWORD dw=0;

    if ( ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE,c_szAppleTalkService) )
        regkey.QueryValue(c_szEnableRouter, dw);
    
    return (dw!=0) ? true : false;

};

ULONG ATLKNodeHandler::ATLKEnableFlags(const SRouterNodeMenu *pMenuData,
                                       INT_PTR pUserData)
{
    ULONG uStatus = MF_GRAYED;
    BOOL fATLKEnabled = ::IfATLKRoutingEnabled();
    
    if(IDS_MENU_ATLK_ENABLE == pMenuData->m_sidMenu)
        uStatus = fATLKEnabled ? MF_GRAYED : MF_ENABLED;
    else if(IDS_MENU_ATLK_DISABLE == pMenuData->m_sidMenu)
        uStatus = fATLKEnabled ? MF_ENABLED : MF_GRAYED;

    return uStatus;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::OnAddMenuItems
        Implementation of ITFSNodeHandler::OnAddMenuItems
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKNodeHandler::OnAddMenuItems(
                                            ITFSNode *pNode,
                                            LPCONTEXTMENUCALLBACK pContextMenuCallback, 
                                            LPDATAOBJECT lpDataObject, 
                                            DATA_OBJECT_TYPES type, 
                                            DWORD dwType,
                                            long *pInsertionAllowed)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = S_OK;
    ATLKNodeHandler::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; 
}

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

    COM_PROTECT_TRY
    {
        switch ( nCommandId )
        {
        case IDS_MENU_ATLK_ENABLE:
        case IDS_MENU_ATLK_DISABLE:

            if ( ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE,c_szAppleTalkService) )
            {
                CStop_StartAppleTalkPrint	MacPrint;

                DWORD dw = (IDS_MENU_ATLK_ENABLE == nCommandId) ? 1 : 0;
                regkey.SetValue(c_szEnableRouter, dw);

                if (FHrFailed(CATLKEnv::HrAtlkPnPSwithRouting()))
                {
                    AfxMessageBox(IDS_ERR_ATLK_CONFIG);
                }
                
                SynchronizeNodeData(pNode);
            }

            break;

        case IDS_MENU_REFRESH:
			hr = ForceGlobalRefresh(m_spRouterInfo);
            break;
        }
    }
    COM_PROTECT_CATCH;

    return hr;
}

HRESULT ATLKNodeHandler::OnVerbRefresh(ITFSNode *pNode,LPARAM arg,LPARAM lParam)
{
    // Now that we have all of the nodes, update the data for
    // all of the nodes
    return ForceGlobalRefresh(m_spRouterInfo);
}

HRESULT ATLKNodeHandler::OnResultRefresh(ITFSComponent * pComponent,
                                         LPDATAOBJECT pDataObject,
                                         MMC_COOKIE cookie,
                                         LPARAM arg,
                                         LPARAM lParam)
{
	return ForceGlobalRefresh(m_spRouterInfo);
}

/*!--------------------------------------------------------------------------
    ATLKNodeHandler::OnExpand
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::OnExpand(ITFSNode *pNode,
                                  LPDATAOBJECT pDataObject,
                                  DWORD dwType,
                                  LPARAM arg,
                                  LPARAM lParam)
{
    HRESULT         hr = hrOK;
    SPIInterfaceInfo        spIf;
    ATLKList        adapterList;
    ATLKListEntry * pAtlkEntry = NULL;
    
    if ( m_bExpanded )
        return hrOK;
        
    COM_PROTECT_TRY
    {
        SynchronizeNodeData(pNode);
    }
    COM_PROTECT_CATCH;

    // cleanup
    // ----------------------------------------------------------------
    while (!adapterList.IsEmpty())
        delete adapterList.RemoveHead();

    m_bExpanded = TRUE;

    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::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) ATLKNodeHandler::GetString(ITFSNode *pNode, int nCol)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = hrOK;

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

    return m_stTitle;
}

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

    COM_PROTECT_TRY
    {
        SPIDataObject  spdo;
        CDataObject*   pdo = NULL;

        pdo= new CDataObject;
        spdo = pdo;

        // Save cookie and type for delayed rendering
        pdo->SetType(type);
        pdo->SetCookie(cookie);

            // Store the coclass with the data object
        pdo->SetClsid(*(m_spTFSCompData->GetCoClassID()));

        pdo->SetTFSComponentData(m_spTFSCompData);

        *ppDataObject = spdo.Transfer();
    }
    COM_PROTECT_CATCH;
    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::Init(IRouterInfo *pRouter, ATLKConfigStream *pConfigStream)
{
    HRESULT hr=S_OK;
    RegKey regkey;

    m_spRouterInfo.Set(pRouter);

    m_pConfigStream = pConfigStream;

    return hrOK;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::ConstructNode
        Initializes the root node (sets it up).
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::ConstructNode(ITFSNode *pNode)
{
    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_INTERFACES);
        pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_INTERFACES);
        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<MMC_COOKIE>(pNode);
        pNode->SetData(TFS_DATA_COOKIE, m_cookie);

        pNode->SetNodeType(&GUID_ATLKNodeType);

    }
    COM_PROTECT_CATCH;

    return hr;
}



/*!--------------------------------------------------------------------------
    ATLKNodeHandler::AddInterfaceNode
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::AddInterfaceNode(ITFSNode *pParent, IInterfaceInfo *pIf, IInfoBase *pInfoBase, ITFSNode **ppNewNode)
{
    HRESULT                 hr = hrOK;
    Assert(pParent);
    Assert(pIf);

    ATLKInterfaceHandler *  pHandler;
    SPITFSResultHandler     spHandler;
    SPITFSNode              spNode;
    InterfaceNodeData*      pData;

    // Create the handler for this node 
    pHandler = new ATLKInterfaceHandler(m_spTFSCompData);
    spHandler = pHandler;
    CORg( pHandler->Init(pIf, pParent, m_pConfigStream) );

    // 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) );

    pData = GET_INTERFACENODEDATA(spNode);
    Assert(pData);

    pData->m_rgData[ATLK_SI_ADAPTER].m_stData = pIf->GetTitle();

    // If we don't have a pic, it means that we have just added
    // the protocol to the interface (and am not picking up a refresh).
    // The properties dialog will make the node visible.
    // Make the node immediately visible
    CORg( spNode->SetVisibilityState(TFS_VIS_SHOW) );
    CORg( spNode->Show() );
    CORg( pParent->AddChild(spNode) );

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

    Error:
    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::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 ATLKNodeHandler::AddMenuItems(ITFSComponent *pComponent,
                                           MMC_COOKIE cookie,
                                           LPDATAOBJECT pDataObject,
                                           LPCONTEXTMENUCALLBACK pCallback,
                                           long *pInsertionAllowed)
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    HRESULT hr = S_OK;
    ATLKNodeHandler::SMenuData  menuData;
    SPITFSNode      spNode;

    COM_PROTECT_TRY
    {
        m_spNodeMgr->FindNode(cookie, &spNode);
        menuData.m_spNode.Set(spNode);
        
        hr = AddArrayOfMenuItems(spNode, s_rgIfNodeMenu,
                                 DimensionOf(s_rgIfNodeMenu),
                                 pCallback,
                                 *pInsertionAllowed,
                                 reinterpret_cast<INT_PTR>(&menuData));
    }
    COM_PROTECT_CATCH;

    return hr; 
}


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

    Assert( m_spNodeMgr );

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

    hr = OnCommand(spNode, nCommandID, CCT_RESULT,
                  pDataObject, 0);

    Error:
    return hr;
}


ImplementEmbeddedUnknown(ATLKNodeHandler, IRtrAdviseSink)

STDMETHODIMP ATLKNodeHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
    DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
    InitPThis(ATLKNodeHandler, IRtrAdviseSink);
    SPITFSNode              spThisNode;
    SPITFSNode              spNode;
    SPITFSNodeEnum          spEnumNode;
    SPIEnumInterfaceInfo    spEnumIf;
    SPIInterfaceInfo        spIf;
    SPIRtrMgrInterfaceInfo  spRmIf;
    SPIInfoBase             spInfoBase;
    BOOL                    fPleaseAdd;
    BOOL                    fFound;
    InterfaceNodeData * pData;
    HRESULT                 hr = hrOK;

    pThis->m_spNodeMgr->FindNode(pThis->m_cookie, &spThisNode);

    if ( dwObjectType == ROUTER_OBJ_RmProtIf )
    {
    }
    else if ( dwChangeType == ROUTER_REFRESH )
    {
        if (ulConn == pThis->m_ulRefreshConnId)
            pThis->SynchronizeNodeData(spThisNode);
    }
    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::SynchronizeNodeData
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::SynchronizeNodeData(ITFSNode *pThisNode)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
    HRESULT hr = hrOK;

    SPITFSNodeEnum  spNodeEnum;
    SPITFSNode      spNode;
    CStringList     ifidList;
    InterfaceNodeData * pNodeData;
    int             i;
    POSITION        pos;
    CString szBuf;
    BOOL            bBoundToAtlk;
    
    // prepare AppleTalk Env information
    CATLKEnv        atlkEnv;

    // find the AppleTalk interface object
    RegKey regkey;
    DWORD dwEnableAtlkRouting =0;


    COM_PROTECT_TRY
    {   
        if ( ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE,
                                          c_szAppleTalkService) )
            regkey.QueryValue(c_szEnableRouter, dwEnableAtlkRouting);

        // winsock on adapter only
        atlkEnv.SetFlags(CATLKEnv::ATLK_ONLY_ONADAPTER);
        
        // load up container of adapters names
        atlkEnv.FetchRegInit();


        // Mark all of the nodes
        pThisNode->GetEnum(&spNodeEnum);

        UnmarkAllNodes(pThisNode, spNodeEnum);

        
        // Iterate through the nodes, looking for the
        // data associated with the node

        spNodeEnum->Reset();
        for ( ; spNodeEnum->Next(1, &spNode, NULL) == hrOK; spNode.Release() )
        {
            CAdapterInfo *  pAdapterInfo = NULL;
            CString         stIfName;
            
            pNodeData = GET_INTERFACENODEDATA(spNode);
            Assert(pNodeData);

            stIfName = pNodeData->spIf->GetId();

            bBoundToAtlk = FALSE;
            
            // Check to see that the adapter is bound to Appletalk.
            // ----------------------------------------------------
            if (!FHrOK(CATLKEnv::IsAdapterBoundToAtlk((LPWSTR) (LPCWSTR) stIfName, &bBoundToAtlk)))
                continue;
            
            // If it's not bound to Appletalk, we're not interested
            // in the adapter.
            // ----------------------------------------------------
            if (!bBoundToAtlk)
                continue;
            
            // Need to check to see if this is a valid
            // netcard.  We may have a GUID, but it may not
            // be working.
            // ----------------------------------------------------
            if (!FIsFunctioningNetcard(stIfName))
                continue;
                    
            // Search for this ID in the atlkEnv
            pAdapterInfo = atlkEnv.FindAdapter(stIfName);
          
            // Initialize the strings for this node.
//            pNodeData->m_rgData[ATLK_SI_ADAPTER].m_stData = stIfName;

            pNodeData->m_rgData[ATLK_SI_STATUS].m_stData = _T("-");
            pNodeData->m_rgData[ATLK_SI_STATUS].m_dwData = 0;

            pNodeData->m_rgData[ATLK_SI_NETRANGE].m_stData = _T("-"); 
            pNodeData->m_rgData[ATLK_SI_NETRANGE].m_dwData = 0;

              
            // If we can't find the adapter, skip it, it will get
            // removed.
            if (pAdapterInfo == NULL)
            {
                TRACE1("The adapter GUID %s was not found in appletalk\\parameters\\adapters key", stIfName);
                continue;
            }

            
            // Ok, this node exists, mark the node
            pNodeData->dwMark = TRUE;
            pAdapterInfo->m_fAlreadyShown = true;
                        


            // Reload some of the adapter-specific information
            {
                CWaitCursor wait;
                hr = atlkEnv.ReloadAdapter(pAdapterInfo, false);
            }

            if(hr != S_OK)
            {
				DisplayTFSErrorMessage(NULL);

				// we are not removing it, since a later refresh
                // may have the information avaible
                
				// remove the adaptor from the list				
                // pThisNode->RemoveChild(spNode);
                continue;
            }
    
            SetAdapterData(spNode, pAdapterInfo, dwEnableAtlkRouting);

            // Redraw the node
            spNode->ChangeNode(RESULT_PANE_CHANGE_ITEM_DATA);
        }
        
        spNode.Release();

        // Now remove all unmarked nodes
        RemoveAllUnmarkedNodes(pThisNode, spNodeEnum);


        // Now go through the list of adapters and find the ones
        // that need to be added into the list.
        // ------------------------------------------------------------

        CATLKEnv::AI p;
        CAdapterInfo* pAI=NULL;
        
        for ( p= atlkEnv.m_adapterinfolist.begin();
              p!= atlkEnv.m_adapterinfolist.end() ;
              p++ )
        {
            pAI = *p;

            if (!pAI->m_fAlreadyShown)
            {
                SPIInterfaceInfo    spIf;
                CString stKey(pAI->m_regInfo.m_szAdapter);
                SPITFSNode      spNewNode;
                SPSZ			spszTitle;

                bBoundToAtlk = FALSE;

                // Check to see that the adapter is bound to Appletalk.
                // ----------------------------------------------------
                if (!FHrOK(CATLKEnv::IsAdapterBoundToAtlk((LPWSTR) (LPCWSTR) stKey, &bBoundToAtlk)))
                    continue;

                // If it's not bound to Appletalk, we're not interested
                // in the adapter.
                // ----------------------------------------------------
                if (!bBoundToAtlk)
                    continue;
                
                // Need to check to see if this is a valid
                // netcard.  We may have a GUID, but it may not
                // be working.
                // ----------------------------------------------------
                if (!FIsFunctioningNetcard(stKey))
                    continue;
                    
                if (!FHrOK(m_spRouterInfo->FindInterface(stKey, &spIf)))
                {
                    // We didn't find the IInterfaceInfo, we will
                    // have to create one ourselves.
                    // ------------------------------------------------
                    CreateInterfaceInfo(&spIf,
                                        stKey,
                                        ROUTER_IF_TYPE_DEDICATED);

                    if (FHrOK(InterfaceInfo::FindInterfaceTitle(NULL,
                                        stKey,
                                        &spszTitle)))
                        spIf->SetTitle(spszTitle);
                    else
                        spIf->SetTitle(spIf->GetId());
                }
                AddInterfaceNode(pThisNode, spIf, NULL, &spNewNode);
                
                {
                    CWaitCursor wait;
                    hr = atlkEnv.ReloadAdapter(pAI, false);
                }

                SetAdapterData(spNewNode, pAI, dwEnableAtlkRouting);
                
                // Redraw the node
                spNewNode->ChangeNode(RESULT_PANE_CHANGE_ITEM_DATA);
            }
        }
        
    }
    COM_PROTECT_CATCH;

    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::OnResultShow
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::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);

/* WeiJiang : only do reload data on Expand and Refresh
    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;
        }
    }

    return hr;
}


/*!--------------------------------------------------------------------------
    ATLKNodeHandler::CompareItems
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(int) ATLKNodeHandler::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);
}


/*!--------------------------------------------------------------------------
	ATLKNodeHandler::FIsFunctioningNetcard
		Takes a GUID and checks to see if the netcard is functioning.

        By default, we return FALSE if any call in this fails.

        This code is modeled off of the netcfg code.
	Author: KennT
 ---------------------------------------------------------------------------*/
BOOL ATLKNodeHandler::FIsFunctioningNetcard(LPCTSTR pszGuid)
{
    CString         stMachine;
    CONFIGRET       cfgRet;
    SP_DEVINFO_DATA DevInfo;
    RegKey          rkNet;
    RegKey          rkNetcard;
    HRESULT         hr = hrOK;
    BOOL            fReturn = FALSE;
    CString         stPnpInstanceId;
    ULONG           ulProblem, ulStatus;
    DWORD           dwErr = ERROR_SUCCESS;

    Assert(IsLocalMachine(m_spRouterInfo->GetMachineName()));


    if (m_hDevInfo == INVALID_HANDLE_VALUE)
    {
        stMachine = m_spRouterInfo->GetMachineName();
        if (IsLocalMachine(stMachine))
            {
            m_hDevInfo = SetupDiCreateDeviceInfoList(
                (LPGUID) &GUID_DevClass_Net,
                NULL);
            }
        else
        {
            // Append on the "\\\\" if needed
			if (StrniCmp((LPCTSTR) stMachine, _T("\\\\"), 2) != 0)
			{
				stMachine = _T("\\\\");
				stMachine += m_spRouterInfo->GetMachineName();
            }
			
			m_hDevInfo = SetupDiCreateDeviceInfoListEx(
				(LPGUID) &GUID_DevClass_Net,
				NULL,
				(LPCTSTR) stMachine,
				0);
        }
    }

    Assert(m_hDevInfo != INVALID_HANDLE_VALUE);

    // If m_hDevInfo is still invalid, then return a
    // functioning device.
    // ----------------------------------------------------------------
    if (m_hDevInfo == INVALID_HANDLE_VALUE)
        return fReturn;

    // Get the PnpInstanceID
    // ----------------------------------------------------------------
    CWRg( rkNet.Open(HKEY_LOCAL_MACHINE, c_szNetworkCardsNT5Key, KEY_READ,
                     m_spRouterInfo->GetMachineName()) );

    CWRg( rkNetcard.Open(rkNet, pszGuid, KEY_READ) );

    dwErr = rkNetcard.QueryValue(c_szPnpInstanceID, stPnpInstanceId);

    // Windows NT Bug : 273284
    // This is a result of the new Bindings Engine
    // some of the registry keys were moved around
    // ----------------------------------------------------------------
    if (dwErr != ERROR_SUCCESS)
    {
        RegKey  rkConnection;
        
        // Need to open another key to get this info.
        CWRg( rkConnection.Open(rkNetcard, c_szRegKeyConnection, KEY_READ) );

        CWRg( rkConnection.QueryValue(c_szPnpInstanceID, stPnpInstanceId) );
    }

    // Now get the info for this device
    // ----------------------------------------------------------------
    ::ZeroMemory(&DevInfo, sizeof(DevInfo));
    DevInfo.cbSize = sizeof(DevInfo);

    if (!SetupDiOpenDeviceInfo(m_hDevInfo,
                               (LPCTSTR) stPnpInstanceId,
                               NULL,
                               0,
                               &DevInfo))
    {
        CWRg( GetLastError() );
    }
        

    cfgRet = CM_Get_DevNode_Status_Ex(&ulStatus, &ulProblem,
                                      DevInfo.DevInst, 0, NULL);;
    if (CR_SUCCESS == cfgRet)
    {
        // ulProblem is returned by calling CM_Get_DevNode_Status_Ex
        //
        // "Functioning" means the device is enabled and started
        // with no problem codes, or it is disabled and stopped with
        // no problem codes.

        fReturn = ( (ulProblem == 0) || (ulProblem == CM_PROB_DISABLED));
    }

Error:
    return fReturn;
}



/*!--------------------------------------------------------------------------
	ATLKNodeHandler::UnmarkAllNodes
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::UnmarkAllNodes(ITFSNode *pNode, ITFSNodeEnum *pEnum)
{
	SPITFSNode	spChildNode;
	InterfaceNodeData * pNodeData;
	
	pEnum->Reset();
	for ( ;pEnum->Next(1, &spChildNode, NULL) == hrOK; spChildNode.Release())
	{
		pNodeData = GET_INTERFACENODEDATA(spChildNode);
		Assert(pNodeData);
		
		pNodeData->dwMark = FALSE;			
	}
	return hrOK;
}

/*!--------------------------------------------------------------------------
	ATLKNodeHandler::RemoveAllUnmarkedNodes
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::RemoveAllUnmarkedNodes(ITFSNode *pNode, ITFSNodeEnum *pEnum)
{
	HRESULT 	hr = hrOK;
	SPITFSNode	spChildNode;
	InterfaceNodeData * pNodeData;
	
	pEnum->Reset();
	for ( ;pEnum->Next(1, &spChildNode, NULL) == hrOK; spChildNode.Release())
	{
		pNodeData = GET_INTERFACENODEDATA(spChildNode);
		Assert(pNodeData);
		
		if (pNodeData->dwMark == FALSE)
		{
			pNode->RemoveChild(spChildNode);
			spChildNode->Destroy();
		}
	}

	return hr;
}

/*!--------------------------------------------------------------------------
	ATLKNodeHandler::SetAdapterData
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKNodeHandler::SetAdapterData(ITFSNode *pNode,
                                        CAdapterInfo *pAdapter,
                                        DWORD dwEnableAtlkRouting)
{
    InterfaceNodeData * pNodeData;
    
    pNodeData = GET_INTERFACENODEDATA(pNode);
    Assert(pNodeData);

    // if the adapter is the default
    UINT    ids = 0;
    INT     lRange, uRange;
    
    if(pAdapter->m_regInfo.m_fDefAdapter)
    {
        if (dwEnableAtlkRouting)
        {
            if (pAdapter->m_regInfo.m_dwSeedingNetwork)
                ids = IDS_ATLK_COL_STATUS_SEEDROUTING_DEF;
            else
                ids = IDS_ATLK_COL_STATUS_ROUTING_DEF;
        }
        else
            ids = IDS_ATLK_COL_STATUS_NONROUTING_DEF;
    }
    else
    {
        if (dwEnableAtlkRouting)
        {
            if (pAdapter->m_regInfo.m_dwSeedingNetwork)
                ids = IDS_ATLK_COL_STATUS_SEEDROUTING;
            else
                ids = IDS_ATLK_COL_STATUS_ROUTING;
        }
        else
            ids = IDS_ATLK_COL_STATUS_NONROUTING;
    }
    
    
    // range column
    if (pAdapter->m_regInfo.m_dwSeedingNetwork)
    {
        lRange = pAdapter->m_regInfo.m_dwRangeLower;
        uRange = pAdapter->m_regInfo.m_dwRangeUpper;
    }
    else
    {
        lRange = pAdapter->m_dynInfo.m_dwRangeLower;
        uRange = pAdapter->m_dynInfo.m_dwRangeUpper;
    }
    
    // write data
    if(uRange == 0 && lRange == 0 && 
       !dwEnableAtlkRouting && 
       !pAdapter->m_regInfo.m_dwSeedingNetwork)
        ids = IDS_ATLK_COL_STATUS_NETWORKNOTSEEDED;
    
    pNodeData->m_rgData[ATLK_SI_STATUS].m_stData.LoadString(ids);
    pNodeData->m_rgData[ATLK_SI_STATUS].m_dwData = 0;
    
    if(uRange == 0 && lRange == 0)
        pNodeData->m_rgData[ATLK_SI_NETRANGE].m_stData.Format(_T("-")); 
    else
        pNodeData->m_rgData[ATLK_SI_NETRANGE].m_stData.Format(_T("%-d-%-d"), 
            lRange, uRange);
    pNodeData->m_rgData[ATLK_SI_NETRANGE].m_dwData = 0;
    

    return hrOK;
}




/*---------------------------------------------------------------------------
    Class: ATLKInterfaceHandler
 ---------------------------------------------------------------------------*/

ATLKInterfaceHandler::ATLKInterfaceHandler(ITFSComponentData *pCompData)
: BaseResultHandler(pCompData, ATLK_COLUMNS)
{
    m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
    m_bState[MMC_VERB_PROPERTIES_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
};

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

    if ( pNode == NULL )
        return hrOK;

    COM_PROTECT_TRY
    {
        // Need to initialize the data for the Domain node

        // Find the right image index for this type of node
        for ( i=0; i<DimensionOf(s_rgInterfaceImageMap); i+=2 )
        {
            if ( (pIfInfo->GetInterfaceType() == s_rgInterfaceImageMap[i]) ||
                 (-1 == s_rgInterfaceImageMap[i]) )
                break;
        }

        if ( pIfInfo->GetInterfaceType() == ROUTER_IF_TYPE_INTERNAL ||
             pIfInfo->GetInterfaceType() == ROUTER_IF_TYPE_HOME_ROUTER )
        {
            m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = HIDDEN;
            m_bState[MMC_VERB_PROPERTIES_INDEX] = FALSE;

            m_rgButtonState[MMC_VERB_DELETE_INDEX] = HIDDEN;
            m_bState[MMC_VERB_DELETE_INDEX] = FALSE;
        }

        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<ULONG_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_ATLKInterfaceNodeType);

//    m_ATLKInterfaceStats.SetConnectionData(pIPConn);

        InterfaceNodeData::Init(pNode, pIfInfo);
    }
    COM_PROTECT_CATCH
    return hr;
}

/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::OnCreateDataObject
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::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;
}


/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::OnCreateDataObject
        Implementation of ITFSResultHandler::OnCreateDataObject
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::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;
}



/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::RefreshInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
void ATLKInterfaceHandler::RefreshInterface(MMC_COOKIE cookie)
{
    SPITFSNode  spNode;
    SPITFSNode  spParent;
    SPITFSNodeHandler   spHandler;

    m_spNodeMgr->FindNode(cookie, &spNode);

    // Can't do it for a single node at this time, just refresh the
    // whole thing.
    spNode->GetParent(&spParent);
    spParent->GetHandler(&spHandler);

    spHandler->OnCommand(spParent,
                         IDS_MENU_REFRESH,
                         CCT_RESULT, NULL, 0);
}


/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::Init
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKInterfaceHandler::Init(IInterfaceInfo *pIfInfo, ITFSNode *pParent, ATLKConfigStream *pConfigStream)
{
    Assert(pIfInfo);

    m_spInterfaceInfo.Set(pIfInfo);

// m_ATLKInterfaceStats.SetConfigInfo(pConfigStream, ATLKSTRM_IFSTATS_ATLKNBR);

    BaseResultHandler::Init(pIfInfo, pParent);

    return hrOK;
}


/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::DestroyResultHandler
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::DestroyResultHandler(MMC_COOKIE cookie)
{
// WaitForStatisticsWindow(&m_ATLKInterfaceStats);

    m_spInterfaceInfo.Release();
    BaseResultHandler::DestroyResultHandler(cookie);
    return hrOK;
}


/*---------------------------------------------------------------------------
    This is the list of commands that will show up for the result pane
    nodes.
 ---------------------------------------------------------------------------*/
struct SIPInterfaceNodeMenu
{
    ULONG   m_sidMenu;          // string/command id for this menu item
    ULONG   (ATLKInterfaceHandler:: *m_pfnGetMenuFlags)(ATLKInterfaceHandler::SMenuData *);
    ULONG   m_ulPosition;
};

/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::AddMenuItems
        Implementation of ITFSResultHandler::AddMenuItems
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::AddMenuItems(
                                               ITFSComponent *pComponent,
                                               MMC_COOKIE cookie,
                                               LPDATAOBJECT lpDataObject, 
                                               LPCONTEXTMENUCALLBACK pContextMenuCallback, 
                                               long *pInsertionAllowed)
{
    return hrOK;
}

/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::Command
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::Command(ITFSComponent *pComponent,
                                           MMC_COOKIE cookie,
                                           int nCommandID,
                                           LPDATAOBJECT pDataObject)
{
    return hrOK;
}

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

/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::CreatePropertyPages
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::CreatePropertyPages
(
ITFSNode *              pNode,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT            pDataObject, 
LONG_PTR                    handle, 
DWORD                   dwType)
{
    HRESULT     hr = hrOK;

    AFX_MANAGE_STATE(AfxGetStaticModuleState());
    CATLKPropertySheet *    pProperties = NULL;
    SPIComponentData spComponentData;
    CString     stTitle;
    SPIRouterInfo   spRouter;
    SPIRtrMgrInfo   spRm;

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

    stTitle.Format(IDS_ATLK_PROPPAGE_TITLE,
                   m_spInterfaceInfo->GetTitle());

    pProperties = new CATLKPropertySheet (pNode, spComponentData,
                                          m_spTFSCompData, stTitle);

// CORg( m_spInterfaceInfo->GetParentRouterInfo(&spRouter) );
// CORg( spRouter->FindRtrMgr(PID_IP, &spRm) );

    CORg( pProperties->Init(m_spInterfaceInfo) );

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

    Error:
    // Is this the right way to destroy the sheet?
    if ( !FHrSucceeded(hr) )
        delete pProperties;

    return hr;
}

/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::CreatePropertyPages
        Implementation of ResultHandler::CreatePropertyPages
    Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP ATLKInterfaceHandler::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;
}



/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::OnResultDelete
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKInterfaceHandler::OnResultDelete(ITFSComponent *pComponent,
                                             LPDATAOBJECT pDataObject,
                                             MMC_COOKIE cookie,
                                             LPARAM arg,
                                             LPARAM param)
{
    SPITFSNode  spNode;
    m_spNodeMgr->FindNode(cookie, &spNode);
    return OnRemoveInterface(spNode);
}


/*!--------------------------------------------------------------------------
    ATLKInterfaceHandler::OnRemoveInterface
        -
    Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT ATLKInterfaceHandler::OnRemoveInterface(ITFSNode *pNode)
{

    return hrOK;
}