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

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

/*
	info.cpp
		
    FILE HISTORY:
		Wei Jiang : 10/27/98 --- Add SetExternalRefreshObject to
                            IRouterInfo and RouterInfo implementation
                            to allow multiple router info the share
                            the same AutoRefresh settings.
*/

#include "stdafx.h"
#include "lsa.h"
#include "infoi.h"
#include "rtrstr.h"			// common router strings
#include "refresh.h"		// RouterRefreshObject
#include "routprot.h"
#include "rtrutilp.h"

long	s_cConnections = 1;	// use for AdviseSink connection ids



TFSCORE_API(HRESULT) CreateRouterInfo(IRouterInfo **ppRouterInfo, HWND hWndSync, LPCWSTR szMachine)
{
	Assert(ppRouterInfo);
	
	HRESULT	hr = hrOK;
	RouterInfo *	pRouterInfo = NULL;
	
	COM_PROTECT_TRY
	{
		pRouterInfo = new RouterInfo(hWndSync, szMachine);
		*ppRouterInfo = pRouterInfo;
	}
	COM_PROTECT_CATCH;

	return hr;
}

IMPLEMENT_WEAKREF_ADDREF_RELEASE(RouterInfo);

STDMETHODIMP RouterInfo::QueryInterface(REFIID iid,void **ppv)
{ 
	*ppv = 0; 
	if (iid == IID_IUnknown)
		*ppv = (IUnknown *) (IRouterInfo *) this;
    else if (iid == IID_IRouterInfo)
        *ppv = (IRouterInfo *) this;
	else if (iid == IID_IRouterRefreshAccess)
		*ppv = (IRouterRefreshAccess *) this;
    else if (iid == IID_IRouterAdminAccess)
        *ppv = (IRouterAdminAccess *) this;
	else
		return E_NOINTERFACE;
	
	((IUnknown *) *ppv)->AddRef(); 
	return hrOK;
}

DEBUG_DECLARE_INSTANCE_COUNTER(RouterInfo)

RouterInfo::RouterInfo(HWND hWndSync, LPCWSTR machineName)
	: m_bDisconnect(FALSE),
	m_hWndSync(hWndSync),
	m_dwRouterType(0),
	m_dwFlags(0),
    m_hMachineConfig(NULL),
    m_hMachineAdmin(NULL),
    m_fIsAdminInfoSet(FALSE),
    m_pbPassword(NULL),
    m_stMachine(machineName),
    m_cPassword(0)
{
	DEBUG_INCREMENT_INSTANCE_COUNTER(RouterInfo);

	InitializeCriticalSection(&m_critsec);

	m_VersionInfo.dwRouterVersion = 0;
	m_VersionInfo.dwOsMajorVersion = 0;
	m_VersionInfo.dwOsMinorVersion = 0;
	m_VersionInfo.dwOsServicePack = 0;
	m_VersionInfo.dwOsBuildNo = 0;
	m_VersionInfo.dwOsFlags = 0;
    m_VersionInfo.dwRouterFlags = 0;
}

RouterInfo::~RouterInfo()
{
	DEBUG_DECREMENT_INSTANCE_COUNTER(RouterInfo);
	Unload();

	DeleteCriticalSection(&m_critsec);

    ::ZeroMemory(m_pbPassword, m_cPassword);
    delete m_pbPassword;
    m_pbPassword = NULL;
    m_cPassword = 0;
}

STDMETHODIMP_(DWORD) RouterInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP RouterInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RouterInfo::Load
		Implementation of IRouterInfo::Load
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::Load(LPCOLESTR   pszMachine,
							  HANDLE      hMachine
							 )
{
	HRESULT	hr = hrOK;
 	RtrCriticalSection	rtrCritSec(&m_critsec);
    TCHAR* psz;
    POSITION pos;
    DWORD dwErr, dwType, dwSize, dwRouterType;
    WCHAR* pwsz, wszMachine[MAX_PATH+3];
	HKEY	hkMachine = NULL;
	USES_CONVERSION;

	COM_PROTECT_TRY
	{

		// Unload any existing information
		// ------------------------------------------------------------
		Unload();

		if (!pszMachine)
		{
			m_stMachine = TEXT("");
			pwsz = NULL;
		}
		else
		{
			m_stMachine = pszMachine;
			pwsz = StrnCpyWFromT(wszMachine, pszMachine, MAX_PATH);
		}

		// Get the version info
		// ------------------------------------------------------------
		CWRg( ConnectRegistry(GetMachineName(), &hkMachine) );
		
		CORg( QueryRouterVersionInfo(hkMachine, &m_VersionInfo) );

		// Get the router type
		// ------------------------------------------------------------
		CORg( QueryRouterType(hkMachine, &dwRouterType, &m_VersionInfo) );		
		m_dwRouterType = dwRouterType;

		
		// If 'hmachine' was not specified, connect
		// ------------------------------------------------------------
		CORg( TryToConnect(pwsz, hMachine) );
		Assert(m_hMachineConfig);
		hMachine = m_hMachineConfig;
        MprConfigServerRefresh(m_hMachineConfig);
				
		// If the caller did not specify a list of LAN adapters,
		// load a list of the LAN adapters from HKLM\Soft\MS\NT\NetworkCards
		// ------------------------------------------------------------
		CORg( RouterInfo::LoadInstalledInterfaceList(OLE2CT(pszMachine),
														&m_IfCBList) );

        // This will fix a lot of weird bugs.
        // If the router has not been configured (if the configured flag
        // has not been set), then we can skip the rest of the
        // configuration section.
        // ------------------------------------------------------------
        
//        if (!(m_VersionInfo.dwRouterFlags & RouterSnapin_IsConfigured))
//        {
//            hr = hrOK;
//            goto Error;
//        }

        if (m_VersionInfo.dwRouterFlags & RouterSnapin_IsConfigured)
        {
            // If the caller did not specify a list of router-managers,
            // load a list of the router-managers from HKLM\Soft\MS\Router
            // ------------------------------------------------------------
            CORg( RouterInfo::LoadInstalledRtrMgrList(pszMachine,
                &m_RmCBList) );
            
            // Load a list with the routing-protocols for each router-manager
            // ------------------------------------------------------------
            pos = m_RmCBList.GetHeadPosition();
            while (pos)
            {
                SRtrMgrCB* pcb = m_RmCBList.GetNext(pos);
                
                CORg( RouterInfo::LoadInstalledRtrMgrProtocolList(
                    pszMachine, pcb->dwTransportId,
                    &m_RmProtCBList,
					this));
            }
            
            // Load router-level info
            // ------------------------------------------------------------
            MPR_SERVER_0* pInfo;
            
            dwErr = ::MprConfigServerGetInfo(m_hMachineConfig,
                                             0,
                                             (LPBYTE *) &pInfo
										 ); 
            if (dwErr == NO_ERROR)
            {
                m_SRouterCB.dwLANOnlyMode = pInfo->fLanOnlyMode;
                ::MprConfigBufferFree(pInfo);
            }
            
            // Load the router-managers
            // ------------------------------------------------------------
            CORg( LoadRtrMgrList() );
        }
            
        // Load the interfaces
        // ------------------------------------------------------------
        CORg( LoadInterfaceList() );

		hr = hrOK;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	if (hkMachine)
        DisconnectRegistry( hkMachine );

	if (!FHrSucceeded(hr))
		Unload();
	
	return hr;
}

				 
/*!--------------------------------------------------------------------------
	RouterInfo::Save
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::Save(LPCOLESTR     pszMachine,
								 HANDLE      hMachine )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return hrOK;
}


/*!--------------------------------------------------------------------------
	RouterInfo::Unload
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::Unload( )
{
	HRESULT	hr = hrOK;
	RtrCriticalSection	rtrCritSec(&m_critsec);
	
	COM_PROTECT_TRY
	{
		// Destroy all COM objects, this includes interface and
		// router-manager objects
		// ------------------------------------------------------------
		Destruct();
		
		// Empty the list loaded using RouterInfo::LoadInstalledRtrMgrList
		// ------------------------------------------------------------
		while (!m_RmCBList.IsEmpty())
			delete m_RmCBList.RemoveHead();

		// Empty the list loaded using RouterInfo::LoadInstalledRmProtList
		// ------------------------------------------------------------
		while (!m_RmProtCBList.IsEmpty())
			delete m_RmProtCBList.RemoveHead();
		
		// Empty the list loaded using RouterInfo::LoadInstalledInterfaceList
		// ------------------------------------------------------------
		while (!m_IfCBList.IsEmpty())
			delete m_IfCBList.RemoveHead();

		
		DoDisconnect();

		m_dwRouterType = 0;

	}
	COM_PROTECT_CATCH;
	return hr;
}

	
/*!--------------------------------------------------------------------------
	RouterInfo::Merge
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::Merge(IRouterInfo *pNewRouter)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT				hr = hrOK;
	RouterCB			routerCB;

	COM_PROTECT_TRY
	{

		// There are several steps to this process, we need to sync
		// up the CBs and then the objects.  However, we should also
		// do a sanity check to see that all of the objects have CBs
		// but not vice versa (there may be CBs that don't running
		// objects associated with them).
		// ------------------------------------------------------------

		// Merge the basic router dta
		// ------------------------------------------------------------
		pNewRouter->CopyCB(&routerCB);
		m_SRouterCB.LoadFrom(&routerCB);

        // Copy over the version information
        // ------------------------------------------------------------
        pNewRouter->GetRouterVersionInfo(&m_VersionInfo);
		
		// Sync up the RtrMgrCB
		// ------------------------------------------------------------
		CORg( MergeRtrMgrCB(pNewRouter) );
		
		// Sync up the InterfaceCB
		// ------------------------------------------------------------
		CORg( MergeInterfaceCB(pNewRouter) );
		
		// Sync up the RtrMgrProtocolCB
		// ------------------------------------------------------------
		CORg( MergeRtrMgrProtocolCB(pNewRouter) );
		
		// Sync up the RtrMgrs
		// ------------------------------------------------------------
		CORg( MergeRtrMgrs(pNewRouter) );

		// Sync up the Interfaces
		// ------------------------------------------------------------
		CORg( MergeInterfaces(pNewRouter) );
		
		m_dwRouterType = pNewRouter->GetRouterType();
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hrOK;
}


/*!--------------------------------------------------------------------------
	RouterInfo::GetRefreshObject
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::GetRefreshObject(IRouterRefresh **ppRefresh)
{
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		// ------------------------------------------------------------
		if ((IRouterRefresh*)m_spRefreshObject && ppRefresh)
		{
			*ppRefresh = m_spRefreshObject;
			(*ppRefresh)->AddRef();
		}
		else
		{
			if (ppRefresh)
				*ppRefresh = NULL;
			hr = E_FAIL;
		}
	}
	COM_PROTECT_CATCH;

	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::SetExternalRefreshObject
		-
		To make multiple RouterInfo share the same AutoRefresh Object, use this
		function.
	Author: WeiJiang
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::SetExternalRefreshObject(IRouterRefresh *pRefresh)
{
	HRESULT	hr = hrOK;

	m_spRefreshObject.Release();
		
	// set to nothing is also allowed
	m_spRefreshObject.Set(pRefresh);

	return hr;
}
	
	
/*!--------------------------------------------------------------------------
	RouterInfo::CopyCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::CopyCB(RouterCB *pRouterCB)
{
	Assert(pRouterCB);
	
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		pRouterCB->dwLANOnlyMode = m_SRouterCB.dwLANOnlyMode;
	}
	COM_PROTECT_CATCH;
	return hr;
}

	
/*!--------------------------------------------------------------------------
	RouterInfo::GetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RouterInfo::GetMachineName()
{
	//$UNICODE : kennt, assumes that we are native UNICODE
	// Assumes OLE == W
	// ----------------------------------------------------------------
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return (LPCTSTR) m_stMachine;
}


/*!--------------------------------------------------------------------------
	RouterInfo::GetRouterType
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RouterInfo::GetRouterType()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwRouterType;
}

STDMETHODIMP	RouterInfo::GetRouterVersionInfo(RouterVersionInfo *pVerInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT				hr = hrOK;

	COM_PROTECT_TRY
	{
		*pVerInfo = m_VersionInfo;
		pVerInfo->dwSize = sizeof(RouterVersionInfo);
	}
	COM_PROTECT_CATCH;
	
	return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::EnumRtrMgrCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::EnumRtrMgrCB( IEnumRtrMgrCB **ppEnumRtrMgrCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromSRmCBList(&m_RmCBList, ppEnumRtrMgrCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::EnumInterfaceCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::EnumInterfaceCB( IEnumInterfaceCB **ppEnumInterfaceCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromSIfCBList(&m_IfCBList, ppEnumInterfaceCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::EnumRtrMgrProtocolCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::EnumRtrMgrProtocolCB(IEnumRtrMgrProtocolCB **ppEnumRmProtCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromSRmProtCBList(&m_RmProtCBList, ppEnumRmProtCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::EnumRtrMgrInterfaceCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::EnumRtrMgrInterfaceCB(IEnumRtrMgrInterfaceCB **ppEnumRmIfCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return E_NOTIMPL;
}

/*!--------------------------------------------------------------------------
	EnumRtrMgrProtocolInterfaceCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::EnumRtrMgrProtocolInterfaceCB(IEnumRtrMgrProtocolInterfaceCB **ppEnumRmProtIfCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return E_NOTIMPL;
}

	
/*!--------------------------------------------------------------------------
	RouterInfo::EnumRtrMgr
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::EnumRtrMgr( IEnumRtrMgrInfo **ppEnumRtrMgr)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromRmList(&m_RmList, ppEnumRtrMgr);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::FindRtrMgr
		S_OK is returned if a RtrMgrInfo is found.
		S_FALSE is returned if a RtrMgrInfo was NOT found.
		error codes returned otherwise.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::FindRtrMgr( DWORD dwTransportId,
					    IRtrMgrInfo **ppInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIRtrMgrInfo	sprm;
	SRmData		rmData;
	
	COM_PROTECT_TRY
	{
		if (ppInfo)
			*ppInfo = NULL;
		
		// Look through the list of rtr mgrs for the one that matches
		// ------------------------------------------------------------
		pos = m_RmList.GetHeadPosition();
		while (pos)
		{
			rmData = m_RmList.GetNext(pos);
			sprm.Set( rmData.m_pRmInfo );
			Assert(sprm);
			if (sprm->GetTransportId() == dwTransportId)
			{
				hr = hrOK;
				if (ppInfo)
				{
					*ppInfo = sprm.Transfer();
				}
				break;
			}
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::AddRtrMgr
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::AddRtrMgr( IRtrMgrInfo *pInfo,
					   IInfoBase *pGlobalInfo,
					   IInfoBase *pClientInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	DWORD	dwConnection = 0;
	SRmData	rmData;

	Assert(pInfo);
	
	COM_PROTECT_TRY
	{
		// Fail if there is a duplicate
		// ------------------------------------------------------------
		if (FHrOK(FindRtrMgr(pInfo->GetTransportId(), NULL)))
			CORg(E_INVALIDARG);

		//$ Review: kennt, if any of these calls fail, how do we
		// clean up correctly?
		// ------------------------------------------------------------
		
		// save the new structure
		// ------------------------------------------------------------
		CORg( pInfo->Save(GetMachineName(),
						  m_hMachineConfig,
						  NULL,
						  pGlobalInfo,
						  pClientInfo,
						  0) );
		
		// add the new structure to our list
		// ------------------------------------------------------------
		rmData.m_pRmInfo = pInfo;
		m_RmList.AddTail(rmData);
		
		pInfo->AddWeakRef();
		pInfo->SetParentRouterInfo(this);
		
		m_AdviseList.NotifyChange(ROUTER_CHILD_ADD, ROUTER_OBJ_Rm, 0);
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::DeleteRtrMgr
		-
		This function deletes a router-manager from the router.
		A side-effect of this deletion is that all RtrMgrInterfaceInfo
		objects which refer to this router-manager are also deleted.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::DeleteRtrMgr( DWORD dwTransportId, BOOL fRemove )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT			hr = hrOK;
	HRESULT			hrIf;
	POSITION		pos;
	POSITION		posRM;
	POSITION		posIf;
	SPIRtrMgrInfo	sprm;
	SPIInterfaceInfo	spIf;
	SRmData			rmData;
	
	COM_PROTECT_TRY
	{
		pos = m_RmList.GetHeadPosition();
		while (pos)
		{
			posRM = pos;
			rmData = m_RmList.GetNext(pos);
			sprm.Set( rmData.m_pRmInfo );
			Assert(sprm);

			if (sprm->GetTransportId() == dwTransportId)
				break;
			sprm.Release();
		}

		// did we find a router-manager?
		// ------------------------------------------------------------
		if (sprm)
		{
			// get a list of the InterfaceInfo objects for
			// interfaces over which this router-manager is configured
			// --------------------------------------------------------
			posIf = m_IfList.GetHeadPosition();
			while (posIf)
			{
				spIf.Set( m_IfList.GetNext(posIf) );
				hrIf = spIf->FindRtrMgrInterface(dwTransportId, NULL);
				
				// go through the list and remove the router-manager from
				// each interface
				// ----------------------------------------------------
				if (hrIf == hrFalse)
				{
					spIf->DeleteRtrMgrInterface(dwTransportId, fRemove);
				}
			}

			// remove the router-manager from our list
			// --------------------------------------------------------
			Assert(rmData.m_pRmInfo == sprm);
			SRmData::Destroy( &rmData );
			m_RmList.RemoveAt(posRM);

			// finally, remove the router-manger itself
			// --------------------------------------------------------
            if (fRemove)
                sprm->Delete(GetMachineName(), NULL);
			
			m_AdviseList.NotifyChange(ROUTER_CHILD_DELETE, ROUTER_OBJ_Rm, 0);
		
		}
		else
			hr = E_INVALIDARG;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::ReleaseRtrMgr
		This function will release the AddRef() that this object has
        on the child.  This allows us to transfer child objects from
        one router to another.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::ReleaseRtrMgr( DWORD dwTransportId )
{
    HRESULT     hr = hrOK;
    POSITION    pos, posRm;
	SRmData			rmData;
    
    COM_PROTECT_TRY
    {
		pos = m_RmList.GetHeadPosition();
		while (pos)
		{
            // Save the position (so that we can delete it)
            posRm = pos;
            rmData = m_RmList.GetNext(pos);

            if (rmData.m_pRmInfo &&
                (rmData.m_pRmInfo->GetTransportId() == dwTransportId))
            {
                // When releasing, we need to disconnect (since the
                // main handle is controlled by the router info).
                rmData.m_pRmInfo->DoDisconnect();
        
                rmData.m_pRmInfo->ReleaseWeakRef();
                rmData.m_pRmInfo = NULL;
                
                // release this node from the list
                m_RmList.RemoveAt(posRm);
                break;
            }

		}        
    }
    COM_PROTECT_CATCH;
    return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::EnumInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::EnumInterface(IEnumInterfaceInfo **ppEnumInterface)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromInterfaceList(&m_IfList, ppEnumInterface);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::FindInterface
		S_OK is returned if an InterfaceInfo is found.
		S_FALSE is returned if an InterfaceInfo was NOT found.
		error codes returned otherwise.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::FindInterface(LPCOLESTR pszInterface,
						   IInterfaceInfo **ppInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIInterfaceInfo	spIf;
	
	COM_PROTECT_TRY
	{
		if (ppInfo)
			*ppInfo = NULL;
		
		// Look through the list of rtr mgrs for the one that matches
		// ------------------------------------------------------------
		pos = m_IfList.GetHeadPosition();
		while (pos)
		{
			spIf.Set(m_IfList.GetNext(pos));
			Assert(spIf);
			if (StriCmpW(spIf->GetId(), pszInterface) == 0)
			{
				hr = hrOK;
				if (ppInfo)
				{
					*ppInfo = spIf.Transfer();
				}
				break;
			}
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::FindInterfaceByName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::FindInterfaceByName(LPCOLESTR pszName,
                                             IInterfaceInfo **ppInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIInterfaceInfo	spIf;
	
	COM_PROTECT_TRY
	{
		if (ppInfo)
			*ppInfo = NULL;
		
		// Look through the list of rtr mgrs for the one that matches
		// ------------------------------------------------------------
		pos = m_IfList.GetHeadPosition();
		while (pos)
		{
			spIf.Set(m_IfList.GetNext(pos));
			Assert(spIf);
			if (StriCmpW(spIf->GetTitle(), pszName) == 0)
			{
				hr = hrOK;
				if (ppInfo)
				{
					*ppInfo = spIf.Transfer();
				}
				break;
			}
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::AddInterfaceInternal
        fForce - if this is TRUE, then we require that the Save succeeded.
                else, we ignore the error.
        fAddToRouter - if this is TRUE, we call the InterfaceInfo::Save,
                else, we do not call it (and do not change router state).
        fMoveRmIf - if this is TRUE, we have to convert the RtrMgrIf's to
                point to the one's in THIS router info.
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::AddInterfaceInternal(IInterfaceInfo *pInfo,
                                         BOOL fForce,
                                         BOOL fAddToRouter)                   
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	Assert(pInfo);
	
	COM_PROTECT_TRY
	{
		// Fail if there is a duplicate
		// ------------------------------------------------------------
		if (FHrOK(FindInterface(pInfo->GetId(), NULL)))
			CORg(E_INVALIDARG);

        // Also need to check that the friendly name is unique.
        // ------------------------------------------------------------
        if (FHrOK(FindInterfaceByName(pInfo->GetTitle(), NULL)))
            CORg(E_INVALIDARG);

		//$ Review: kennt, if any of these calls fail, how do we
		// clean up correctly?
		// ------------------------------------------------------------

        if (fAddToRouter)
        {
            // save the new structure
            // --------------------------------------------------------
            hr = pInfo->Save(GetMachineName(), m_hMachineConfig, NULL);
            if (fForce)
                CORg( hr );
        }

		// add the new structure to our list
		// ------------------------------------------------------------
		m_IfList.AddTail(pInfo);
		pInfo->AddWeakRef();
		pInfo->SetParentRouterInfo(this);

		m_AdviseList.NotifyChange(ROUTER_CHILD_ADD, ROUTER_OBJ_If, 0);

		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::NotifyRtrMgrInterfaceOfMove
		Notify the appropriate RouterManagers that a new interface
        has been added.
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::NotifyRtrMgrInterfaceOfMove(IInterfaceInfo *pIf)
{
    HRESULT     hr = hrOK;
    SPIEnumRtrMgrInterfaceInfo  spEnumRmIf;
    SPIRtrMgrInterfaceInfo  spRmIf;
    SPIEnumRtrMgrProtocolInterfaceInfo  spEnumRmProtIf;
    SPIRtrMgrInfo           spRm;
    SPIRtrMgrProtocolInterfaceInfo  spRmProtIf;
    SPIRtrMgrProtocolInfo   spRmProt;

    pIf->EnumRtrMgrInterface(&spEnumRmIf);

    while (spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK)
    {
        // Find the appropriate router manager and have them
        // send a notification.
        // ------------------------------------------------------------
        FindRtrMgr(spRmIf->GetTransportId(), &spRm);

        if (spRm)
        {
            spRm->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);

            // Now for each router-manager, enumerate the protocols
            // --------------------------------------------------------

            spRmIf->EnumRtrMgrProtocolInterface(&spEnumRmProtIf);
            while (spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK)
            {
                spRm->FindRtrMgrProtocol(spRmProtIf->GetProtocolId(),
                                         &spRmProt);
                if (spRmProt)
                {
                    spRmProt->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmProtIf,
                                        0);
                }
                spRmProt.Release();
                spRmProtIf.Release();
            }
        }
        spEnumRmProtIf.Release();
        spRm.Release();
        spRmIf.Release();
        
    }
    
    return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::AddInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::AddInterface(IInterfaceInfo *pInfo)
{
	return AddInterfaceInternal(pInfo,
                                TRUE /* bForce */,
                                TRUE /* fAddToRouter */);
}


/*!--------------------------------------------------------------------------
	RouterInfo::DeleteInterface
		-
		This function deletes the named CInterfaceInfo from the router.
		As a side-effect, all the contained CRmInterfaceInfo objects
		are also deleted.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP	RouterInfo::DeleteInterface(LPCOLESTR pszInterface, BOOL fRemove)
{
    return RemoveInterfaceInternal(pszInterface, fRemove);
}


/*!--------------------------------------------------------------------------
	RouterInfo::ReleaseInterface
		This function will release the AddRef() that this object has
        on the child.  This allows us to transfer child objects from
        one router to another.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::ReleaseInterface( LPCOLESTR pszInterface )
{
    HRESULT     hr = hrOK;
    POSITION    pos, posIf;
    SPIInterfaceInfo    spIf;
    
    COM_PROTECT_TRY
    {
		pos = m_IfList.GetHeadPosition();
		while (pos)
		{
            // Save the position (so that we can delete it)
            posIf = pos;
            spIf.Set( m_IfList.GetNext(pos) );

            if (spIf &&
                (StriCmpW(spIf->GetId(), pszInterface) == 0))
            {
                // When releasing, we need to disconnect (since the
                // main handle is controlled by the router info).
                spIf->DoDisconnect();
        
                spIf->ReleaseWeakRef();
                spIf.Release();

                // release this node from the list
                m_IfList.RemoveAt(posIf);
                break;
            }
            spIf.Release();
		}        
    }
    COM_PROTECT_CATCH;
    return hr;    
}

HRESULT RouterInfo::RemoveInterfaceInternal(LPCOLESTR pszIf, BOOL fRemoveFromRouter)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT			hr = hrOK;
	POSITION		pos, posIf;
	SPIInterfaceInfo	spIf;
	
	COM_PROTECT_TRY
	{
		pos = m_IfList.GetHeadPosition();
		while (pos)
		{
			posIf = pos;
			spIf.Set( m_IfList.GetNext(pos) );
			if (StriCmpW(spIf->GetId(), pszIf) == 0)
				break;
			spIf.Release();
		}

		if (!spIf)
			hr = E_INVALIDARG;
		else
		{
			// Remove the interface from our list
			// --------------------------------------------------------
			spIf->Destruct();
			spIf->ReleaseWeakRef();			// remove list addref
			m_IfList.RemoveAt(posIf);

            // Need to remove the RtrMgrInterfaceInfos from the list.
            // --------------------------------------------------------
            SPIEnumRtrMgrInterfaceInfo  spEnumRmIf;
            SPIRtrMgrInterfaceInfo      spRmIf;
            spIf->EnumRtrMgrInterface(&spEnumRmIf);

            for (spEnumRmIf->Reset();
                 hrOK == spEnumRmIf->Next(1, &spRmIf, NULL);
                 spRmIf.Release())
            {
                DWORD   dwTransportId = spRmIf->GetTransportId();
                spRmIf.Release();
                
                spIf->DeleteRtrMgrInterface(dwTransportId, fRemoveFromRouter);
            }

            if (fRemoveFromRouter)
            {
                // Delete the interface from the router
                // ----------------------------------------------------
                spIf->Delete(GetMachineName(), NULL);

                // If this is a WAN interface, delete it from the
                // phonebook-file

                // version # greater than Win2K, this will be done in MprAdminInterfaceDelete, which is called in Delete
                // fix 91331

				DWORD	dwMajor = 0, dwMinor = 0, dwBuildNo = 0;
			    HKEY    hkeyMachine = NULL;

		        // Ignore the failure code, what else can we do?
		        // ------------------------------------------------------------
		        DWORD	dwErr = ConnectRegistry(GetMachineName(), &hkeyMachine);
		        if (dwErr == ERROR_SUCCESS)
		        {
		            dwErr = GetNTVersion(hkeyMachine, &dwMajor, &dwMinor, &dwBuildNo)
;            
		            DisconnectRegistry(hkeyMachine);
		        }

				DWORD	dwVersionCombine = MAKELONG( dwBuildNo, MAKEWORD(dwMinor, dwMajor));
				DWORD	dwVersionCombineNT50 = MAKELONG ( VER_BUILD_WIN2K, MAKEWORD(VER_MINOR_WIN2K, VER_MAJOR_WIN2K));

				// if the version is greater than Win2K release
				if(dwVersionCombine > dwVersionCombineNT50)
					;	// skip 
				else
				// end if fix 91331
				{

                // ----------------------------------------------------
                if (spIf->GetInterfaceType() == ROUTER_IF_TYPE_FULL_ROUTER)
                    hr = RasPhoneBookRemoveInterface(GetMachineName(),
                        pszIf);
                }
            }
            
			m_AdviseList.NotifyChange(ROUTER_CHILD_DELETE, ROUTER_OBJ_If, 0);
		
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}


STDMETHODIMP RouterInfo::RtrAdvise(IRtrAdviseSink *pRtrAdviseSink,
								   LONG_PTR *pulConnection,
								   LPARAM lUserParam)
{
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	RtrCriticalSection	rtrCritSec(&m_critsec);
	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

STDMETHODIMP RouterInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}


STDMETHODIMP RouterInfo::RtrUnadvise(LONG_PTR dwConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(dwConnection);
}



//---------------------------------------------------------------------------
// Function:    CRouterInfo::LoadInstalledRtrMgrList
//
// This function builds a list of the router manager's available
// for installation. The list contains RtrMgrCB structures.
//---------------------------------------------------------------------------

HRESULT RouterInfo::LoadInstalledRtrMgrList(LPCTSTR     pszMachine,
											SRtrMgrCBList *pRmCBList)
{
    DWORD			dwErr;
    HKEY			hkeyMachine = 0;
	RegKey			regkey;
	RegKey			regkeyRM;
	RegKey::CREGKEY_KEY_INFO	regKeyInfo;
	RegKeyIterator	regkeyIter;
	HRESULT			hr, hrIter;
	CString			stKey;
	DWORD			dwData;
	DWORD			cchValue;
	SPSZ			spszValue;
	SPSRtrMgrCB		spSRtrMgrCB;
		
    // connect to the registry
	// ----------------------------------------------------------------
    CWRg( ConnectRegistry(pszMachine, &hkeyMachine) );

    // open HKLM\Software\Microsoft\Router\CurrentVersion\RouterManagers
	// ----------------------------------------------------------------
	CWRg( regkey.Open(hkeyMachine, c_szRouterManagersKey, KEY_READ) );

	// enumerate the keys
	// ----------------------------------------------------------------
	CORg( regkeyIter.Init(&regkey) );

	for (hrIter = regkeyIter.Next(&stKey); hrIter == hrOK; hrIter = regkeyIter.Next(&stKey))
	{
		// cleanup from the previous loop
		// ------------------------------------------------------------
		regkeyRM.Close();
		
		// open the key
		// ------------------------------------------------------------
		dwErr = regkeyRM.Open(regkey, stKey, KEY_READ);
		
		if (dwErr == ERROR_SUCCESS)
		{
			// Get this information so that we can be more efficient
			// at allocating space.
			// --------------------------------------------------------
			dwErr = regkeyRM.QueryKeyInfo(&regKeyInfo);
		}

		
		if (dwErr != ERROR_SUCCESS)
		{
			continue;
		}

		// Allocate a space for the largest value (we're reading
		// in strings).
		// ------------------------------------------------------------
		spszValue.Free();
		cchValue = MaxCchFromCb( regKeyInfo.dwMaxValueData );
		spszValue = new TCHAR[ MinTCharNeededForCch(cchValue) ];
		Assert(spszValue);
				
		do {
			// allocate a new structure for this router-manager
			// --------------------------------------------------------
			spSRtrMgrCB = new SRtrMgrCB;
			Assert(spSRtrMgrCB);
			
			spSRtrMgrCB->stId = stKey;

			// read the ProtocolId value
			// --------------------------------------------------------
			dwErr = regkeyRM.QueryValue(c_szProtocolId, dwData);
			if (dwErr != ERROR_SUCCESS) { break; }			
			spSRtrMgrCB->dwTransportId = dwData;

			// read the DLLPath value
			// --------------------------------------------------------
			dwErr = regkeyRM.QueryValue(c_szDLLPath, spszValue, cchValue,TRUE);
			if (dwErr != ERROR_SUCCESS) { break; }
			spSRtrMgrCB->stDLLPath = spszValue;

			//
			// read the ConfigDLL value
			//
			//dwErr = regkeyRM.QueryValue(c_szConfigDLL,spszValue,cchValue,TRUE);
			//if (dwErr != ERROR_SUCCESS) { break; }			
			//spSRtrMgrCB->stConfigDLL = spszValue;

			// read the Title value
			// --------------------------------------------------------
			dwErr = regkeyRM.QueryValue(c_szTitle, spszValue, cchValue, FALSE);
			if (dwErr != ERROR_SUCCESS)
				spSRtrMgrCB->stTitle = spSRtrMgrCB->stId;
			else
				spSRtrMgrCB->stTitle = spszValue;
			
			// add the object to our list
			// --------------------------------------------------------
			pRmCBList->AddTail(spSRtrMgrCB);

			// Release the pointer, it belongs to pRmCBList now.
			// --------------------------------------------------------
			spSRtrMgrCB.Transfer();
			
		} while(FALSE);

		// If there was an error with the registry values, we
		// ignore it and go onto the nextkey.
		// ------------------------------------------------------------

		regkeyRM.Close();		
	}

	if (!FHrSucceeded(hrIter))
		hr = hrIter;
	
Error:
	if (hkeyMachine)
		DisconnectRegistry(hkeyMachine);

    return hr;
}

HRESULT RouterInfo::LoadInstalledRtrMgrProtocolList(LPCTSTR pszMachine,
		DWORD dwTransportId, SRtrMgrProtocolCBList *pRmProtCBList, RouterInfo * pRouter)
{
	WCHAR	*		pszPassword = NULL;
	int				nPasswordLen = 0;
	UCHAR			ucSeed = 0x83;			//why?
	HRESULT			hr = hrOK;

	if ( pRouter->IsAdminInfoSet() )
	{
		pRouter->GetUserPassword(NULL, &nPasswordLen );

		pszPassword = (WCHAR *) new WCHAR [(nPasswordLen /sizeof(WCHAR)) + 1 ];
		pRouter->GetUserPassword( (BYTE *)pszPassword, &nPasswordLen  );
		pszPassword[nPasswordLen/sizeof(WCHAR) ] = 0;
		RtlDecodeW(ucSeed, pszPassword);

		hr = RouterInfo::LoadInstalledRtrMgrProtocolList(	pszMachine, 
															dwTransportId, 
															pRmProtCBList, 
															pRouter->GetUserName(), 
															pszPassword, 
															pRouter->GetDomainName() );
		if ( pszPassword )
		{
			ZeroMemory ( pszPassword, nPasswordLen );
			delete pszPassword;
		}
	}
	else
	{
		hr = RouterInfo::LoadInstalledRtrMgrProtocolList(	pszMachine, 
															dwTransportId, 
															pRmProtCBList, 
															NULL, 
															NULL, 
															NULL );
	}
	return hr;
}
HRESULT RouterInfo::LoadInstalledRtrMgrProtocolList(LPCTSTR pszMachine,
		DWORD dwTransportId, SRtrMgrProtocolCBList *pRmProtCBList, IRouterInfo * pRouter)
{
	WCHAR	*				pszPassword = NULL;
	int						nPasswordLen = 0;
	UCHAR					ucSeed = 0x83;			//why?
	HRESULT					hr = hrOK;
	SPIRouterAdminAccess    spAdmin;


	spAdmin.HrQuery(pRouter);
	if (spAdmin && spAdmin->IsAdminInfoSet())
	{

		spAdmin->GetUserPassword(NULL, &nPasswordLen );

		pszPassword = (WCHAR *) new WCHAR [(nPasswordLen /sizeof(WCHAR)) + 1 ];
		spAdmin->GetUserPassword( (BYTE *)pszPassword, &nPasswordLen  );
		pszPassword[nPasswordLen/sizeof(WCHAR) ] = 0;
		RtlDecodeW(ucSeed, pszPassword);

		hr = RouterInfo::LoadInstalledRtrMgrProtocolList(	pszMachine, 
															dwTransportId, 
															pRmProtCBList, 
															spAdmin->GetUserName(), 
															pszPassword, 
															spAdmin->GetDomainName() );
		if ( pszPassword )
		{
			ZeroMemory ( pszPassword, nPasswordLen );
			delete pszPassword;
		}
	}
	else
	{
		hr = RouterInfo::LoadInstalledRtrMgrProtocolList(	pszMachine, 
															dwTransportId, 
															pRmProtCBList, 
															NULL, 
															NULL, 
															NULL );

	}
	return hr;
}

//---------------------------------------------------------------------------
// Function:    CRouterInfo::QueryInstalledRmProtList
//
// This function builds a list of the routing protocols which can be added
// to the specified router manager.
//---------------------------------------------------------------------------

HRESULT	RouterInfo::LoadInstalledRtrMgrProtocolList(
    LPCTSTR     pszMachine,
    DWORD       dwTransportId,
	SRtrMgrProtocolCBList *	pSRmProtCBList,
	LPCWSTR lpwszUserName, 
	LPCWSTR lpwszPassword , 
	LPCWSTR lpwszDomain
	)
{
	Assert(pSRmProtCBList);
	
    DWORD			dwErr;
    HKEY			hkey, hkrm, hkeyMachine = 0;
	HRESULT			hr = hrOK;
	RegKey			regkeyRM;
	RegKey			regkeyProt;
	RegKey::CREGKEY_KEY_INFO	regKeyInfo;
	RegKeyIterator	regkeyIter;
	HRESULT			hrIter;
	SPSZ			spszValue;
	SPSZ			spszRm;
	ULONG			cchValue;
	CString			stKey;
	SPSRtrMgrProtocolCB	spSRmProtCB;
	DWORD			dwData;
	BOOL			f64BitAdmin = FALSE;
    BOOL            f64BitLocal = FALSE;
    TCHAR           szLocalMachineName[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD           dwLocalMachineNameSize = MAX_COMPUTERNAME_LENGTH + 1;



	if ( lpwszUserName )
		CWRg( IsWindows64Bit(pszMachine, lpwszUserName, lpwszPassword, lpwszDomain, &f64BitAdmin) );
	else
		CWRg( IsWindows64Bit(pszMachine, NULL, NULL, NULL, &f64BitAdmin) );

    
    GetComputerName ( szLocalMachineName, &dwLocalMachineNameSize );

    if ( !lstrcmp ( szLocalMachineName, pszMachine ) )
    {
        f64BitLocal = f64BitAdmin;
    }
    else
    {
		CWRg( IsWindows64Bit(szLocalMachineName, NULL, NULL, NULL, &f64BitLocal) );
    }
    // connect to the registry
	// ----------------------------------------------------------------
    CWRg( ConnectRegistry(pszMachine, &hkeyMachine) );

    // open the key for the specified router-manager
    // under HKLM\Software\Microsoft\Router\RouterManagers
	// ----------------------------------------------------------------
    CWRg( FindRmSoftwareKey(hkeyMachine, dwTransportId, &hkrm, &spszRm) );

    // The transport was found, so its registry key is in 'hkrm'
	// ----------------------------------------------------------------
	regkeyRM.Attach(hkrm);

	// enumerate the keys
	// ----------------------------------------------------------------

	CORg( regkeyIter.Init(&regkeyRM) );

	for (hrIter=regkeyIter.Next(&stKey); hrIter==hrOK; hrIter=regkeyIter.Next(&stKey))
	{
		// Cleanup from the previous loop
		// ------------------------------------------------------------
		regkeyProt.Close();
		
		// open the key
		// ------------------------------------------------------------
		dwErr = regkeyProt.Open(regkeyRM, stKey, KEY_READ);
		if (dwErr != ERROR_SUCCESS)
		{
			continue;
		}
		
		do {

			// allocate a new structure for this protocol
			// --------------------------------------------------------
			spSRmProtCB.Free();
			spSRmProtCB = new SRtrMgrProtocolCB;
			Assert(spSRmProtCB);

			spSRmProtCB->stId = stKey;
			spSRmProtCB->dwTransportId = dwTransportId;
			spSRmProtCB->stRtrMgrId = spszRm;

			// get information about the key's values
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryKeyInfo(&regKeyInfo);
			if (dwErr != ERROR_SUCCESS) { break; }

			// allocate space to hold the longest of the values
			// --------------------------------------------------------
			spszValue.Free();
			cchValue = (regKeyInfo.dwMaxValueData)/sizeof(TCHAR);
			spszValue = new TCHAR[cchValue * (2/sizeof(TCHAR))];
			Assert(spszValue);

			// read the ProtocolId value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szProtocolId, dwData);
			if (dwErr != ERROR_SUCCESS) { break; }
//#if IA64
            //OSPF node should be shown iff we are a 32 bit machine administering
            //a 32 bit machine
			if ( f64BitAdmin  || f64BitLocal )
				if( dwData == PROTO_IP_OSPF ) {break;}

            
//#endif
			spSRmProtCB->dwProtocolId = dwData;

			// read the Flags value
			//
			dwErr = regkeyProt.QueryValue(c_szFlags, dwData);
			if (dwErr != ERROR_SUCCESS)
			    spSRmProtCB->dwFlags = 0;
            else
			    spSRmProtCB->dwFlags = dwData;

			//
			// read the DLLName value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szDLLName, spszValue, cchValue,
										  TRUE);
			if (dwErr != ERROR_SUCCESS)
                spSRmProtCB->stDLLName.Empty();
			else
                spSRmProtCB->stDLLName = (LPCTSTR)spszValue;

			//
			// read the ConfigDLL value
			//
			//dwErr = regkeyProt.QueryValue(c_szConfigDLL, spszValue, cchValue,
			//							  TRUE);
			//if (dwErr != ERROR_SUCCESS) { break; }
			//spSRmProtCB->stConfigDLL = (LPCTSTR)spszValue;

			
			// read the ConfigCLSID value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szConfigCLSID, spszValue, cchValue, FALSE);
			
			// Ignore the error code, if there is no CLSID, just NULL out
			// the GUID, note that we can't depend on the key necessarily
			// being there (for NT4 reasons).
			// --------------------------------------------------------
			::ZeroMemory(&(spSRmProtCB->guidConfig), sizeof(GUID));
			if ((dwErr != ERROR_SUCCESS) ||
				!FHrSucceeded(CLSIDFromString(T2OLE((LPTSTR)(LPCTSTR) spszValue),
											 &(spSRmProtCB->guidConfig))))
				memset(&(spSRmProtCB->guidConfig), 0xff, sizeof(GUID));

			
			// read the AdminUICLSID value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szAdminUICLSID, spszValue, cchValue, FALSE);

			// Ignore the error code, if there is no CLSID, just NULL out
			// the GUID, note that we can't depend on the key necessarily
			// being there (for NT4 reasons).
			// --------------------------------------------------------
			::ZeroMemory(&(spSRmProtCB->guidAdminUI), sizeof(GUID));
			if ((dwErr != ERROR_SUCCESS) ||
				!FHrSucceeded(CLSIDFromString(T2OLE((LPTSTR)(LPCTSTR) spszValue),
											 &(spSRmProtCB->guidAdminUI))))
				memset(&(spSRmProtCB->guidAdminUI), 0xff, sizeof(GUID));

			// read the VendorName value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szVendorName, spszValue, cchValue, FALSE);
			
			// Ignore the error code, if there is no value, just NULL out
			// the value, note that we can't depend on the key necessarily
			// being there (for NT4 reasons).
			// --------------------------------------------------------
			if (dwErr == ERROR_SUCCESS)
				spSRmProtCB->stVendorName = spszValue;

			// read the Title value
			// --------------------------------------------------------
			dwErr = regkeyProt.QueryValue(c_szTitle, spszValue, cchValue,
										  FALSE);
			if (dwErr != ERROR_SUCCESS)
				spSRmProtCB->stTitle = spSRmProtCB->stId;
			else
				spSRmProtCB->stTitle = (LPCTSTR)spszValue;

			// add the object to our list
			// --------------------------------------------------------
			pSRmProtCBList->AddTail(spSRmProtCB);

			// Let this go, it's under the control of the protList
			// --------------------------------------------------------
			spSRmProtCB.Transfer();

			dwErr = ERROR_SUCCESS;

		} while(FALSE);

    }

Error:

	if (hkeyMachine)
		DisconnectRegistry(hkeyMachine);

    return hr;
}


//---------------------------------------------------------------------------
// Function:    CRouterInfo::LoadInstalledInterfaceList
//
// This function builds a list of network cards available for addition
// to the router manager.
//---------------------------------------------------------------------------

HRESULT RouterInfo::LoadInstalledInterfaceList(LPCTSTR     pszMachine,
											   SInterfaceCBList *pSIfCBList)
{
    DWORD			dwErr;
    HKEY			hkeyMachine = 0;
	RegKey			regkeyNC;
	RegKey			regkeyCard;
	CStringList		ipCardList;
	CStringList		ipxCardList;
	RegKeyIterator	regkeyIter;
	HRESULT			hrIter;
	CString			stKey;
	SPSInterfaceCB	spSIfCB;
	HRESULT			hr = hrOK;
	BOOL			fNT4;
	LPCTSTR			pszKey;
	CString			stServiceName;
	CNetcardRegistryHelper	ncreghelp;
    DWORD           ifBindFlags = 0;

	
    // connect to the registry
    // ----------------------------------------------------------------
    CWRg( ConnectRegistry(pszMachine, &hkeyMachine) );

	
	//$NT5: kennt, changes made to read NT5 specific information
	// ----------------------------------------------------------------
	CWRg( IsNT4Machine(hkeyMachine, &fNT4) );

	
    // open HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards
    // ----------------------------------------------------------------
	pszKey = fNT4 ? c_szNetworkCardsKey : c_szNetworkCardsNT5Key;
	CWRg( regkeyNC.Open(hkeyMachine, pszKey, KEY_READ) );

	
	// get the netcards that IP and IPX are bound to
	// ----------------------------------------------------------------
	CORg( ::LoadLinkageList(pszMachine, hkeyMachine, TEXT("tcpip"),
							 &ipCardList) );
	CORg( ::LoadLinkageList(pszMachine, hkeyMachine, TEXT("nwlnkipx"),
							 &ipxCardList) );

	
	// enumerate the subkeys, and for each key,
	// make an addition to our list
	// ----------------------------------------------------------------
	CWRg( regkeyIter.Init(&regkeyNC) );

	hrIter = regkeyIter.Next(&stKey);

	for (; hrIter == hrOK; hrIter=regkeyIter.Next(&stKey))
	{
        ifBindFlags = 0;
		regkeyCard.Close();
		
		// now open the key
		// ------------------------------------------------------------
		dwErr = regkeyCard.Open(regkeyNC, stKey, KEY_READ);
		if (dwErr != ERROR_SUCCESS)
			continue;

		
		// setup the helper class
		// ------------------------------------------------------------
		ncreghelp.Initialize(fNT4, regkeyCard, stKey,
							 pszMachine);

		do {
			// read the ServiceName
			// --------------------------------------------------------

			//$NT5: the service name is not in the same format as NT4
			// this will need to be done differently.
			// --------------------------------------------------------
			if (fNT4)
			{
				dwErr = ncreghelp.ReadServiceName();
				if (dwErr != ERROR_SUCCESS)
					break;
				stServiceName = ncreghelp.GetServiceName();
			}
			else
				stServiceName = stKey;

			// if the service name is not in the IP or IPX adapter list,
			// then ignore this netcard because it is not a real netcard
			// --------------------------------------------------------
			if (ipCardList.Find((LPCTSTR) stServiceName))
            {
                ifBindFlags |= InterfaceCB_BindToIp;
            }


            // Now check IPX
            // ------------------------------------------------
			{
				BOOL	fFound = TRUE;
				CString	stNewServiceName;
				
				do
				{
					if (ipxCardList.Find((LPCTSTR) stServiceName))
						break;
					
					stNewServiceName = stServiceName + c_szEthernetSNAP;
					if (ipxCardList.Find((LPCTSTR) stNewServiceName))
						break;
					
					stNewServiceName = stServiceName + c_szEthernetII;
					if (ipxCardList.Find((LPCTSTR) stNewServiceName))
						break;
					
					stNewServiceName = stServiceName + c_szEthernet8022;
					if (ipxCardList.Find((LPCTSTR) stNewServiceName))
						break;
					
					stNewServiceName = stServiceName + c_szEthernet8023;
					if (ipxCardList.Find((LPCTSTR) stNewServiceName))
						break;
					
					fFound = FALSE;
				} while (FALSE);

                if (fFound)
                    ifBindFlags |= InterfaceCB_BindToIpx;
				
			}

            // If we didn't find it in IP or IPX
            // break out of the loop
            // ----------------------------------------------------
            if (ifBindFlags == 0)
                break;				

            
			// ignore NdisWan adapters
			// --------------------------------------------------------
			if (_wcsnicmp( (const wchar_t *)stServiceName, 
						   L"NdisWan", 
						   (sizeof(L"NdisWan")-1)/sizeof (WCHAR)) == 0 ) {
				break;
			}
			
			// allocate an SSInterfaceCB
			// --------------------------------------------------------
			spSIfCB = new SInterfaceCB;
			Assert(spSIfCB);

			spSIfCB->stId = (LPCTSTR) stServiceName;
			spSIfCB->dwIfType = ROUTER_IF_TYPE_DEDICATED;
            spSIfCB->dwBindFlags = ifBindFlags;

			// read the title
			// --------------------------------------------------------
			dwErr = ncreghelp.ReadTitle();
			if (dwErr != ERROR_SUCCESS)
				spSIfCB->stTitle = spSIfCB->stId;
			else
				spSIfCB->stTitle = (LPCTSTR) ncreghelp.GetTitle();

			// read the device
			// --------------------------------------------------------
			dwErr = ncreghelp.ReadDeviceName();
			if (dwErr != ERROR_SUCCESS)
				spSIfCB->stDeviceName = spSIfCB->stTitle;
			else
				spSIfCB->stDeviceName = (LPCTSTR) ncreghelp.GetDeviceName();

			// add the SSInterfaceCB to the callers list
			// --------------------------------------------------------
			pSIfCBList->AddTail(spSIfCB);
			spSIfCB.Transfer();

			dwErr = NO_ERROR;

		} while (FALSE);

		if (dwErr != NO_ERROR)
		{
			hr = HRESULT_FROM_WIN32(dwErr);
			break;
		}

    }

Error:
	if (hkeyMachine)
		DisconnectRegistry(hkeyMachine);

    return dwErr;
}

//---------------------------------------------------------------------------
// Function:    CRouterInfo::LoadRtrMgrList
//---------------------------------------------------------------------------

HRESULT RouterInfo::LoadRtrMgrList()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	BOOL		bFound = TRUE;
	SPIRtrMgrInfo	spRmInfo;
    BYTE*		pItemTable = NULL;
    MPR_TRANSPORT_0* ptransport;
    DWORD dwErr, i, dwEntries, dwTotal;
	HRESULT		hr = hrOK;
	USES_CONVERSION;

    // Enumerate the transports configured
    // ----------------------------------------------------------------
    dwErr = ::MprConfigTransportEnum(
                m_hMachineConfig,
                0,
                &pItemTable,
                (DWORD)-1,
                &dwEntries,
                &dwTotal,
                NULL
                );

    if (dwErr != NO_ERROR && dwErr != ERROR_NO_MORE_ITEMS)
		return HRESULT_FROM_WIN32(dwErr);

    // Create router-manager objects for each transport
    // ----------------------------------------------------------------

    for (i = 0, ptransport = (MPR_TRANSPORT_0*)pItemTable;
         i < dwEntries;
         i++, ptransport++) {

        // See if the transport is already in our list,
        // and if not create an object for it.
        // ------------------------------------------------------------
		FindRtrMgr(ptransport->dwTransportId, &spRmInfo);

		if (spRmInfo == NULL)
		{
            // Construct a CRmInfo object on this transport
            // --------------------------------------------------------
			spRmInfo = new RtrMgrInfo(ptransport->dwTransportId,
								  W2T(ptransport->wszTransportName), this);
			spRmInfo->SetFlags( RouterSnapin_InSyncWithRouter );
			Assert(spRmInfo);
			bFound = FALSE;
        }
		else
			bFound = TRUE;


        // Load the information for the transport,
        // including its list of protocols
        // ------------------------------------------------------------
		hr = spRmInfo->Load(GetMachineName(),
							m_hMachineConfig,
							ptransport->hTransport);
		if (!FHrSucceeded(hr))
        {
            spRmInfo->Destruct();
            spRmInfo.Release();
            continue;
        }

        // Add the router manager object to our list
        // ------------------------------------------------------------
		if (bFound == FALSE)
		{
			SRmData	rmData;
			
			rmData.m_pRmInfo = spRmInfo;
			m_RmList.AddTail(rmData);
			
			CONVERT_TO_WEAKREF(spRmInfo);
			spRmInfo.Transfer();
		}

    }

//Error:
	if (pItemTable)
		::MprConfigBufferFree(pItemTable);

    return hr;
}


//---------------------------------------------------------------------------
// Function:    RouterInfo::LoadInterfaceList
//---------------------------------------------------------------------------

HRESULT RouterInfo::LoadInterfaceList()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
    BOOL				bAdd;
	BYTE*				pItemTable = NULL;
	SPIInterfaceInfo	spIfInfo;
    MPR_INTERFACE_0*	pinterface;
    DWORD				dwErr, i;
	DWORD				dwEntries = 0, dwTotal = 0;
	HRESULT				hr = hrOK;
	HRESULT				tmpHr = hrOK;
	SPMprServerHandle	sphMprServer;
    BOOL                fMprAdmin = TRUE;   // was MprAdminInterfaceEnum used?
	USES_CONVERSION;

	// Windows NT Bug : 180752
	// Should try to enumerate with MprAdminInterfaceEnum first.
	dwErr = ConnectRouter(GetMachineName(), &sphMprServer);
	if (dwErr == NO_ERROR)
	{
		dwErr = ::MprAdminInterfaceEnum(sphMprServer,	
										0,
										(BYTE **) &pItemTable,
										(DWORD) -1,
										&dwEntries,
										&dwTotal,
										NULL);
	}

	if (dwErr != NO_ERROR)
	{
		Assert(pItemTable == NULL);

        // MprConfigInterfaceEnum is used, not MprAdminIntefaceEnum
        // ------------------------------------------------------------
        fMprAdmin = FALSE;
		
		// Enumerate the interfaces configured
		// ------------------------------------------------------------
		dwErr = ::MprConfigInterfaceEnum(
										 m_hMachineConfig,
										 0,
										 &pItemTable,
										 (DWORD)-1,
										 &dwEntries,
										 &dwTotal,
										 NULL
										);
	}

    if (dwErr != NO_ERROR && dwErr != ERROR_NO_MORE_ITEMS)
		return HRESULT_FROM_WIN32(dwErr);

    // Delete interface-objects for interfaces which don't exist anymore
    // ----------------------------------------------------------------
    POSITION pos = m_IfList.GetHeadPosition();

    while (pos) {

        POSITION postemp = pos;

        spIfInfo.Set( m_IfList.GetNext(pos) );
		
        // See if the interface is in the new table
        // ------------------------------------------------------------
        for (i = 0, pinterface = (MPR_INTERFACE_0*)pItemTable;
             i < dwEntries;
             i++, pinterface++)
		{
			if (StriCmpW(OLE2CW(spIfInfo->GetId()), pinterface->wszInterfaceName) == 0)
				break;
        }

        // Go on if the interface was found
        // ------------------------------------------------------------
        if (i < dwEntries)
		{
            // Update the interface's settings
            // --------------------------------------------------------
			spIfInfo->SetInterfaceEnabledState( pinterface->fEnabled );
            continue;
        }

        // The interface-object was not found and is obsolete; delete it
        // ------------------------------------------------------------
        m_IfList.RemoveAt(postemp);
		spIfInfo->Destruct();
		spIfInfo->ReleaseWeakRef();	// remove list addref
		
		spIfInfo.Release();	// this will release the sp addref
    }


    // Create interface objects for each new interface
    // ----------------------------------------------------------------

    for (i = 0, pinterface = (MPR_INTERFACE_0*)pItemTable;
         i < dwEntries;
         i++, pinterface++)
	{

		spIfInfo.Release();

        // See if the interface exists,
        // and if not create a new interface object
        // ------------------------------------------------------------
		FindInterface(W2OLE(pinterface->wszInterfaceName), &spIfInfo);

        if (spIfInfo == NULL)
		{
            SInterfaceCB *  pSIfCB = NULL;
            bAdd = TRUE;

            // Find the CB that corresponds to this interface
            // --------------------------------------------------------
            pSIfCB = FindInterfaceCB(pinterface->wszInterfaceName);

            // Construct a CInterfaceInfo object on this interface
            // --------------------------------------------------------
            spIfInfo = new InterfaceInfo(W2T(pinterface->wszInterfaceName),
										 pinterface->dwIfType,
										 pinterface->fEnabled,
                                         pSIfCB ? pSIfCB->dwBindFlags :
                                           (InterfaceCB_BindToIp | InterfaceCB_BindToIpx),
                                         this);
			spIfInfo->SetFlags( RouterSnapin_InSyncWithRouter );
			Assert(spIfInfo);
        }
		else
			bAdd = FALSE;


        // Load the information for the interface
        // ------------------------------------------------------------
        tmpHr = spIfInfo->Load(GetMachineName(),
							m_hMachineConfig, NULL);

		if (!FHrSucceeded(tmpHr))
		{
			spIfInfo->Destruct();
			spIfInfo.Release();
			continue;
		}

        // add the object to our interface list
        // ------------------------------------------------------------
        if (bAdd)
		{
			m_IfList.AddTail(spIfInfo);
			CONVERT_TO_WEAKREF(spIfInfo);
			spIfInfo.Transfer();
		}
    }

//Error:
	if (pItemTable)
    {
        if (fMprAdmin)
            ::MprAdminBufferFree(pItemTable);
        else
            ::MprConfigBufferFree(pItemTable);
    }

    return hr;
}



/*!--------------------------------------------------------------------------
	RouterInfo::ReviveStrongRef
		Override of CWeakRef::ReviveStrongRef
	Author: KennT
 ---------------------------------------------------------------------------*/
void RouterInfo::ReviveStrongRef()
{
	// Don't need to do anything
}

/*!--------------------------------------------------------------------------
	RouterInfo::OnLastStrongRef
		Override of CWeakRef::OnLastStrongRef

		On the last strong reference for the router info indicates that
		there are no strong pointers to any object in the hierarchy.  Thus
		we are free to remove all of our internal pointers.
	Author: KennT
 ---------------------------------------------------------------------------*/
void RouterInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	Destruct();
}

/*!--------------------------------------------------------------------------
	RouterInfo::Destruct
		Implementation of IRouterInfo::Destruct
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IInterfaceInfo *	pIf;
	SRmData				rmData;
	
	// Destroy the interface objects
	// ----------------------------------------------------------------
	while (!m_IfList.IsEmpty())
	{
		pIf = m_IfList.RemoveHead();
		pIf->Destruct();
		pIf->ReleaseWeakRef();
	}
	
	// Destroy the router-manager objects
	// ----------------------------------------------------------------
	while (!m_RmList.IsEmpty())
	{
		rmData = m_RmList.RemoveHead();
		SRmData::Destroy( &rmData );
	}
	
	return hrOK; 
}

/*!--------------------------------------------------------------------------
	RouterInfo::TryToConnect
		If we are already connected, then the handle passed in is
		ignored.

		Otherwise, if "hMachine" was not specified, connect to the
		config on the specified machine.
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::TryToConnect(LPCWSTR pswzMachine, HANDLE hMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	if (m_hMachineConfig == NULL)
	{
		if (hMachine)
		{
			m_hMachineConfig = hMachine;
			m_bDisconnect = FALSE;			
		}
		else
		{
			CWRg( ::MprConfigServerConnect((LPWSTR) pswzMachine,
										   &m_hMachineConfig) );
			m_bDisconnect = TRUE;
		}
	}

Error:
	return hr;
}

STDMETHODIMP RouterInfo::OnChange(LONG_PTR ulConnection,
								  DWORD dwChangeType,
								  DWORD dwObjectType,
								  LPARAM lUserParam,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::MergeRtrMgrCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RouterInfo::MergeRtrMgrCB(IRouterInfo *pNewRouter)
{
	HRESULT			hr = hrOK;
	SPIEnumRtrMgrCB	spRmCB;
	RtrMgrCB		rmCB;
	SRtrMgrCB *		pSRmCB;
	POSITION		pos, posDelete;

	// Set the internal data on the SRtrMgrCBs to 0
	// ----------------------------------------------------------------
	pos = m_RmCBList.GetHeadPosition();
	while (pos)
	{
		pSRmCB = m_RmCBList.GetNext(pos);
		Assert(pSRmCB);
		pSRmCB->dwPrivate = 0;
	}

	CORg( pNewRouter->EnumRtrMgrCB(&spRmCB) );

	while (spRmCB->Next(1, &rmCB, NULL) == hrOK)
	{
		// Now look for this rmCB in our current list
		// If we find it, mark the CB
		// If we do not find it, add this RmCB
		// ------------------------------------------------------------

		pSRmCB = FindRtrMgrCB(rmCB.dwTransportId);
		if (pSRmCB)
		{
			pSRmCB->dwPrivate = 1;
		}
		else
		{
			// Add this CB to the internal list
			// --------------------------------------------------------
			SRtrMgrCB *	pNewSRmCB = new SRtrMgrCB;

			pNewSRmCB->LoadFrom(&rmCB);
			pNewSRmCB->dwPrivate = 1;
			
			m_RmCBList.AddTail(pNewSRmCB);
		}
		
	}

	// Now go through the internal list and delete all items that we
	// didn't find in the new list
	// ----------------------------------------------------------------
	pos = m_RmCBList.GetHeadPosition();
	while (pos)
	{
		pSRmCB = m_RmCBList.GetNext(pos);
		Assert(pSRmCB);
		if (pSRmCB->dwPrivate == 0)
		{
			posDelete = m_RmCBList.Find(pSRmCB);
			m_RmCBList.RemoveAt(posDelete);
			delete pSRmCB;
		}
	}

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::MergeInterfaceCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	RouterInfo::MergeInterfaceCB(IRouterInfo *pNewRouter)
{
	HRESULT			hr = hrOK;
	SPIEnumInterfaceCB	spIfCB;
	InterfaceCB		IfCB;
	SInterfaceCB *		pSIfCB;
	POSITION		pos, posDelete;

	// Set the internal data on the SInterfaceCBs to 0
	// ----------------------------------------------------------------
	pos = m_IfCBList.GetHeadPosition();
	while (pos)
	{
		pSIfCB = m_IfCBList.GetNext(pos);
		Assert(pSIfCB);
		pSIfCB->dwPrivate = 0;
	}

	CORg( pNewRouter->EnumInterfaceCB(&spIfCB) );

	while (spIfCB->Next(1, &IfCB, NULL) == hrOK)
	{
		// Now look for this IfCB in our current list
		// If we find it, mark the CB
		// If we do not find it, add this IfCB
		// ------------------------------------------------------------

		pSIfCB = FindInterfaceCB(IfCB.szId);
		if (pSIfCB)
		{
			// We found it, update the internal data
			// --------------------------------------------------------
			pSIfCB->bEnable = IfCB.bEnable;
			pSIfCB->dwPrivate = 1;
		}
		else
		{
			// Add this CB to the internal list
			// --------------------------------------------------------
			SInterfaceCB *	pNewSIfCB = new SInterfaceCB;

			pNewSIfCB->LoadFrom(&IfCB);
			pNewSIfCB->dwPrivate = 1;
			
			m_IfCBList.AddTail(pNewSIfCB);
		}
		
	}

	// Now go through the internal list and delete all items that we
	// didn't find in the new list
	// ----------------------------------------------------------------
	pos = m_IfCBList.GetHeadPosition();
	while (pos)
	{
		pSIfCB = m_IfCBList.GetNext(pos);
		Assert(pSIfCB);
		if (pSIfCB->dwPrivate == 0)
		{
			posDelete = m_IfCBList.Find(pSIfCB);
			m_IfCBList.RemoveAt(posDelete);
			delete pSIfCB;
		}
	}

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::MergeRtrMgrProtocolCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	RouterInfo::MergeRtrMgrProtocolCB(IRouterInfo *pNewRouter)
{
	HRESULT			hr = hrOK;
	SPIEnumRtrMgrProtocolCB	spRmProtCB;
	RtrMgrProtocolCB		RmProtCB;
	SRtrMgrProtocolCB *		pSRmProtCB;
	POSITION		pos, posDelete;

	// Set the internal data on the SRtrMgrProtocolCBs to 0
	// ----------------------------------------------------------------
	pos = m_RmProtCBList.GetHeadPosition();
	while (pos)
	{
		pSRmProtCB = m_RmProtCBList.GetNext(pos);
		Assert(pSRmProtCB);
		pSRmProtCB->dwPrivate = 0;
	}

	CORg( pNewRouter->EnumRtrMgrProtocolCB(&spRmProtCB) );

	while (spRmProtCB->Next(1, &RmProtCB, NULL) == hrOK)
	{
		// Now look for this RmProtCB in our current list
		// If we find it, mark the CB
		// If we do not find it, add this RmProtCB
		// ------------------------------------------------------------

		pSRmProtCB = FindRtrMgrProtocolCB(RmProtCB.dwTransportId,
										  RmProtCB.dwProtocolId);
		if (pSRmProtCB)
		{
			pSRmProtCB->dwPrivate = 1;
		}
		else
		{
			// Add this CB to the internal list
			// --------------------------------------------------------
			SRtrMgrProtocolCB *	pNewSRmProtCB = new SRtrMgrProtocolCB;

			pNewSRmProtCB->LoadFrom(&RmProtCB);
			pNewSRmProtCB->dwPrivate = 1;
			
			m_RmProtCBList.AddTail(pNewSRmProtCB);
		}
		
	}

	// Now go through the internal list and delete all items that we
	// didn't find in the new list
	// ----------------------------------------------------------------
	pos = m_RmProtCBList.GetHeadPosition();
	while (pos)
	{
		pSRmProtCB = m_RmProtCBList.GetNext(pos);
		Assert(pSRmProtCB);
		if (pSRmProtCB->dwPrivate == 0)
		{
			posDelete = m_RmProtCBList.Find(pSRmProtCB);
			m_RmProtCBList.RemoveAt(posDelete);
			delete pSRmProtCB;
		}
	}

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::MergeRtrMgrs
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	RouterInfo::MergeRtrMgrs(IRouterInfo *pNewRouter)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	SPIEnumRtrMgrInfo	spEnumRm;
	SPIRtrMgrInfo		spRm;
	HRESULT				hr = hrOK;
	CDWordArray			oldDWArray;
	CDWordArray			newDWArray;
	int					cOld, cNew;
	int					i, j;
	DWORD				dwTemp;

	Assert(pNewRouter);

	COM_PROTECT_TRY
	{
		// Need to sync up RtrMgrInfo
		
		//
		// The general algorithm is to build up two arrays
		// the first array contains the transport ids for this object
		// the second array contains the ids for the new object
		//
		// We then go through and remove all transports that are in
		// BOTH lists.
		//
		// This will leave us with the first array containing the
		// ids of the transports that need to be deleted from this object.
		//
		// The second array will have the list of ids of transports that
		// have to be added to this object from the second object.
		// ------------------------------------------------------------

		// Get the list of transports that are in the new object
		// ------------------------------------------------------------
		CORg( pNewRouter->EnumRtrMgr(&spEnumRm) );
		spEnumRm->Reset();
		while (spEnumRm->Next(1, &spRm, NULL) == hrOK)
		{
			newDWArray.Add(spRm->GetTransportId());
			spRm.Release();
		}

		spEnumRm.Release();
		spRm.Release();


		// Get the list of transports that are in this object
		// ------------------------------------------------------------
		CORg( this->EnumRtrMgr(&spEnumRm) );
		spEnumRm->Reset();
		while (spEnumRm->Next(1, &spRm, NULL) == hrOK)
		{
			oldDWArray.Add(spRm->GetTransportId());
			spRm.Release();
		}

		spEnumRm.Release();
		spRm.Release();


		// Ok now go through both lists, removing from the lists
		// transports that are in both lists.
		// ------------------------------------------------------------
		cOld = oldDWArray.GetSize();
		cNew = newDWArray.GetSize();
		for (i=cOld; --i>=0; )
		{
			dwTemp = oldDWArray.GetAt(i);
			for (j=cNew; --j>=0; )
			{
				if (dwTemp == newDWArray.GetAt(j))
				{
					SPIRtrMgrInfo	spRm1;
					SPIRtrMgrInfo	spRm2;

					this->FindRtrMgr(dwTemp, &spRm1);
					pNewRouter->FindRtrMgr(dwTemp, &spRm2);

					Assert(spRm1);
					Assert(spRm2);
					spRm1->Merge(spRm2);
										
					// remove both instances
					// ------------------------------------------------
					newDWArray.RemoveAt(j);
					oldDWArray.RemoveAt(i);

					// Need to update the size of the new array
					// ------------------------------------------------
					cNew--;
					break;
				}
			}
		}

		// oldDWArray now contains the transports that should be
		// removed.
		// ------------------------------------------------------------
		if (oldDWArray.GetSize())
		{
			for (i=oldDWArray.GetSize(); --i>=0; )
			{
				DeleteRtrMgr(oldDWArray.GetAt(i), FALSE);
			}
		}

		// newDWArray contains the transports that should be added
		// ------------------------------------------------------------
		if (newDWArray.GetSize())
		{
			for (i=newDWArray.GetSize(); --i>= 0; )
			{
				hr = pNewRouter->FindRtrMgr(newDWArray.GetAt(i), &spRm);
				Assert(hr == hrOK);
				Assert(spRm);

				// Do a sanity check, make sure that this RtrMgr is
				// in the RtrMgrCB list
				// ----------------------------------------------------
				Assert(FindRtrMgrCB(spRm->GetTransportId()));

                
                // Add this router manager, to the router info.
                // ----------------------------------------------------
				if (spRm)
                {
					AddRtrMgr(spRm, NULL, NULL);

                    // Remove this router manager from its previous router
                    // ------------------------------------------------
                    pNewRouter->ReleaseRtrMgr(spRm->GetTransportId());
                }

				spRm.Release();
			}
		}
		
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	RouterInfo::MergeInterfaces
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	RouterInfo::MergeInterfaces(IRouterInfo *pNewRouter)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	SPIEnumInterfaceInfo	spEnumIf;
	SPIInterfaceInfo		spIf;
	HRESULT				hr = hrOK;
	CStringArray		oldStArray;
	CStringArray		newStArray;
	int					cOld, cNew;
	int					i, j;
	CString				stTemp;

	Assert(pNewRouter);

	COM_PROTECT_TRY
	{
		// Need to sync up InterfaceInfo
		// ------------------------------------------------------------
		
		//
		// The general algorithm is to build up two arrays
		// the first array contains the protocol ids for this object
		// the second array contains the ids for the new object
		//
		// We then go through and remove all protocols that are in
		// BOTH lists.
		//
		// This will leave us with the first array containing the
		// ids of the protocols that need to be deleted from this object.
		//
		// The second array will have the list of ids of protocols that
		// have to be added to this object from the second object.
		// ------------------------------------------------------------

		// Get the list of protocols that are in the new object
		// ------------------------------------------------------------
		CORg( pNewRouter->EnumInterface(&spEnumIf) );
		spEnumIf->Reset();
		while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
		{
			newStArray.Add(spIf->GetId());
			spIf.Release();
		}

		spEnumIf.Release();
		spIf.Release();


		// Get the list of protocols that are in this object
		// ------------------------------------------------------------
		CORg( this->EnumInterface(&spEnumIf) );
		spEnumIf->Reset();
		while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
		{
			oldStArray.Add(spIf->GetId());
			spIf.Release();
		}

		spEnumIf.Release();
		spIf.Release();


		// Ok now go through both lists, removing from the lists
		// protocols that are in both lists.
		// ------------------------------------------------------------
		cOld = oldStArray.GetSize();
		cNew = newStArray.GetSize();
		for (i=cOld; --i>=0; )
		{
			stTemp = oldStArray.GetAt(i);
			for (j=cNew; --j>=0; )
			{
				if (stTemp == newStArray.GetAt(j))
				{
					SPIInterfaceInfo	spIf1;
					SPIInterfaceInfo	spIf2;

					this->FindInterface(stTemp, &spIf1);
					pNewRouter->FindInterface(stTemp, &spIf2);

					Assert(spIf1);
					Assert(spIf2);
					spIf1->Merge(spIf2);
										
					// remove both instances
					// ------------------------------------------------
					newStArray.RemoveAt(j);
					oldStArray.RemoveAt(i);

					// Need to update the size of the new array
					// ------------------------------------------------
					cNew--;
					break;
				}
			}
		}

		// oldStArray now contains the protocols that should be
		// removed.
		// ------------------------------------------------------------
		if (oldStArray.GetSize())
		{
			for (i=oldStArray.GetSize(); --i>=0; )
			{
				RemoveInterfaceInternal(oldStArray.GetAt(i),
                                        FALSE /* fRemoveFromRouter */ );
			}
		}

		// newStArray contains the protocols that should be added
		// ------------------------------------------------------------
		if (newStArray.GetSize())
		{
			for (i=newStArray.GetSize(); --i>= 0; )
			{
				hr = pNewRouter->FindInterface(newStArray.GetAt(i), &spIf);
				Assert(hr == hrOK);
				Assert(spIf);

				// Do a sanity check, make sure that this Interface is
				// in the InterfaceCB list
				// This is only true if this is a LAN adapter.
				// Assert(FindInterfaceCB(spIf->GetId()));

				// We allow errors to not affect whether or not
				// the interface is added to the UI (this allows us
				// to stay in sync with the merged routerinfo).
				// ----------------------------------------------------
				if (spIf)
                {
					hr = AddInterfaceInternal(spIf, FALSE, FALSE);

                    // Send the RmIf notifications
                    // ------------------------------------------------
                    if (FHrOK(hr))
                        NotifyRtrMgrInterfaceOfMove(spIf);
                    
                    // Remove this interface from its previous router
                    // ------------------------------------------------
                    pNewRouter->ReleaseInterface(spIf->GetId());
                }
				spIf.Release();
			}
		}
		
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}


/*!--------------------------------------------------------------------------
	RouterInfo::FindRtrMgrCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
SRtrMgrCB *	RouterInfo::FindRtrMgrCB(DWORD dwTransportId)
{
	POSITION	pos;
	SRtrMgrCB *	pSRmCB = NULL;

	pos = m_RmCBList.GetHeadPosition();

	while (pos)
	{
		pSRmCB = m_RmCBList.GetNext(pos);
		Assert(pSRmCB);
		if (pSRmCB->dwTransportId == dwTransportId)
			return pSRmCB;
	}
	return NULL;
}

/*!--------------------------------------------------------------------------
	RouterInfo::FindRtrMgrProtocolCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
SRtrMgrProtocolCB * RouterInfo::FindRtrMgrProtocolCB(DWORD dwTransportId, DWORD dwProtocolId)
{
	POSITION	pos;
	SRtrMgrProtocolCB *	pSRmProtCB = NULL;

	pos = m_RmProtCBList.GetHeadPosition();

	while (pos)
	{
		pSRmProtCB = m_RmProtCBList.GetNext(pos);
		Assert(pSRmProtCB);
		if ((pSRmProtCB->dwTransportId == dwTransportId) &&
			(pSRmProtCB->dwProtocolId == dwProtocolId))
			return pSRmProtCB;
	}
	return NULL;
}

/*!--------------------------------------------------------------------------
	RouterInfo::FindInterfaceCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
SInterfaceCB *	RouterInfo::FindInterfaceCB(LPCTSTR pszInterfaceId)
{
	POSITION	pos;
	SInterfaceCB *	pSIfCB = NULL;

	pos = m_IfCBList.GetHeadPosition();

	while (pos)
	{
		pSIfCB = m_IfCBList.GetNext(pos);
		Assert(pSIfCB);
		if (StriCmp(pSIfCB->stTitle, pszInterfaceId) == 0)
			return pSIfCB;
	}
	return NULL;
}


/*!--------------------------------------------------------------------------
	RouterInfo::Disconnect
		Removes connections made by this object.
	Author: KennT
 ---------------------------------------------------------------------------*/
void RouterInfo::Disconnect()
{
		if (m_bDisconnect)
			::MprConfigServerDisconnect(m_hMachineConfig);
		
		m_bDisconnect = FALSE;
		m_hMachineConfig = NULL;
}

/*!--------------------------------------------------------------------------
	RouterInfo::DoDisconnect
		We are to disconnect our connections from the server.
		This means calling MprConfigServerDisconnect() on our
		connections.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RouterInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;
	SPIEnumRtrMgrInfo	spEnumRm;
	SPIRtrMgrInfo		spRm;
	SPIEnumInterfaceInfo	spEnumIf;
	SPIInterfaceInfo	spIf;

	COM_PROTECT_TRY
	{
		// Disconnect ourselves
		// ------------------------------------------------------------
		Disconnect();


		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);


		// Now tell all child objects to disconnect.
		// ------------------------------------------------------------
		HRESULT			hrIter = hrOK;

		
		// Tell each of the router-managers to disconnect.
		// ------------------------------------------------------------
		EnumRtrMgr(&spEnumRm);
		spEnumRm->Reset();
		while (spEnumRm->Next(1, &spRm, NULL) == hrOK)
		{
			spRm->DoDisconnect();
			spRm.Release();
		}


		// Tell each interface to disconnect.
		// ------------------------------------------------------------
		EnumInterface(&spEnumIf);
		spEnumIf->Reset();
		while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
		{
			spIf->DoDisconnect();
			spIf.Release();
		}
		
		
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
    RouterInfo::IsAdminInfoSet
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(BOOL) RouterInfo::IsAdminInfoSet()
{
    return m_fIsAdminInfoSet;
}

STDMETHODIMP_(LPCOLESTR) RouterInfo::GetUserName()
{
    if (m_fIsAdminInfoSet)
        return (LPCOLESTR) m_stUserName;
    else
        return NULL;
}

STDMETHODIMP_(LPCOLESTR) RouterInfo::GetDomainName()
{
    if (m_fIsAdminInfoSet && !m_stDomain.IsEmpty())
        return (LPCOLESTR) m_stDomain;
    else
        return NULL;
}

STDMETHODIMP RouterInfo::GetUserPassword(BYTE *pPassword, int *pcPassword)
{
    HRESULT     hr = hrOK;

    if (pPassword == NULL)
    {
        Assert(pcPassword);
        *pcPassword = m_cPassword;
        return hr;
    }

    Assert(pPassword);
    Assert(pcPassword);

    COM_PROTECT_TRY
    {
        if (!m_fIsAdminInfoSet)
        {
            *pcPassword = 0;
        }
        else
        {
            CopyMemory(pPassword, m_pbPassword, m_cPassword);
            *pcPassword = m_cPassword;
        }
    }
    COM_PROTECT_CATCH;

    return hr;       
}

STDMETHODIMP RouterInfo::SetInfo(LPCOLESTR pszName,
                                 LPCOLESTR pszDomain,
                                 LPBYTE pPassword,
                                 int cPassword)
{
    HRESULT     hr = hrOK;

    Assert(pszName);

    COM_PROTECT_TRY
    {
        m_stUserName = pszName;
        m_stDomain = pszDomain;

        // Allocate space for the password
        delete m_pbPassword;
        m_pbPassword = NULL;
        m_cPassword = 0;
        
        if (cPassword)
        {
            m_pbPassword = new BYTE[cPassword];
            CopyMemory(m_pbPassword, pPassword, cPassword);
            m_cPassword = cPassword;
        }
        
        m_fIsAdminInfoSet = TRUE;
    }
    COM_PROTECT_CATCH;

    return hr;       
}





/*---------------------------------------------------------------------------
	RtrMgrInfo implementation
 ---------------------------------------------------------------------------*/


IMPLEMENT_WEAKREF_ADDREF_RELEASE(RtrMgrInfo);

IMPLEMENT_SIMPLE_QUERYINTERFACE(RtrMgrInfo, IRtrMgrInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrInfo)

RtrMgrInfo::RtrMgrInfo(DWORD dwTransportId,
					   LPCTSTR pszTransportName,
					   RouterInfo *pRouterInfo)
	: m_hMachineConfig(NULL),
	m_hTransport(NULL),
	m_bDisconnect(FALSE),
	m_dwFlags(0)
{
	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrInfo);
	
	m_cb.dwTransportId = dwTransportId;
	m_cb.stId = pszTransportName;

	// There is a case in the old code where pRouterInfo == NULL
	// It is in the CAddRouterManager dialog, however this is
	// not called from anywhere in the code.
	// ----------------------------------------------------------------
	Assert(pRouterInfo);
	
	m_pRouterInfoParent = static_cast<IRouterInfo *>(pRouterInfo);
	if (m_pRouterInfoParent)
		m_pRouterInfoParent->AddRef();

	InitializeCriticalSection(&m_critsec);
}

RtrMgrInfo::~RtrMgrInfo()
{
	Assert(m_pRouterInfoParent == NULL);
	Assert(m_AdviseList.IsEmpty());
	Destruct();
	DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrInfo);

	DeleteCriticalSection(&m_critsec);
}

void RtrMgrInfo::ReviveStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRouterInfoParent)
	{
		CONVERT_TO_STRONGREF(m_pRouterInfoParent);
	}
}

void RtrMgrInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRouterInfoParent)
	{
		CONVERT_TO_WEAKREF(m_pRouterInfoParent);
	}
	if (m_fDestruct)
		Destruct();
}

STDMETHODIMP RtrMgrInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRouterInfo *	pParent;
	
	m_fDestruct = TRUE;
	if (!m_fStrongRef)
	{
		// Release the parent pointer
		// ------------------------------------------------------------
		pParent = m_pRouterInfoParent;
		m_pRouterInfoParent = NULL;
		if (pParent)
			pParent->ReleaseWeakRef();

		// Release the data
		// ------------------------------------------------------------
		Unload();
	}
	return hrOK;
}

STDMETHODIMP_(DWORD) RtrMgrInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP RtrMgrInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::Load
		-
		Loads a CRmInfo structure from the registry
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::Load(LPCOLESTR         pszMachine,
							  HANDLE          hMachine,
							  HANDLE          hTransport
							 )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	SPIEnumRtrMgrCB	spEnumRmCB;
	IEnumRtrMgrCB *	pEnumRmCB;
	BOOL			bFound;
	RtrMgrCB		RmCBTemp;
	USES_CONVERSION;
		

	COM_PROTECT_TRY
	{
		// Discard any existing information
		// ------------------------------------------------------------
		Unload();
		
		m_stMachine = (pszMachine ? pszMachine : TEXT(""));

		// if 'hMachine' was not specified, connect to the config
		// on the specified machine
		// ------------------------------------------------------------
		Assert(m_hMachineConfig == NULL);
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );

        // if 'hTransport' was not specified, connect to the transport
        // ------------------------------------------------------------
        if (hTransport)
			m_hTransport = hTransport;
        else
		{
			CWRg( ::MprConfigTransportGetHandle(hMachine,
												GetTransportId(),
												&hTransport));
            m_hTransport = hTransport;
        }


        // Retrieve the title, dll-path, and config-dll from the Software key;
        // ------------------------------------------------------------
		Assert(m_pRouterInfoParent);
		CORg( m_pRouterInfoParent->EnumRtrMgrCB(&pEnumRmCB) );
		spEnumRmCB = pEnumRmCB;

        // Find the control-block for the router-manager being loaded
        // ------------------------------------------------------------
		bFound = FALSE;
		pEnumRmCB->Reset();
		while (pEnumRmCB->Next(1, &RmCBTemp, NULL) == hrOK)
		{			
            // Get the next control-block
            // --------------------------------------------------------
			if (RmCBTemp.dwTransportId != GetTransportId())
				continue;

			m_cb.stTitle = OLE2CT(RmCBTemp.szId);
			m_cb.stDLLPath= OLE2CT(RmCBTemp.szTitle);
			//m_cb.stConfigDLL = OLE2CT(RmCBTemp.szConfigDLL);

            bFound = TRUE;
            break;
        }

        if (!bFound)
			m_cb.stTitle = m_cb.stId;

        // Load the list of routing-protocols for this router-manager
        // ------------------------------------------------------------
        CWRg( LoadRtrMgrInfo(hMachine,
							 hTransport) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	if (!FHrSucceeded(hr))
		Unload();
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::Save
		-
		This function saves the information for a CRmInfo in the registry.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::Save(LPCOLESTR		pszMachine,
							  HANDLE          hMachine,
							  HANDLE          hTransport,
							  IInfoBase *		pGlobalInfo,
							  IInfoBase *     pClientInfo,
							  DWORD           dwDeleteProtocolId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	DWORD dwErr;
	LPWSTR pwsz = NULL;
	WCHAR wszTransport[MAX_TRANSPORT_NAME_LEN+1];
	SPWSZ	spwszDll;
	
	COM_PROTECT_TRY
	{
		// If we are already connected (i.e. 'm_hMachineConfig' is non-NULL)
		// then the handle passed in is ignored.
		//
		// Otherwise, if 'hMachine' was not specified, connect to the config
		// on the specified machine
		// ------------------------------------------------------------
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );
		
		
		// If we are already connected (i.e. 'm_hTransport' is non-NULL)
		// then the handle passed in is ignored.
		//
		// Otherwise, if 'hTransport' wasn't passed in, try to get a handle
		// to the transport; if that fails, create the transport.
		// ------------------------------------------------------------
		if (m_hTransport)
			hTransport = m_hTransport;
		else if (hTransport)
			m_hTransport = hTransport;
		else
		{
			// Get a handle to the transport
			// --------------------------------------------------------
			dwErr = ::MprConfigTransportGetHandle(hMachine,
									m_cb.dwTransportId, &hTransport);			
			if (dwErr != NO_ERROR)
			{
				// We couldn't get a handle to the transport,
				// so now attempt to create it.
				//
				// Convert transport-name to Unicode
				// ----------------------------------------------------
				if (!m_cb.stId.GetLength())
					pwsz = NULL;
				else
					pwsz = StrCpyWFromT(wszTransport, m_cb.stId);
				
				// Convert the DLL path to Unicode
				// ----------------------------------------------------
				spwszDll = StrDupWFromT(m_cb.stDLLPath);
								
				// Create the transport
				// ----------------------------------------------------
				CWRg( ::MprConfigTransportCreate(hMachine,
												GetTransportId(),
												pwsz,
												NULL,
												0,
												NULL,
												0,
												spwszDll,
												&hTransport
												));
			}
		}
				
		// Now save the global info for the transport
		// ------------------------------------------------------------
		CWRg( SaveRtrMgrInfo(hMachine,
							 hTransport,
							 pGlobalInfo,
							 pClientInfo,
							 dwDeleteProtocolId) );
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::Unload
		Implementation of IRtrMgrInfo::Unload
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::Unload( )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	IRtrMgrProtocolInfo	* pRmProt;
	
	COM_PROTECT_TRY
	{
		while (!m_RmProtList.IsEmpty())
		{
			pRmProt = m_RmProtList.RemoveHead();
			pRmProt->Destruct();
			pRmProt->ReleaseWeakRef();
		}

		DoDisconnect();
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::Delete
		-
		This function removes the information associated with a router-manager
		from the registry.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::Delete(LPCOLESTR	pszMachine,
								HANDLE      hMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    HANDLE hTransport = NULL;
	
	COM_PROTECT_TRY
	{
		//
		// If already connected, the handle passed in is ignored;
		//
		// Otherwise, if 'hMachine' was not specified, connect to the config
		// on the specified machine
		//
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );

        //
        // Attempt to get a handle for the transport
        //
        CWRg( ::MprConfigTransportGetHandle(hMachine,
											m_cb.dwTransportId,
											&hTransport
										   ) );

        //
        // Delete the transport
        //
        CWRg( ::MprConfigTransportDelete(hMachine, hTransport) );

        m_hTransport = NULL;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}
		
/*!--------------------------------------------------------------------------
	RtrMgrInfo::SetInfoBase
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::SetInfoBase(IInfoBase*      pGlobalInfo,
									 IInfoBase*      pClientInfo )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	MPR_SERVER_HANDLE	hRouter = NULL;
    BYTE* pGlobalInfoData = NULL, *pClientInfoData = NULL;
    DWORD dwGlobalInfoDataSize = 0, dwClientInfoDataSize = 0;
	DWORD	dwErr;

	COM_PROTECT_TRY
	{
        //
        // Format the router-manager's data as an opaque block
        //
        if (pGlobalInfo)
            CORg( pGlobalInfo->WriteTo(&pGlobalInfoData, &dwGlobalInfoDataSize) );

        //
        // Format the client-interface's data as an opaque block
        //
        if (pClientInfo)
            CORg( pClientInfo->WriteTo(&pClientInfoData, &dwClientInfoDataSize) );
		
        //
        // Connect to the router
        //
		CORg( ConnectRouter(GetMachineName(), &hRouter) );

        //
        // Set the new info for the router-manager
        //
		dwErr = MprAdminTransportSetInfo(hRouter,
										 GetTransportId(),
										 pGlobalInfoData,
										 dwGlobalInfoDataSize,
										 pClientInfoData,
										 dwClientInfoDataSize
										);

		if ((dwErr == RPC_S_SERVER_UNAVAILABLE) ||
			(dwErr == RPC_S_UNKNOWN_IF))
			dwErr = NO_ERROR;
		CWRg( dwErr );
	
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	CoTaskMemFree( pGlobalInfoData );
	CoTaskMemFree( pClientInfoData );

	if (hRouter)
		::MprAdminServerDisconnect(hRouter);
	
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetInfoBase
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::GetInfoBase(HANDLE		hMachine,
									 HANDLE		hTransport,
									 IInfoBase **ppGlobalInfo,
									 IInfoBase **ppClientInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrOK;
	COM_PROTECT_TRY
	{
        CORg( TryToGetAllHandles(m_stMachine,
                                 &hMachine,
                                 &hTransport) );
		hr = ::LoadInfoBase(hMachine ? hMachine : m_hMachineConfig,
							hTransport ? hTransport : m_hTransport,
							ppGlobalInfo, ppClientInfo);

        COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::Merge
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::Merge(IRtrMgrInfo *pNewRm)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	SPIEnumRtrMgrProtocolInfo	spEnumRmProt;
	SPIRtrMgrProtocolInfo		spRmProt;
	HRESULT				hr = hrOK;
	CDWordArray			oldDWArray;
	CDWordArray			newDWArray;
	int					cOld, cNew;
	int					i, j;
	DWORD				dwTemp;
	RtrMgrCB			rmCB;

	Assert(pNewRm);
	Assert(pNewRm->GetTransportId() == GetTransportId());

	COM_PROTECT_TRY
	{
		pNewRm->CopyRtrMgrCB(&rmCB);
		m_cb.LoadFrom(&rmCB);
		
		//
		// The general algorithm is to build up two arrays
		// the first array contains the protocol ids for this object
		// the second array contains the ids for the new object
		//
		// We then go through and remove all protocols that are in
		// BOTH lists.
		//
		// This will leave us with the first array containing the
		// ids of the protocols that need to be deleted from this object.
		//
		// The second array will have the list of ids of protocols that
		// have to be added to this object from the second object.
		//

		// Get the list of protocols that are in the new object
		CORg( pNewRm->EnumRtrMgrProtocol(&spEnumRmProt) );
		spEnumRmProt->Reset();
		while (spEnumRmProt->Next(1, &spRmProt, NULL) == hrOK)
		{
			newDWArray.Add(spRmProt->GetProtocolId());
			spRmProt.Release();
		}

		spEnumRmProt.Release();
		spRmProt.Release();


		// Get the list of protocols that are in this object
		CORg( this->EnumRtrMgrProtocol(&spEnumRmProt) );
		spEnumRmProt->Reset();
		while (spEnumRmProt->Next(1, &spRmProt, NULL) == hrOK)
		{
			oldDWArray.Add(spRmProt->GetProtocolId());
			spRmProt.Release();
		}

		spEnumRmProt.Release();
		spRmProt.Release();


		// Ok now go through both lists, removing from the lists
		// protocols that are in both lists.
		cOld = oldDWArray.GetSize();
		cNew = newDWArray.GetSize();
		for (i=cOld; --i>=0; )
		{
			dwTemp = oldDWArray.GetAt(i);
			for (j=cNew; --j>=0; )
			{
				if (dwTemp == newDWArray.GetAt(j))
				{
					// remove both instances
					newDWArray.RemoveAt(j);
					oldDWArray.RemoveAt(i);

					// Need to update the size of the new array
					cNew--;
					break;
				}
			}
		}

		// oldDWArray now contains the protocols that should be
		// removed.
		if (oldDWArray.GetSize())
		{
			for (i=oldDWArray.GetSize(); --i>=0; )
			{
				DeleteRtrMgrProtocol(oldDWArray.GetAt(i), FALSE);
			}
		}

		// newDWArray contains the protocols that should be added
		if (newDWArray.GetSize())
		{
			for (i=newDWArray.GetSize(); --i>= 0; )
			{
				hr = pNewRm->FindRtrMgrProtocol(
										newDWArray.GetAt(i), &spRmProt);
				Assert(hr == hrOK);

				if (spRmProt)
                {
					AddRtrMgrProtocol(spRmProt, NULL, NULL);

                    // Remove this rmprot from its old router
                    // ------------------------------------------------
                    pNewRm->ReleaseRtrMgrProtocol(spRmProt->GetProtocolId());
                }

                
				spRmProt.Release();
			}
		}
		
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInfo::GetId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.stId;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::SetId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::SetId(LPCOLESTR pszId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.stId = pszId;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetTransportId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrInfo::GetTransportId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwTransportId;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInfo::GetTitle()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE
	// This assumes that we are native UNICODE
	// and that OLECHAR == WCHAR
	return m_cb.stTitle;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::CopyRtrMgrCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::CopyRtrMgrCB(RtrMgrCB *pRmCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.SaveTo(pRmCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}

	

/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
LPCOLESTR RtrMgrInfo::GetMachineName()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE
	// This assumes that we are native UNICODE and that
	// OLECHAR == WCHAR
	return m_stMachine;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::EnumRtrMgrProtocol
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::EnumRtrMgrProtocol(IEnumRtrMgrProtocolInfo ** ppEnumRmProt)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromRtrMgrProtocolList(&m_RmProtList, ppEnumRmProt);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::FindRtrMgrProtocol
		S_OK is returned if a RtrMgrInfo is found.
		S_FALSE is returned if a RtrMgrInfo was NOT found.
		error codes returned otherwise.
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::FindRtrMgrProtocol(DWORD dwProtocolId,
											IRtrMgrProtocolInfo **ppRmProtInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIRtrMgrProtocolInfo	spRmProt;
	
	COM_PROTECT_TRY
	{
		if (ppRmProtInfo)
			*ppRmProtInfo = NULL;
		
		// Look through the list of rtr mgrs for the one that matches
		pos = m_RmProtList.GetHeadPosition();
		while (pos)
		{
			spRmProt.Set(m_RmProtList.GetNext(pos));
			Assert(spRmProt);
			if (spRmProt->GetProtocolId() == dwProtocolId)
			{
				hr = hrOK;
				if (ppRmProtInfo)
				{
					// The spRmProt::Set, does a strong reference
					// so we don't need to convert to a strong reference
					*ppRmProtInfo = spRmProt.Transfer();
				}
				break;
			}
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}
	
/*!--------------------------------------------------------------------------
	RtrMgrInfo::AddRtrMgrProtocol
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::AddRtrMgrProtocol(IRtrMgrProtocolInfo *pInfo,
										   IInfoBase * pGlobalInfo,
										   IInfoBase * pClientInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	Assert(pInfo);
	
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		//
		// Fail if there is a duplicate
		//
		if (FHrOK(FindRtrMgrProtocol(pInfo->GetProtocolId(), NULL)))
			CORg(E_INVALIDARG);

		//
		// Save the router-manager's data
		//
		if (pGlobalInfo || pClientInfo)
		{
			CORg( Save(GetMachineName(),
					   m_hMachineConfig,
					   m_hTransport,
					   pGlobalInfo,
					   pClientInfo,
					   0) );
		}
		
		//
		// Add the routing-protocol to the list
		//
		m_RmProtList.AddTail(pInfo);
		pInfo->AddWeakRef();
		pInfo->SetParentRtrMgrInfo(this);

		m_AdviseList.NotifyChange(ROUTER_CHILD_ADD, ROUTER_OBJ_RmProt, 0);
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::DeleteRtrMgrProtocol
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::DeleteRtrMgrProtocol( DWORD dwProtocolId, BOOL fRemove )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	SPIRtrMgrProtocolInfo	spRmProt;
	POSITION			pos, posRmProt;
	SPIEnumInterfaceInfo	spEnumIf;
	SPIEnumRtrMgrInterfaceInfo	spEnumRmIf;
	SPIInterfaceInfo		spIf;
	SPIRtrMgrInterfaceInfo	spRmIf;
	
	COM_PROTECT_TRY
	{

		//
		// Find the routing-protocol to be deleted
		//
		pos = m_RmProtList.GetHeadPosition();
		while (pos)
		{
			posRmProt = pos;
			spRmProt.Set( m_RmProtList.GetNext(pos) );
			Assert(spRmProt);

			if (spRmProt->GetProtocolId() == dwProtocolId)
				break;
			spRmProt.Release();
		}

		if (!spRmProt)
			CORg( E_INVALIDARG );

		// We should also go through and remove the protocols
		// from any interfaces that use the protocols
		if (m_pRouterInfoParent)
		{
			// Ask the parent for its list of interfaces
			m_pRouterInfoParent->EnumInterface(&spEnumIf);

			for (;spEnumIf->Next(1, &spIf, NULL) == hrOK; spIf.Release())
			{
				// Now enumerate through all of the RtrMgrs on this interface
				spEnumRmIf.Release();
				spRmIf.Release();
				
				spIf->EnumRtrMgrInterface(&spEnumRmIf);
				for (;spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK;
					 spRmIf.Release())
				{
					if (spRmIf->GetTransportId() == GetTransportId())
					{
						// Call this on all interfaces, it should just
						// fail if the protocol is not on that interface
						spRmIf->DeleteRtrMgrProtocolInterface(dwProtocolId,
                            fRemove);
						break;
					}
				}
			}
		}
		
		//
		// save the updated information, removing any block
		// belonging to the deleted routing-protocol
		//
        if (fRemove)
            CORg( Save(GetMachineName(),
                       m_hMachineConfig,
                       m_hTransport,
                       NULL,
                       NULL,
                       dwProtocolId) );

		//
		// remove the protocol from our list
		//
		spRmProt->Destruct();
		spRmProt->ReleaseWeakRef();
//		spRmProt.Transfer();
		m_RmProtList.RemoveAt(posRmProt);

		m_AdviseList.NotifyChange(ROUTER_CHILD_DELETE, ROUTER_OBJ_RmProt, 0);
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::ReleaseRtrMgrProtocol
		This function will release the AddRef() that this object has
        on the child.  This allows us to transfer child objects from
        one router to another.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::ReleaseRtrMgrProtocol( DWORD dwProtocolId )
{
    HRESULT     hr = hrOK;
    POSITION    pos, posRmProt;
	SPIRtrMgrProtocolInfo	spRmProt;
    
    COM_PROTECT_TRY
    {
		pos = m_RmProtList.GetHeadPosition();
		while (pos)
		{
            // Save the position (so that we can delete it)
            posRmProt = pos;
            spRmProt.Set( m_RmProtList.GetNext(pos) );

            if (spRmProt &&
                (spRmProt->GetProtocolId() == dwProtocolId))
            {
                // When releasing, we need to disconnect (since the
                // main handle is controlled by the router info).
                spRmProt->DoDisconnect();
        
                spRmProt->ReleaseWeakRef();
                spRmProt.Release();
                
                // release this node from the list
                m_RmProtList.RemoveAt(posRmProt);
                break;
            }
            spRmProt.Release();
		}        
    }
    COM_PROTECT_CATCH;
    return hr;
}

	
/*!--------------------------------------------------------------------------
	RtrMgrInfo::RtrAdvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::RtrAdvise(IRtrAdviseSink *pRtrAdviseSink,
								   LONG_PTR *pulConnection,
								   LPARAM lUserParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}



/*!--------------------------------------------------------------------------
	RtrMgrInfo::RtrNotify
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::RtrUnadvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::RtrUnadvise(LONG_PTR ulConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(ulConnection);
}


	
/*!--------------------------------------------------------------------------
	RtrMgrInfo::LoadRtrMgrInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInfo::LoadRtrMgrInfo(HANDLE	hMachine,
								   HANDLE	hTransport)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT			hr = hrOK;
	SPIInfoBase		spGlobalInfo;
	SPIEnumInfoBlock	spEnumInfoBlock;
	SPIEnumRtrMgrProtocolCB	spEnumRmProtCB;
	InfoBlock *		pBlock;
	RtrMgrProtocolCB	RmProtCB;
	RtrMgrProtocolInfo *pRmProt = NULL;

	//
    // If reloading, always load the global info, whether or not
    // the caller has requested that it be loaded, since it will be needed
    // to build the list of installed protocols.
    //

	//$ Review: kennt, what do we do with an error? This case was not
	// checked previously.
	GetInfoBase(hMachine, hTransport, &spGlobalInfo, NULL);

    //
    // We are reloading, so we need to rebuild the list of protocols.
    // Get a list of the installed routing-protocols;
	//
	CORg( m_pRouterInfoParent->EnumRtrMgrProtocolCB(&spEnumRmProtCB) );

    //
    // Go through the list of blocks in the global info
    // constructing a CRmProtInfo for each one that corresponds
    // to a routing-protocol
    //

	CORg( spGlobalInfo->QueryBlockList(&spEnumInfoBlock) );

	spEnumInfoBlock->Reset();

	while (spEnumInfoBlock->Next(1, &pBlock, NULL) == hrOK)
	{
        //
        // When a routing protocol is removed, its block is left in place,
        // but with zero-length data.
        // We skip such blocks since they don't represent installed protocols.
        //
        if (!pBlock->dwSize)
			continue;

        //
        // Try to find a routing protocol whose protocol-ID
        // is the same as this block's type
        //

		spEnumRmProtCB->Reset();

		while (spEnumRmProtCB->Next(1, &RmProtCB, NULL) == hrOK)
		{
            //
            // If this isn't the protocol's control block, continue
            //
            if (RmProtCB.dwProtocolId != pBlock->dwType)
				continue;

            //
            // This is the control block, so construct a new CRmProtInfo
            //
			pRmProt = new RtrMgrProtocolInfo(RmProtCB.dwProtocolId,
											 RmProtCB.szId,
											 GetTransportId(),
											 m_cb.stId,
											 this);
			Assert(pRmProt);

			pRmProt->SetCB(&RmProtCB);

            //
            // Add the new protocol to our list
            //
			m_RmProtList.AddTail(pRmProt);
			CONVERT_TO_WEAKREF(pRmProt);
			pRmProt = NULL;

            break;
        }
    }

Error:
	if (pRmProt)
		pRmProt->Release();
    return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::SaveRtrMgrInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInfo::SaveRtrMgrInfo(HANDLE hMachine,
								   HANDLE hTransport,
								   IInfoBase *pGlobalInfo,
								   IInfoBase *pClientInfo,
								   DWORD dwDeleteProtocolId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrOK;
	SPIInfoBase	spGlobalInfoTemp;
	SPIInfoBase	spClientInfoTemp;
    DWORD dwGlobalBytesSize, dwClientBytesSize;
    LPBYTE pGlobalBytes = NULL, pClientBytes = NULL;

	COM_PROTECT_TRY
	{
        //
        // If asked to delete a protocol, delete it now
        //
        if (dwDeleteProtocolId)
		{
            //
            // If either global-info or client info was not given
            // load the unspecified parameters so that they can be updated
            // after the protocol to be deleted has been removed
            //
            if (!pGlobalInfo || !pClientInfo)
			{

				GetInfoBase(hMachine, hTransport,
							pGlobalInfo ? NULL : &spGlobalInfoTemp,
							pClientInfo ? NULL : &spClientInfoTemp
						   );
				if (pGlobalInfo == NULL)
					pGlobalInfo = spGlobalInfoTemp;
				if (pClientInfo == NULL)
					pClientInfo = spClientInfoTemp;				
            }

            //
            // Now remove the protocol specified
            //
            pGlobalInfo->SetData(dwDeleteProtocolId, 0, NULL, 0, 0);
            pClientInfo->SetData(dwDeleteProtocolId, 0, NULL, 0, 0);
        }

        //
        // Now update the information in the registry
        // Convert the global-info to raw bytes
        //
        if (pGlobalInfo)
            CORg( pGlobalInfo->WriteTo(&pGlobalBytes, &dwGlobalBytesSize) );

        //
        // Now convert the client-info to raw bytes
        //
        if (pClientInfo)
            CORg( pClientInfo->WriteTo(&pClientBytes, &dwClientBytesSize) );

        //
        // Save the information to the persistent store
        //
        CWRg( ::MprConfigTransportSetInfo(hMachine,
										  hTransport,
										  pGlobalBytes,
										  dwGlobalBytesSize,
										  pClientBytes,
										  dwClientBytesSize,
										  NULL
										 ) );
		
        //
        // Finally, update the info of the running router-manager if possible
        //
        CORg( SetInfoBase(pGlobalInfo, pClientInfo) );


		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	CoTaskMemFree( pGlobalBytes );
	CoTaskMemFree( pClientBytes );
	
	return hrOK;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::TryToConnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInfo::TryToConnect(LPCWSTR pswzMachine, HANDLE *phMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	
	if (m_hMachineConfig)
		*phMachine = m_hMachineConfig;
	else if (*phMachine)
	{
		m_hMachineConfig = *phMachine;
		m_bDisconnect = FALSE;
	}
	else
	{
		//$ Review: kennt, this function does not take a LPCWSTR,
		// is this a mistake or does it modify the parameters?
		CWRg( ::MprConfigServerConnect((LPWSTR) pswzMachine, phMachine) );
		m_hMachineConfig = *phMachine;
		m_bDisconnect = TRUE;
	}

Error:
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::GetParentRouterInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInfo::GetParentRouterInfo(IRouterInfo **ppParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	*ppParent = m_pRouterInfoParent;
	if (*ppParent)
		(*ppParent)->AddRef();
	return hrOK;
}

/*!--------------------------------------------------------------------------
	RtrMgrInfo::SetParentRouterInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInfo::SetParentRouterInfo(IRouterInfo *pParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRouterInfo *	pTemp;
	
	pTemp = m_pRouterInfoParent;
	m_pRouterInfoParent = NULL;
	
	if (m_fStrongRef)
	{
		if (pTemp)
			pTemp->Release();
		if (pParent)
			pParent->AddRef();
	}
	else
	{
		if (pTemp)
			pTemp->ReleaseWeakRef();
		if (pParent)
			pParent->AddWeakRef();
	}
	m_pRouterInfoParent = pParent;

	return hrOK;
}


/*!--------------------------------------------------------------------------
	RtrMgrInfo::Disconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
void RtrMgrInfo::Disconnect()
{
	if (m_bDisconnect && m_hMachineConfig)
		::MprConfigServerDisconnect(m_hMachineConfig);
	
	m_bDisconnect = FALSE;
	m_hMachineConfig = NULL;
	m_hTransport = NULL;
}
	


/*!--------------------------------------------------------------------------
	RtrMgrInfo::DoDisconnect
		Removes the connections held by this object.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;
	SPIEnumRtrMgrProtocolInfo	spEnumRmProt;
	SPIRtrMgrProtocolInfo		spRmProt;

	COM_PROTECT_TRY
	{

		// Disconnect our data.
		// ------------------------------------------------------------
		Disconnect();

		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);

		// Now tell all child objects to disconnect.
		// ------------------------------------------------------------
		HRESULT			hrIter = hrOK;

		EnumRtrMgrProtocol(&spEnumRmProt);
		spEnumRmProt->Reset();
		while (spEnumRmProt->Next(1, &spRmProt, NULL) == hrOK)
		{
			spRmProt->DoDisconnect();
			spRmProt.Release();
		}
		
	}
	COM_PROTECT_CATCH;
	return hr;
}


HRESULT RtrMgrInfo::TryToGetAllHandles(LPCOLESTR pszMachine,
                                       HANDLE *phMachine,
                                       HANDLE *phTransport)
{
    HRESULT     hr = hrOK;


    Assert(phMachine);
    Assert(phTransport);
    
    //
    // If already loaded, the handle passed in is ignored.
    //
    // Otherwise, if 'hMachine' was not specified, connect to the config
    // on the specified machine
    //
    CORg( TryToConnect(pszMachine, phMachine) );
        
    //
    // Get a handle to the interface-transport
    //

    //
    // If 'hIfTransport' was not specified, connect
    //
    if (phTransport)
    {
        if (m_hTransport)
            *phTransport = m_hTransport;
        else if (*phTransport)
            m_hTransport = *phTransport;
        else
        {
            //
            // Get a handle to the interface-transport
            //
            CWRg( ::MprConfigTransportGetHandle(
                                                *phMachine,
                                                GetTransportId(),
                                                phTransport
                                               ) );
            m_hTransport = *phTransport;
        }
    }

Error:
    return hr;
}






/*---------------------------------------------------------------------------
	RtrMgrProtocolInfo Implementation
 ---------------------------------------------------------------------------*/

TFSCORE_API(HRESULT)	CreateRtrMgrProtocolInfo(
							IRtrMgrProtocolInfo **ppRmProtInfo,
							const RtrMgrProtocolCB *pRmProtCB)
{
	Assert(ppRmProtInfo);
	Assert(pRmProtCB);

	HRESULT	hr = hrOK;
	IRtrMgrProtocolInfo *	pRmProt = NULL;
	RtrMgrProtocolInfo *	prmp;
	USES_CONVERSION;

	COM_PROTECT_TRY
	{
		prmp = new RtrMgrProtocolInfo(pRmProtCB->dwProtocolId,
									  W2CT(pRmProtCB->szId),
									  pRmProtCB->dwTransportId,
									  W2CT(pRmProtCB->szRtrMgrId),
									  NULL);
		
		prmp->SetCB(pRmProtCB);
		*ppRmProtInfo = prmp;
	}
	COM_PROTECT_CATCH;

	return hr;
}



IMPLEMENT_WEAKREF_ADDREF_RELEASE(RtrMgrProtocolInfo);

IMPLEMENT_SIMPLE_QUERYINTERFACE(RtrMgrProtocolInfo, IRtrMgrProtocolInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrProtocolInfo)

RtrMgrProtocolInfo::RtrMgrProtocolInfo(DWORD dwProtocolId,
									   LPCTSTR         lpszId,
									   DWORD           dwTransportId,
									   LPCTSTR         lpszRm,
									   RtrMgrInfo *		pRmInfo)
	: m_dwFlags(0)
{
	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrProtocolInfo);
	
	m_cb.dwProtocolId = dwProtocolId;
	m_cb.stId = lpszId;
	m_cb.dwTransportId = dwTransportId;
	m_cb.stRtrMgrId = lpszRm;

	m_pRtrMgrInfoParent = pRmInfo;
	if (m_pRtrMgrInfoParent)
		m_pRtrMgrInfoParent->AddRef();

	InitializeCriticalSection(&m_critsec);
}

RtrMgrProtocolInfo::~RtrMgrProtocolInfo()
{
	Assert(m_pRtrMgrInfoParent == NULL);
	Destruct();
	DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrProtocolInfo);
	DeleteCriticalSection(&m_critsec);
}

void RtrMgrProtocolInfo::ReviveStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRtrMgrInfoParent)
	{
		CONVERT_TO_STRONGREF(m_pRtrMgrInfoParent);
	}
}

void RtrMgrProtocolInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRtrMgrInfoParent)
	{
		CONVERT_TO_WEAKREF(m_pRtrMgrInfoParent);
	}
	if (m_fDestruct)
		Destruct();
}

STDMETHODIMP RtrMgrProtocolInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRtrMgrInfo *	pParent;
	
	m_fDestruct = TRUE;
	if (!m_fStrongRef)
	{
		// Release the parent pointer
		pParent = m_pRtrMgrInfoParent;
		m_pRtrMgrInfoParent = NULL;
		if (pParent)
			pParent->ReleaseWeakRef();

		// release any data		
	}
	return hrOK;
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP RtrMgrProtocolInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::GetProtocolId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrProtocolInfo::GetProtocolId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwProtocolId;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::GetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInfo::GetTitle()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes OLECHAR == WCHAR and that
	// we are native UNICODE
	return m_cb.stTitle;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::GetTransportId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrProtocolInfo::GetTransportId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwTransportId;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::CopyCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::CopyCB(RtrMgrProtocolCB *pRmProtCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.SaveTo(pRmProtCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::SetCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT	RtrMgrProtocolInfo::SetCB(const RtrMgrProtocolCB *pcb)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	m_cb.LoadFrom(pcb);
	return hrOK;
}


/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::GetParentRtrMgrInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::GetParentRtrMgrInfo(IRtrMgrInfo **ppParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	*ppParent = m_pRtrMgrInfoParent;
	if (*ppParent)
		(*ppParent)->AddRef();
	return hrOK;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::SetParentRtrMgrInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::SetParentRtrMgrInfo(IRtrMgrInfo *pParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRtrMgrInfo *	pTemp;
	
	pTemp = m_pRtrMgrInfoParent;
	m_pRtrMgrInfoParent = NULL;
	
	if (m_fStrongRef)
	{
		if (pTemp)
			pTemp->Release();
		if (pParent)
			pParent->AddRef();
	}
	else
	{
		if (pTemp)
			pTemp->ReleaseWeakRef();
		if (pParent)
			pParent->AddWeakRef();
	}
	m_pRtrMgrInfoParent = pParent;

	return hrOK;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::RtrAdvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::RtrAdvise(IRtrAdviseSink *pRtrAdviseSink,
										   LONG_PTR *pulConnection,
										   LPARAM lUserParam)
{
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	RtrCriticalSection	rtrCritSec(&m_critsec);
	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::RtrNotify
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::RtrUnadvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::RtrUnadvise(LONG_PTR ulConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(ulConnection);
}


/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::Disconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
void RtrMgrProtocolInfo::Disconnect()
{
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInfo::DoDisconnect
		Implementation of IRtrMgrProtocolInfo::DoDisconnect
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;

	COM_PROTECT_TRY
	{
		// Disconnect our data.
		// ------------------------------------------------------------
		Disconnect();

		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);
	}
	COM_PROTECT_CATCH;
	return hr;
}






/*---------------------------------------------------------------------------
	InterfaceInfo Implementation
 ---------------------------------------------------------------------------*/

TFSCORE_API(HRESULT) CreateInterfaceInfo(IInterfaceInfo **ppInterfaceInfo,
										 LPCWSTR pswzInterfaceId,
										 DWORD dwInterfaceType)
{
	Assert(ppInterfaceInfo);
	
	HRESULT	hr = hrOK;
	InterfaceInfo *	pInterfaceInfo = NULL;
	USES_CONVERSION;
	
	COM_PROTECT_TRY
	{
		pInterfaceInfo = new InterfaceInfo(W2CT(pswzInterfaceId),
										   dwInterfaceType,
										   TRUE,
										   InterfaceCB_BindToIp | InterfaceCB_BindToIpx,
                                           NULL);
		*ppInterfaceInfo = pInterfaceInfo;
	}
	COM_PROTECT_CATCH;

	return hr;
}

IMPLEMENT_WEAKREF_ADDREF_RELEASE(InterfaceInfo)

IMPLEMENT_SIMPLE_QUERYINTERFACE(InterfaceInfo, IInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(InterfaceInfo)

InterfaceInfo::InterfaceInfo(LPCTSTR pszId,
							 DWORD dwIfType,
							 BOOL bEnable,
                             DWORD dwBindFlags,
							 RouterInfo *pRouterInfo)
	: m_hMachineConfig(NULL),
	m_hInterface(NULL),
	m_bDisconnect(FALSE),
	m_dwFlags(0)
{
	DEBUG_INCREMENT_INSTANCE_COUNTER(InterfaceInfo);

	m_cb.stId = pszId;
	m_cb.dwIfType = dwIfType;
	m_cb.bEnable = bEnable;
    m_cb.dwBindFlags = dwBindFlags;

	m_pRouterInfoParent = pRouterInfo;
	if (m_pRouterInfoParent)
		m_pRouterInfoParent->AddRef();

	InitializeCriticalSection(&m_critsec);
}

InterfaceInfo::~InterfaceInfo()
{
	Assert(m_pRouterInfoParent == NULL);
	Destruct();
	DEBUG_DECREMENT_INSTANCE_COUNTER(InterfaceInfo);
	DeleteCriticalSection(&m_critsec);
}

void InterfaceInfo::ReviveStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRouterInfoParent)
	{
		CONVERT_TO_STRONGREF(m_pRouterInfoParent);
	}
}

void InterfaceInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRouterInfoParent)
	{
		CONVERT_TO_WEAKREF(m_pRouterInfoParent);
	}
	if (m_fDestruct)
		Destruct();
}

STDMETHODIMP InterfaceInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRouterInfo *	pParent;

	m_fDestruct = TRUE;
	if (!m_fStrongRef)
	{
		pParent = m_pRouterInfoParent;
		m_pRouterInfoParent = NULL;
		if (pParent)
			pParent->ReleaseWeakRef();

		// release any data
		Unload();
	}
	return hrOK;
}

STDMETHODIMP_(DWORD) InterfaceInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP InterfaceInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::Load
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::Load(LPCOLESTR   pszMachine,
								 HANDLE      hMachine,
								 HANDLE      hInterface)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwSize = 0;
	MPR_INTERFACE_0 *pinterface = NULL;
	SPIEnumInterfaceCB	spEnumInterfaceCB;
	InterfaceCB		ifCB;
	SPSZ			spszTitle;
	CString			stTitle;
	DWORD			dwIfType;
    BOOL            bFound = FALSE;

	COM_PROTECT_TRY
	{
		//
		// Discard any existing information
		//
		Unload();

		m_stMachine = OLE2CT(pszMachine ? pszMachine : TEXT(""));

		//
		// If 'hMachine' was not specified, connect to the config
		// on the specified machine
		//
		Assert(m_hMachineConfig == NULL);
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );

		//
		// If 'hInterface' was not specified, connect to the interface
		//
		CORg( TryToGetIfHandle(hMachine, OLE2CW(GetId()), &hInterface) );

        //
        // Get information for the interface
        //		
		CWRg( ::MprConfigInterfaceGetInfo(
										  hMachine,
										  hInterface,
										  0,
										  (LPBYTE*)&pinterface,
										  &dwSize
										 ) );

        // Windows NT Bug ?
        // If this interface is a removed adapter, do not show it.
        // This check needs to be made only for MprConfigInterfacEnum
        // ------------------------------------------------------------
        if ((pinterface->dwConnectionState == ROUTER_IF_STATE_UNREACHABLE) &&
            (pinterface->fUnReachabilityReasons == MPR_INTERFACE_NO_DEVICE))
        {
            CORg( E_INVALIDARG );
        }
            
        //
        // Save the interface type and enabled/disabled status
        //
        m_cb.dwIfType = (DWORD)pinterface->dwIfType;
        m_cb.bEnable  = pinterface->fEnabled;

        ::MprConfigBufferFree(pinterface);

        if (m_pRouterInfoParent)
		{
            //
            // The caller has supplied a list of LAN adapters ('pifcbList'),
            // or this object is contained in a 'CRouterInfo' which will have
            // already loaded the LAN interface control-blocks;
            // search through the list to find our title,
            //
			m_pRouterInfoParent->EnumInterfaceCB(&spEnumInterfaceCB);

			spEnumInterfaceCB->Reset();
			while (spEnumInterfaceCB->Next(1, &ifCB, NULL) == hrOK)
			{
				if (StriCmp(ifCB.szId, OLE2CT(GetId())) == 0)
				{
					m_cb.stTitle = ifCB.szTitle;
					m_cb.stDeviceName = ifCB.szDevice;
					bFound = TRUE;
					break;
				}
				else
				{
					// Windows NT bug 103770
					// Need to check to see if the pcb->sID is a prefix
					// of the Id string (if so it may be the IPX case
					// so use that ID).
					stTitle = GetId();
					if (stTitle.Find((LPCTSTR) ifCB.szId) == 0)
					{
						// Need to check to see that the extension
						// is what we think it is.
						LPCTSTR	pszExt = ((LPCTSTR) stTitle +
										  lstrlen(ifCB.szId));

						if ((*pszExt == 0) ||
							(lstrcmpi(pszExt, c_szEthernetSNAP) == 0) ||
							(lstrcmpi(pszExt, c_szEthernetII) == 0) ||
							(lstrcmpi(pszExt, c_szEthernet8022) == 0) ||
							(lstrcmpi(pszExt, c_szEthernet8023) == 0))
						{
							m_cb.stTitle = ifCB.szTitle;
							m_cb.stTitle += _T(" (");
							m_cb.stTitle += pszExt + 1; // add 1 to skip over /
							m_cb.stTitle += _T(")");
							bFound = TRUE;
							break;
						}
					}
				}
			}
		}
        
        if (!bFound)
		{
			//
			// Read the title directly from the registry
			//
			hr = InterfaceInfo::FindInterfaceTitle(OLE2CT(GetMachineName()),
									   OLE2CT(GetId()),
									   &spszTitle);
			if (FHrOK(hr))
				m_cb.stTitle = spszTitle;
			else
				m_cb.stTitle = OLE2CT(GetId());
			hr = hrOK;
		}
        
        //
        // Load the list of router-managers on this interface
        //
		CORg( LoadRtrMgrInterfaceList() );

		COM_PROTECT_ERROR_LABEL;

	}
	COM_PROTECT_CATCH;

	if (!FHrSucceeded(hr))
		Unload();
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::Save
		-
		Saves the changes to a CInterfaceInfo to the registry.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::Save(LPCOLESTR     pszMachine,
								 HANDLE      hMachine,
								 HANDLE      hInterface)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwErr;
    MPR_INTERFACE_0 mprInterface;
    WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
	MPR_SERVER_HANDLE hrouter = NULL;
    MPR_IPINIP_INTERFACE_0  mprTunnelInterface;
    BOOL    fIpInIpMapping = FALSE;


	COM_PROTECT_TRY
	{
		//
		// If already connected, the handle passed in is ignored;
		//
		// Otherwise, if 'hMachine' was not specified, connect to the config
		// on the specified machine
		//
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );

		//
		// Convert the interface name to Unicode
		//
		StrCpyWFromOle(wszInterface, GetId());

		ZeroMemory(&mprInterface, sizeof(mprInterface));

		StrCpyW(mprInterface.wszInterfaceName, wszInterface);
		mprInterface.dwIfType = (ROUTER_INTERFACE_TYPE) GetInterfaceType();
		mprInterface.fEnabled = IsInterfaceEnabled();

        //
        // If already connected, use the existing interface-handle.
        //
        // Otherwise, if the interface-handle wasn't passed in,
        // try to get a handle to the interface; if that fails,
        // create the interface.
        //
		hr = TryToGetIfHandle(hMachine, wszInterface, &hInterface);
		if (!FHrSucceeded(hr))
		{
            if (GetInterfaceType() == ROUTER_IF_TYPE_TUNNEL1)
            {
                //
                // If we are creating a tunnel, we need to register
                // the GUID-to-friendly name mapping.
                //
                ::ZeroMemory(&mprTunnelInterface,
                             sizeof(mprTunnelInterface));
                StrnCpyW(mprTunnelInterface.wszFriendlyName,
                         GetTitle(),
                         MAX_INTERFACE_NAME_LEN);
                CORg( CLSIDFromString(wszInterface,
                                      &(mprTunnelInterface.Guid)) );
                
                CWRg( MprSetupIpInIpInterfaceFriendlyNameCreate(
                    (LPOLESTR) GetMachineName(),
                    &mprTunnelInterface
                    ) );

                // The mapping was created.
                // If we get an error, we need to delete the mapping.
                fIpInIpMapping = TRUE;
            }
            
			//
			// We couldn't get a handle to the interface,
			// so now attempt to create it.
			//
			CWRg( ::MprConfigInterfaceCreate(
											 hMachine,
											 0,
											 (LPBYTE)&mprInterface,
											 &hInterface
											) );
			m_hInterface = hInterface;			
		}

        //
        // Save the current settings for the interface.
        //
        CWRg( ::MprConfigInterfaceSetInfo(
                    hMachine,
                    hInterface,
                    0,
                    (LPBYTE)&mprInterface
                    ) );
		
		//
		// Now notify the router-service of the new interface
		//
		
 
		//
		// Attempt to connect to the router-service
		//
		//$ Review: kennt, what happens if the call to ConnectRouter()
		// fails, we don't have an error code
		if (ConnectRouter(OLE2CT(GetMachineName()), (HANDLE*)&hrouter) == NO_ERROR)
		{
			//
			// The router is running; attempt to get a handle to the interface
			//			
			dwErr = ::MprAdminInterfaceGetHandle(hrouter,
								wszInterface,
								&hInterface,
								FALSE
								);
			
			if (dwErr != NO_ERROR)
			{	
				//
				// We couldn't get a handle to the interface,
				// so try creating it.
				//				
				dwErr = ::MprAdminInterfaceCreate(
								hrouter,
								0,
								(BYTE*)&mprInterface,
								&hInterface
								);
			}
			else
			{	
				//
				// Save the current settings for the interface.
				//				
				dwErr = ::MprAdminInterfaceSetInfo(hrouter,
												hInterface,
												0,
												(LPBYTE)&mprInterface
												);
			}
			
			::MprAdminServerDisconnect(hrouter);
			
			if ((dwErr == RPC_S_SERVER_UNAVAILABLE) ||
				(dwErr == RPC_S_UNKNOWN_IF))
				dwErr = NO_ERROR;

			if (dwErr != NO_ERROR)
				hr = HRESULT_FROM_WIN32(dwErr);
		}
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

    if (!FHrSucceeded(hr) && fIpInIpMapping)
    {
        // Assume : that the the mprTunnelInterface.Guid was
        // initialized, since to reach there they would have had
        // to gone through the CLSIDFromString() call.
        MprSetupIpInIpInterfaceFriendlyNameDelete((LPOLESTR) GetMachineName(),
            &(mprTunnelInterface.Guid)
            );
    }
    
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::Delete
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::Delete(LPCOLESTR     pszMachine,
								   HANDLE      hMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwErr;
    HANDLE hInterface;
    WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
    MPR_SERVER_HANDLE hrouter = NULL;
    GUID    guidTunnel;


	COM_PROTECT_TRY
	{
		// If already connected, the handle passed in is ignored;
		//
		// Otherwise, if 'hMachine' was not specified, connect to the config
		// on the specified machine
		// ------------------------------------------------------------
		CORg( TryToConnect(OLE2CW(pszMachine), &hMachine) );

		StrCpyWFromOle(wszInterface, GetId());

		// Try to get a handle to the interface
		// ------------------------------------------------------------
		CWRg( ::MprConfigInterfaceGetHandle(hMachine,
											wszInterface,
											&hInterface
										   ) );
        // Delete the interface
        // ------------------------------------------------------------
        dwErr = ::MprConfigInterfaceDelete(
										   hMachine,										   hInterface
										  );
        m_hInterface = NULL;
		CWRg( dwErr );

        // If this interface is a tunnel, we need to remove the
        // GUID-to-Friendly name mapping
        // ------------------------------------------------------------
        if (GetInterfaceType() == ROUTER_IF_TYPE_TUNNEL1)
        {
            if (FHrOK(CLSIDFromString((LPTSTR) GetId(),
                                          &guidTunnel)))
            {
                // If this call fails, we can't do anything about it
                // ----------------------------------------------------
                MprSetupIpInIpInterfaceFriendlyNameDelete((LPTSTR) pszMachine,
                    &guidTunnel);
            }
        }

		// Remove the interface from the router if it is running
		// ------------------------------------------------------------

		if (ConnectRouter(OLE2CT(GetMachineName()), (HANDLE*)&hrouter) == NO_ERROR)
		{
			// The router is running; get a handle to the interface
			// --------------------------------------------------------
			dwErr = ::MprAdminInterfaceGetHandle(
												hrouter,
												wszInterface,
												&hInterface,
												FALSE
												);
			if (dwErr == NO_ERROR)
			{
				// Delete the interface
				// ----------------------------------------------------
				dwErr = ::MprAdminInterfaceDelete(
					hrouter,
					hInterface
					);
			}
			
			::MprAdminServerDisconnect(hrouter);
			
			if ((dwErr == RPC_S_SERVER_UNAVAILABLE) ||
				(dwErr == RPC_S_UNKNOWN_IF))
				dwErr = NO_ERROR;
			
			hr = HRESULT_FROM_WIN32(dwErr);
		}


		// Windows NT Bug: 138738
		// Need to remove the interface from the router managers
		// when deleting the interface.
		// ------------------------------------------------------------
		
		// Clear out all information for this interface
		// ------------------------------------------------------------
		if (FHrSucceeded(hr))
		{
			SPIEnumRtrMgrInterfaceInfo spEnumRmIf;
			SPIRtrMgrInterfaceInfo	spRmIf;
			
			// Remove the Router Managers from this interface
			// --------------------------------------------------------
			EnumRtrMgrInterface(&spEnumRmIf);

			while (spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK)
			{
				DWORD	dwTransportId = spRmIf->GetTransportId();
				spRmIf.Release();
				
				DeleteRtrMgrInterface(dwTransportId, TRUE);
			}
		}
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::Unload
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::Unload( )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	IRtrMgrInterfaceInfo *	pRmIf;
	COM_PROTECT_TRY
	{
		//
		// Free all the contained router-manager structures in our list
		//
		while (!m_RmIfList.IsEmpty())
		{
			pRmIf = m_RmIfList.RemoveHead();
			pRmIf->Destruct();
			pRmIf->ReleaseWeakRef();
		}

		DoDisconnect();
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::Merge
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::Merge(IInterfaceInfo *pNewIf)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT				hr = hrOK;
	HRESULT				hrT;
	SPIEnumRtrMgrInterfaceInfo	spEnumRmIf;
	SPIRtrMgrInterfaceInfo		spRmIf;
	SPIRtrMgrInfo		spRm;
	SPIRtrMgrProtocolInfo	spRmProt;
	SPIRtrMgrProtocolInterfaceInfo	spRmProtIf;
	SPIEnumRtrMgrProtocolInterfaceInfo	spEnumRmProtIf;
	CDWordArray			oldDWArray;
	CDWordArray			newDWArray;
	int					cOld, cNew;
	int					i, j;
	DWORD				dwTemp;
	InterfaceCB			ifCB;

	Assert(pNewIf);
	Assert(lstrcmpi(pNewIf->GetId(), GetId()) == 0);

	COM_PROTECT_TRY
	{
		// Need to sync up the interface CB Data
		pNewIf->CopyCB(&ifCB);
		m_cb.LoadFrom(&ifCB);

		// Need to sync up the RtrMgrInterface list
		// They are identified by transport ids, so we can
		// use the two array method used by
		// IRtrMgrInterfaceInfo::Merge
		
		// Get the list of RtrMgrs that are in the new object
		CORg( pNewIf->EnumRtrMgrInterface(&spEnumRmIf) );
		spEnumRmIf->Reset();
		while (spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK)
		{
			newDWArray.Add(spRmIf->GetTransportId());
			spRmIf.Release();
		}

		spEnumRmIf.Release();
		spRmIf.Release();


		// Get the list of interfaces that are in this object
		CORg( this->EnumRtrMgrInterface(&spEnumRmIf) );
		spEnumRmIf->Reset();
		while (spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK)
		{
			oldDWArray.Add(spRmIf->GetTransportId());
			spRmIf.Release();
		}

		spEnumRmIf.Release();
		spRmIf.Release();


		// Ok now go through both lists, removing from the lists
		// interfaces that are in both lists.
		cOld = oldDWArray.GetSize();
		cNew = newDWArray.GetSize();
		for (i=cOld; --i>=0; )
		{
			dwTemp = oldDWArray.GetAt(i);
			for (j=cNew; --j>=0; )
			{
				if (dwTemp == newDWArray.GetAt(j))
				{
					SPIRtrMgrInterfaceInfo	spRmIf1;
					SPIRtrMgrInterfaceInfo	spRmIf2;

					this->FindRtrMgrInterface(dwTemp, &spRmIf1);
					pNewIf->FindRtrMgrInterface(dwTemp, &spRmIf2);

					Assert(spRmIf1);
					Assert(spRmIf2);
					spRmIf1->Merge(spRmIf2);
										
					// remove both instances
					newDWArray.RemoveAt(j);
					oldDWArray.RemoveAt(i);

					// Need to update the size of the new array
					cNew--;
					break;
				}
			}
		}

		// oldDWArray now contains the interfaces that should be
		// removed.
		if (oldDWArray.GetSize())
		{
			for (i=oldDWArray.GetSize(); --i>=0; )
			{
				// Windows NT Bug: 132993, if this interface
				// is one that is purely local (mostly because
				// it is a new interface), then we should not
				// delete it.
				SPIRtrMgrInterfaceInfo	spRmIfTemp;
				
				FindRtrMgrInterface(oldDWArray.GetAt(i),
									&spRmIfTemp);
				Assert(spRmIfTemp);
				if (spRmIfTemp->GetFlags() & RouterSnapin_InSyncWithRouter)
					DeleteRtrMgrInterface(oldDWArray.GetAt(i), FALSE);
			}
		}

		// newDWArray contains the interfaces that should be added
		if (newDWArray.GetSize())
		{
			for (i=newDWArray.GetSize(); --i>= 0; )
			{
				hr = pNewIf->FindRtrMgrInterface(
							newDWArray.GetAt(i), &spRmIf);
				Assert(hr == hrOK);

				if (spRmIf)
				{
					AddRtrMgrInterface(spRmIf, NULL);

                    // Remove this rmif from its old interface
                    // ------------------------------------------------
                    pNewIf->ReleaseRtrMgrInterface(spRmIf->GetTransportId());
                    
					// We need to do the notify ourselves (because
					// of the NULL infobase) the notifications won't
					// get sent.
					spRmIf->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);

					if (m_pRouterInfoParent)
					{
						spRm.Release();
						hrT = m_pRouterInfoParent->FindRtrMgr(spRmIf->GetTransportId(), &spRm);
						if (FHrOK(hrT))
						{
							spRm->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);

							// In addition, we will have to let the objects
							// know that the interfaces are also being added
							spEnumRmProtIf.Release();
							spRmProtIf.Release();
							
							spRmIf->EnumRtrMgrProtocolInterface(&spEnumRmProtIf);
							for(; spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK; spRmProtIf.Release())
							{
								spRmProt.Release();
								spRm->FindRtrMgrProtocol(spRmProtIf->GetProtocolId(),
									&spRmProt);
								if (spRmProt)
									spRmProt->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmProtIf, 0);
							}
						}
					}
						
				}
				spRmIf.Release();
			}
		}
		
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::GetId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) InterfaceInfo::GetId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_cb.stId;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::GetInterfaceType
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) InterfaceInfo::GetInterfaceType()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwIfType;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::GetDeviceName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) InterfaceInfo::GetDeviceName()
{
	RtrCriticalSection rtrCritSec(&m_critsec);
	return m_cb.stDeviceName;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::GetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) InterfaceInfo::GetTitle()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_cb.stTitle;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::SetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::SetTitle(LPCOLESTR pszTitle)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.stTitle = pszTitle;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::IsInterfaceEnabled
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(BOOL)	InterfaceInfo::IsInterfaceEnabled()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.bEnable;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::SetInterfaceEnabledState
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::SetInterfaceEnabledState( BOOL bEnabled)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	m_cb.bEnable = bEnabled;
	return hrOK;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::CopyCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::CopyCB(InterfaceCB *pifcb)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.SaveTo(pifcb);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::FindInterfaceTitle
		-
		This function retrieves the title of the given interface.
		The argument 'LpszIf' should contain the ID of the interface,
		for instance "EPRO1".
	Author: WeiJiang
 ---------------------------------------------------------------------------*/

HRESULT InterfaceInfo::FindInterfaceTitle(LPCTSTR pszMachine,
								   LPCTSTR pszInterface,
								   LPTSTR *ppszTitle)
{
	HRESULT	hr = hrOK;
	DWORD		dwErr = ERROR_SUCCESS;
	HKEY		hkeyMachine = NULL;
	BOOL		fNT4;
	
	COM_PROTECT_TRY
	{

		//
		// connect to the registry
		//
		CWRg( ConnectRegistry(pszMachine, &hkeyMachine) );

		CWRg( IsNT4Machine(hkeyMachine, &fNT4) );

		if (hkeyMachine)
			DisconnectRegistry(hkeyMachine);
			

		if(fNT4)
			hr = RegFindInterfaceTitle(pszMachine, pszInterface, ppszTitle);
		else
		{

			//$NT5
			SPMprConfigHandle	sphConfig;
			LPWSTR				pswz;
			CString				stMachineName = pszMachine;
			TCHAR				szDesc[1024];

		
			if (stMachineName.IsEmpty())
				pswz = NULL;
			else
				pswz = (LPTSTR) (LPCTSTR) stMachineName;

			dwErr = ::MprConfigServerConnect(pswz,
										 &sphConfig);

			if (dwErr == ERROR_SUCCESS)
			{
				dwErr = ::MprConfigGetFriendlyName(sphConfig,
											   (LPTSTR)pszInterface,
											   szDesc,
											   sizeof(szDesc));
				if(dwErr == ERROR_SUCCESS)
					*ppszTitle = StrDup((LPCTSTR) szDesc);
			}

			hr = HRESULT_FROM_WIN32(dwErr);

            
            // If we can't find the title by using the Mpr APIS,
            // try to access the registry directly (using the setup APIs)
            // --------------------------------------------------------
            if (dwErr != ERROR_SUCCESS)
            {
                hr = SetupFindInterfaceTitle(pswz, pszInterface,
                                             ppszTitle);
            }


		}

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::GetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) InterfaceInfo::GetMachineName()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_stMachine;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::SetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::SetMachineName(LPCOLESTR pszMachineName)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_stMachine = pszMachineName;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::GetParentRouterInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::GetParentRouterInfo(IRouterInfo **ppRouterInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		*ppRouterInfo = m_pRouterInfoParent;
		if (*ppRouterInfo)
			(*ppRouterInfo)->AddRef();
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::SetParentRouterInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT InterfaceInfo::SetParentRouterInfo(IRouterInfo *pParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRouterInfo *	pTemp;
	
	pTemp = m_pRouterInfoParent;
	m_pRouterInfoParent = NULL;
	
	if (m_fStrongRef)
	{
		if (pTemp)
			pTemp->Release();
		if (pParent)
			pParent->AddRef();
	}
	else
	{
		if (pTemp)
			pTemp->ReleaseWeakRef();
		if (pParent)
			pParent->AddWeakRef();
	}
	m_pRouterInfoParent = pParent;

	return hrOK;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::EnumRtrMgrInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::EnumRtrMgrInterface( IEnumRtrMgrInterfaceInfo **ppEnumRmIf)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromRtrMgrInterfaceList(&m_RmIfList, ppEnumRmIf);
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::AddRtrMgrInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::AddRtrMgrInterface( IRtrMgrInterfaceInfo *pRmIf,
								    IInfoBase *pIfInfo)
{
	Assert(pRmIf);
	
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT				hr = hrOK;
	HRESULT				hrT;
	SPIRtrMgrInfo		spRm;
	
	COM_PROTECT_TRY
	{
		//
		// Fail if there is a duplicate
		//
		if (FHrOK(FindRtrMgrInterface(pRmIf->GetTransportId(), NULL)))
			CORg( E_INVALIDARG );
			
		//
		// Save the new router-manager
		//

		CORg( pRmIf->Save(GetMachineName(),
						  m_hMachineConfig, m_hInterface, NULL, pIfInfo, 0) );

		//
		// Add the new router-manager structure to the list
		//
		m_RmIfList.AddTail(pRmIf);
		pRmIf->AddWeakRef();
		pRmIf->SetParentInterfaceInfo(this);

		// We don't notify of a new interface since we haven't
		// actually saved the interface back down to the router
		if (pIfInfo)
		{
			m_AdviseList.NotifyChange(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);

			if (m_pRouterInfoParent)
			{
				hrT = m_pRouterInfoParent->FindRtrMgr(pRmIf->GetTransportId(), &spRm);
				if (FHrOK(hrT))
					spRm->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);
			}
		}
			
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::DeleteRtrMgrInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::DeleteRtrMgrInterface(DWORD dwTransportId, BOOL fRemove)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK, hrT;
	SPIRtrMgrInterfaceInfo	spRmIf;
	POSITION		pos, posRmIf;
	SPIRtrMgrInfo	spRm;
	SPIEnumRtrMgrProtocolInterfaceInfo	spEnumRmProtIf;
	SPIRtrMgrProtocolInterfaceInfo		spRmProtIf;
	
	COM_PROTECT_TRY
	{
		//
		// Find the router-manager to be deleted
		//
		pos = m_RmIfList.GetHeadPosition();
		while (pos)
		{
			posRmIf = pos;

			spRmIf.Set( m_RmIfList.GetNext(pos) );

			if (spRmIf->GetTransportId() == dwTransportId)
				break;
			spRmIf.Release();
        }

		if (!spRmIf)
			CORg( E_INVALIDARG );

		// Delete all RtrMgrProtocolInterfaces from the router manager
		spRmIf->EnumRtrMgrProtocolInterface(&spEnumRmProtIf);
		while (spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK)
		{
			DWORD	dwProtocolId = spRmProtIf->GetProtocolId();
			spRmProtIf.Release();
			spRmIf->DeleteRtrMgrProtocolInterface(dwProtocolId, fRemove);
		}

		//
		// Remove the router-manager from our list
		//
		m_RmIfList.RemoveAt(posRmIf);
		spRmIf->Destruct();
		spRmIf->ReleaseWeakRef();

		//
		// Remove the router-manager from the registry and the router
		//
        if (fRemove)
            spRmIf->Delete(GetMachineName(), NULL, NULL);

		m_AdviseList.NotifyChange(ROUTER_CHILD_DELETE, ROUTER_OBJ_RmIf, 0);
		
		if (m_pRouterInfoParent)
		{
			hrT = m_pRouterInfoParent->FindRtrMgr(spRmIf->GetTransportId(), &spRm);
			if (FHrOK(hrT))
				spRm->RtrNotify(ROUTER_CHILD_DELETE, ROUTER_OBJ_RmIf, 0);
		}
		
		spRmIf.Release();

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::ReleaseRtrMgrInterface
		This function will release the AddRef() that this object has
        on the child.  This allows us to transfer child objects from
        one router to another.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::ReleaseRtrMgrInterface( DWORD dwTransportId )
{
    HRESULT     hr = hrOK;
    POSITION    pos, posRmIf;
	SPIRtrMgrInterfaceInfo	spRmIf;
    
    COM_PROTECT_TRY
    {
		pos = m_RmIfList.GetHeadPosition();
		while (pos)
		{
            // Save the position (so that we can delete it)
            posRmIf = pos;
            spRmIf.Set( m_RmIfList.GetNext(pos) );

            if (spRmIf &&
                (spRmIf->GetTransportId() == dwTransportId))
            {
                // When releasing, we need to disconnect (since the
                // main handle is controlled by the router info).
                spRmIf->DoDisconnect();
        
                spRmIf->ReleaseWeakRef();
                spRmIf.Release();
                
                // release this node from the list
                m_RmIfList.RemoveAt(posRmIf);
                break;
            }
            spRmIf.Release();
		}        
    }
    COM_PROTECT_CATCH;
    return hr;
}

	


/*!--------------------------------------------------------------------------
	InterfaceInfo::FindRtrMgrInterface
		S_OK is returned if a RtrMgrInfo is found.
		S_FALSE is returned if a RtrMgrInfo was NOT found.
		error codes returned otherwise.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::FindRtrMgrInterface( DWORD dwTransportId,
								    IRtrMgrInterfaceInfo **ppInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIRtrMgrInterfaceInfo	spRmIf;
	
	COM_PROTECT_TRY
	{
		if (ppInfo)
			*ppInfo = NULL;
		
		pos = m_RmIfList.GetHeadPosition();

		while (pos)
		{
			spRmIf.Set( m_RmIfList.GetNext(pos) );

			if (spRmIf->GetTransportId() == dwTransportId)
			{
				hr = hrOK;
				if (ppInfo)
					*ppInfo = spRmIf.Transfer();
				break;
			}
        }
	}
	COM_PROTECT_CATCH;
	return hr;
}

	
/*!--------------------------------------------------------------------------
	InterfaceInfo::RtrAdvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	RtrCriticalSection	rtrCritSec(&m_critsec);
	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::RtrNotify
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::RtrUnadvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::RtrUnadvise( LONG_PTR ulConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(ulConnection);
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::LoadRtrMgrInterfaceList
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT InterfaceInfo::LoadRtrMgrInterfaceList()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
    BOOL bAdd;
    LPBYTE pItemTable = NULL;
	SPIRtrMgrInterfaceInfo	spRmIf;
    DWORD dwErr, i, dwEntries, dwTotal;
	HRESULT		hr = hrOK;
    MPR_IFTRANSPORT_0 *piftransport;
	TCHAR szTransport[MAX_TRANSPORT_NAME_LEN+1];
	USES_CONVERSION;

    //
    // Now enumerate the transports on this interface
    //
    dwErr = ::MprConfigInterfaceTransportEnum(
                m_hMachineConfig,
                m_hInterface,
                0,
                &pItemTable,
                (DWORD)-1,
                &dwEntries,
                &dwTotal,
                NULL
                );

    if (dwErr != NO_ERROR && dwErr != ERROR_NO_MORE_ITEMS)
		CWRg( dwErr );

    //
    // Construct a CRmInterfaceInfo for each transport enumerated
    //
    for (i = 0, piftransport = (MPR_IFTRANSPORT_0*)pItemTable;
         i < dwEntries;
         i++, piftransport++)
	{
		FindRtrMgrInterface(piftransport->dwTransportId, &spRmIf);

        if (spRmIf)
			bAdd = FALSE;
        else
		{
            bAdd = TRUE;

            StrCpyTFromW(szTransport, piftransport->wszIfTransportName);

            //
            // Construct a CRmInterfaceInfo object for this transport
            //
			spRmIf = new RtrMgrInterfaceInfo(piftransport->dwTransportId,
											 szTransport,
											 OLE2CT(GetId()),
											 GetInterfaceType(),
											 this);

			spRmIf->SetFlags(RouterSnapin_InSyncWithRouter);
        }

        //
        // Load the information for this CRmInterfaceInfo,
        // indicating to it that it should load its list of protocols.
        //
        hr = spRmIf->Load(GetMachineName(), m_hMachineConfig, m_hInterface,
                          piftransport->hIfTransport );
        if (!FHrSucceeded(hr))
        {
            spRmIf->Destruct();
            spRmIf.Release();
            continue;
        }

        //
        // Add the router-manager interface to our list
        //
        if (bAdd)
		{
			m_RmIfList.AddTail(spRmIf);
			CONVERT_TO_WEAKREF(spRmIf);
			spRmIf.Transfer();
		}
    }

Error:
	if (pItemTable)
		::MprConfigBufferFree(pItemTable);

	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::TryToConnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT InterfaceInfo::TryToConnect(LPCWSTR pswzMachine, HANDLE *phMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	
	if (m_hMachineConfig)
		*phMachine = m_hMachineConfig;
	else if (*phMachine)
	{
		m_hMachineConfig = *phMachine;
		m_bDisconnect = FALSE;
	}
	else
	{
		//$ Review: kennt, this function does not take a LPCWSTR,
		// is this a mistake or does it modify the parameters?
		CWRg( ::MprConfigServerConnect((LPWSTR) pswzMachine, phMachine) );
		m_hMachineConfig = *phMachine;
		m_bDisconnect = TRUE;
	}

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::TryToGetIfHandle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT InterfaceInfo::TryToGetIfHandle(HANDLE hMachine,
										LPCWSTR pswzInterface,
										HANDLE *phInterface)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	
	if (m_hInterface)
		*phInterface = m_hInterface;
	else if (*phInterface)
		m_hInterface = *phInterface;
	else
	{
		//
		// Get a handle to the interface
		//
		CWRg(::MprConfigInterfaceGetHandle(hMachine,
										   (LPWSTR) pswzInterface,
										   phInterface
										  ) );
		m_hInterface = *phInterface;
	}
Error:
	return hr;
}


/*!--------------------------------------------------------------------------
	InterfaceInfo::Disconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
void InterfaceInfo::Disconnect()
{
	if (m_bDisconnect && m_hMachineConfig)
		::MprConfigServerDisconnect(m_hMachineConfig);
	
	m_bDisconnect = FALSE;
	m_hMachineConfig = NULL;
	m_hInterface = NULL;
}

/*!--------------------------------------------------------------------------
	InterfaceInfo::DoDisconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;
	SPIEnumRtrMgrInterfaceInfo	spEnumRmIf;
	SPIRtrMgrInterfaceInfo		spRmIf;

	COM_PROTECT_TRY
	{
		// Disconnect our data.
		// ------------------------------------------------------------
		Disconnect();

		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);

		// Now tell all child objects to disconnect.
		// ------------------------------------------------------------
		HRESULT			hrIter = hrOK;

		EnumRtrMgrInterface(&spEnumRmIf);
		spEnumRmIf->Reset();
		while (spEnumRmIf->Next(1, &spRmIf, NULL) == hrOK)
		{
			spRmIf->DoDisconnect();
			spRmIf.Release();
		}
		
	}
	COM_PROTECT_CATCH;
	return hr;
}






/*---------------------------------------------------------------------------
	IRtrMgrInterfaceInfo Implementation
 ---------------------------------------------------------------------------*/

TFSCORE_API(HRESULT) CreateRtrMgrInterfaceInfo(IRtrMgrInterfaceInfo **ppRmIf,
											  LPCWSTR pszId,
											  DWORD dwTransportId,
											  LPCWSTR pswzInterfaceId,
											  DWORD dwIfType)
{
	Assert(ppRmIf);

	HRESULT hr = hrOK;
	IRtrMgrInterfaceInfo *	pRmIf = NULL;
	USES_CONVERSION;

	COM_PROTECT_TRY
	{
		pRmIf = new RtrMgrInterfaceInfo(dwTransportId,
									   W2CT(pszId),
									   W2CT(pswzInterfaceId),
									   dwIfType,
									   NULL);
		*ppRmIf = pRmIf;
	}
	COM_PROTECT_CATCH;

	return hr;
}

IMPLEMENT_WEAKREF_ADDREF_RELEASE(RtrMgrInterfaceInfo)

IMPLEMENT_SIMPLE_QUERYINTERFACE(RtrMgrInterfaceInfo, IRtrMgrInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrInterfaceInfo)

RtrMgrInterfaceInfo::RtrMgrInterfaceInfo(DWORD dwTransportId,
										LPCTSTR pszId,
										LPCTSTR pszIfId,
										DWORD dwIfType,
										InterfaceInfo *pInterfaceInfo)
	: m_hMachineConfig(NULL),
	m_hInterface(NULL),
	m_hIfTransport(NULL),
	m_bDisconnect(FALSE),
	m_dwFlags(0)
{
	m_cb.dwTransportId = dwTransportId;
	m_cb.stId = pszId;
	m_cb.stInterfaceId = pszIfId;
	m_cb.dwIfType = dwIfType;
	
	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrInterfaceInfo);

	m_pInterfaceInfoParent = pInterfaceInfo;
	if (m_pInterfaceInfoParent)
		m_pInterfaceInfoParent->AddRef();
	InitializeCriticalSection(&m_critsec);
}

RtrMgrInterfaceInfo::~RtrMgrInterfaceInfo()
{
	Assert(m_pInterfaceInfoParent == NULL);
	Destruct();
	DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrInterfaceInfo);
	DeleteCriticalSection(&m_critsec);
}

void RtrMgrInterfaceInfo::ReviveStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pInterfaceInfoParent)
	{
		CONVERT_TO_STRONGREF(m_pInterfaceInfoParent);
	}
}

void RtrMgrInterfaceInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pInterfaceInfoParent)
	{
		CONVERT_TO_WEAKREF(m_pInterfaceInfoParent);
	}
	if (m_fDestruct)
		Destruct();
}

STDMETHODIMP RtrMgrInterfaceInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IInterfaceInfo *	pParent;
	m_fDestruct = TRUE;
	if (!m_fStrongRef)
	{
		pParent = m_pInterfaceInfoParent;
		m_pInterfaceInfoParent = NULL;
		if (pParent)
			pParent->ReleaseWeakRef();

		Unload();
	}
	return hrOK;
}

STDMETHODIMP_(DWORD) RtrMgrInterfaceInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP RtrMgrInterfaceInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Load
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::Load(LPCOLESTR   pszMachine,
									   HANDLE      hMachine,
									   HANDLE      hInterface,
									   HANDLE      hIfTransport)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwErr;
    DWORD dwSize = 0;
	MPR_INTERFACE_0 *pinterface = NULL;
	SPIInterfaceInfo	spIf;
	SPIRouterInfo		spRouter;
	SPIEnumInterfaceCB	spEnumIfCB;
	InterfaceCB			ifCB;
	SPSZ				spsz;

	COM_PROTECT_TRY
	{
		//
		// Discard any information already loaded
		//
		Unload();

		m_stMachine = (pszMachine ? pszMachine : TEXT(""));

		//
		// If 'hMachine' was not specified, connect to the config
		// on the specified machine
		//
		Assert(m_hMachineConfig == NULL);

        CORg( TryToGetAllHandles(T2CW((LPTSTR)(LPCTSTR) m_stMachine),
                                 &hMachine, &hInterface, &hIfTransport) );

        //
        // Get information about the interface
        //
        CWRg(::MprConfigInterfaceGetInfo(
                    hMachine,
                    hInterface,
                    0,
                    (LPBYTE*)&pinterface,
                    &dwSize
                    ) );

        //
        // Save the interface type
        //
        m_cb.dwIfType = (DWORD)pinterface->dwIfType;

        
        //
        // If this isn't a LAN card, the interface-ID is the title;
        // otherwise, retrieve the title from the Software key
        //
        if (GetInterfaceType() != (DWORD)ROUTER_IF_TYPE_DEDICATED)
		{
            m_cb.stTitle = OLE2CT(GetInterfaceId());
        }
		else
		{
			// Can we get to the router info object?
			if (m_pInterfaceInfoParent)
				m_pInterfaceInfoParent->GetParentRouterInfo(&spRouter);

			if (spRouter)
			{
				//
				// This object is contained in a 'CRouterInfo',
				// which will have already loaded the LAN interface
				// control-blocks search through that list to find our title,
				//

				BOOL bFound = FALSE;
				
				CORg( spRouter->EnumInterfaceCB(&spEnumIfCB) );

				spEnumIfCB->Reset();

				while (spEnumIfCB->Next(1, &ifCB, NULL) == hrOK)
				{
					if (StriCmpW(ifCB.szId, GetInterfaceId()) == 0)
					{
						m_cb.stTitle = OLE2CT(ifCB.szId);
						bFound = TRUE;
						break;
					}
				}

				if (!bFound)
				{
					hr = InterfaceInfo::FindInterfaceTitle(OLE2CT(GetMachineName()),
										   OLE2CT(GetInterfaceId()),
										   &spsz);
					if (FHrOK(hr))
						m_cb.stTitle = spsz;
					else
						m_cb.stTitle = OLE2CT(GetInterfaceId());
					hr = hrOK;
				}
			}
			else
			{
				//
				// Read the title directly from the registry
				//
				hr = InterfaceInfo::FindInterfaceTitle(OLE2CT(GetMachineName()),
										   OLE2CT(GetInterfaceId()),
										   &spsz);
				if (FHrOK(hr))
					m_cb.stTitle = spsz;
				else
					m_cb.stTitle = OLE2CT(GetInterfaceId());
				hr = hrOK;
			}

        }
        //
        // Load the list of routing-protocols active on this interface
        //
		CORg( LoadRtrMgrInterfaceInfo(hMachine, hInterface, hIfTransport) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	if (pinterface)
        ::MprConfigBufferFree(pinterface);

	return hr;
}
	

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Save
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::Save(
									   LPCOLESTR     pszMachine,
									   HANDLE      hMachine,
									   HANDLE      hInterface,
									   HANDLE      hIfTransport,
									   IInfoBase*  pInterfaceInfo,
									   DWORD       dwDeleteProtocolId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwErr;
	
	COM_PROTECT_TRY
	{

        //$ OPT : We reuse the handles (if they exist), so why
        // do we pass in the machine name?  What we should do is
        // to release all the handles first.

        Assert(m_stMachine.CompareNoCase(pszMachine) == 0);

        hr = TryToGetAllHandles(pszMachine,
                                &hMachine,
                                &hInterface,
                                &hIfTransport);
        
        if (!FHrSucceeded(hr) && (hIfTransport == NULL))
		{
            dwErr = ::MprConfigInterfaceTransportGetHandle(hMachine,
                        hInterface, GetTransportId(), &hIfTransport);
            if (dwErr != NO_ERROR)
			{
                //
                // We couldn't connect so try creating the interface-transport;
                // First convert the transport-name to Unicode
                //
                WCHAR wszTransport[MAX_TRANSPORT_NAME_LEN+1];
                StrCpyWFromT(wszTransport, m_cb.stId);

                //
                // Create the interface-transport
                //
                CWRg( ::MprConfigInterfaceTransportAdd(hMachine, hInterface,
                            GetTransportId(), wszTransport,
                            NULL, 0, &hIfTransport) );
            }
            m_hIfTransport = hIfTransport;
        }


        //
        // Update the registry and our infobase with the current information
        //
        CORg( SaveRtrMgrInterfaceInfo(
                    hMachine, hInterface, hIfTransport, pInterfaceInfo,
                    dwDeleteProtocolId
                    ) );

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

	
/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Unload
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::Unload( )
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	IRtrMgrProtocolInterfaceInfo *	pRmProtIf;
	COM_PROTECT_TRY
	{

		while (!m_RmProtIfList.IsEmpty())
		{
			pRmProtIf = m_RmProtIfList.RemoveHead();
			pRmProtIf->Destruct();
			pRmProtIf->ReleaseWeakRef();
		}

		DoDisconnect();

	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Delete
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::Delete(LPCOLESTR     pszMachine,
										 HANDLE      hMachine,
										 HANDLE      hInterface)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	MPR_SERVER_HANDLE hrouter = NULL;
	HRESULT	hr = hrOK;
    DWORD dwErr;
    HANDLE hIfTransport = NULL;
    WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
	USES_CONVERSION;
	
	COM_PROTECT_TRY
	{

        //
        //$ OPT, kennt : why is the machine name passed in here?
        //
        
        CORg( TryToGetAllHandles(pszMachine,
                                 &hMachine,
                                 &hInterface,
                                 NULL) );
		do
		{

			//
			// Get a handle to the interface-transport
			//
			dwErr = ::MprConfigInterfaceTransportGetHandle(
								hMachine,
								hInterface,
								GetTransportId(),
								&hIfTransport
								);
			if (dwErr == NO_ERROR)
			{
				//
				// Remove the interface-transport
				//
				dwErr = ::MprConfigInterfaceTransportRemove(
								hMachine,
								hInterface,
								hIfTransport
								);
			}

			m_hIfTransport = NULL;
			
		} while(FALSE);

		//
		// Now remove the router-manager from the interface
		// with the currently running router
		//
		if (ConnectRouter(OLE2CT(pszMachine), (HANDLE*)&hrouter) == NO_ERROR)
		{
            //
            // Convert ID into Unicode
            //
            StrnCpyWFromOle(wszInterface, GetInterfaceId(),
                            DimensionOf(wszInterface));

			//
			// The router is running; if the interface exists, remove it
			//
			dwErr = ::MprAdminInterfaceGetHandle(
							hrouter,
							wszInterface,
							&hInterface,
							FALSE
							);

			if (dwErr == NO_ERROR)
			{
				//
				// Remove the interface-transport
				//				
				dwErr = ::MprAdminInterfaceTransportRemove(
									hrouter,
									hInterface,
									GetTransportId()
									);
			}

			::MprAdminServerDisconnect(hrouter);

			if ((dwErr == RPC_S_SERVER_UNAVAILABLE) ||
				(dwErr == RPC_S_UNKNOWN_IF))
				dwErr = NO_ERROR;
			
			CWRg( dwErr );
		}

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Merge
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::Merge(IRtrMgrInterfaceInfo *pNewRmIf)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	SPIEnumRtrMgrProtocolInterfaceInfo	spEnumRmProtIf;
	SPIRtrMgrProtocolInterfaceInfo		spRmProtIf;
	HRESULT				hr = hrOK;
	CDWordArray			oldDWArray;
	CDWordArray			newDWArray;
	int					cOld, cNew;
	int					i, j;
	DWORD				dwTemp;
	RtrMgrInterfaceCB	rmIfCB;

	Assert(pNewRmIf);
	Assert(pNewRmIf->GetTransportId() == GetTransportId());
	Assert(lstrcmpi(pNewRmIf->GetId(), GetId()) == 0);

	COM_PROTECT_TRY
	{
		// Need to sync up RtrMgrInterfaceInfo
		pNewRmIf->CopyCB(&rmIfCB);
		m_cb.LoadFrom(&rmIfCB);
		
		//
		// The general algorithm is to build up two arrays
		// the first array contains the protocol ids for this object
		// the second array contains the ids for the new object
		//
		// We then go through and remove all protocols that are in
		// BOTH lists.
		//
		// This will leave us with the first array containing the
		// ids of the protocols that need to be deleted from this object.
		//
		// The second array will have the list of ids of protocols that
		// have to be added to this object from the second object.
		//

		// Get the list of protocols that are in the new object
		CORg( pNewRmIf->EnumRtrMgrProtocolInterface(&spEnumRmProtIf) );
		spEnumRmProtIf->Reset();
		while (spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK)
		{
			newDWArray.Add(spRmProtIf->GetProtocolId());
			spRmProtIf.Release();
		}

		spEnumRmProtIf.Release();
		spRmProtIf.Release();


		// Get the list of protocols that are in this object
		CORg( this->EnumRtrMgrProtocolInterface(&spEnumRmProtIf) );
		spEnumRmProtIf->Reset();
		while (spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK)
		{
			oldDWArray.Add(spRmProtIf->GetProtocolId());
			spRmProtIf.Release();
		}

		spEnumRmProtIf.Release();
		spRmProtIf.Release();


		// Ok now go through both lists, removing from the lists
		// protocols that are in both lists.
		cOld = oldDWArray.GetSize();
		cNew = newDWArray.GetSize();
		for (i=cOld; --i>=0; )
		{
			dwTemp = oldDWArray.GetAt(i);
			for (j=cNew; --j>=0; )
			{
				if (dwTemp == newDWArray.GetAt(j))
				{
					// remove both instances
					newDWArray.RemoveAt(j);
					oldDWArray.RemoveAt(i);

					// Need to update the size of the new array
					cNew--;
					break;
				}
			}
		}

		// oldDWArray now contains the protocols that should be
		// removed.
		if (oldDWArray.GetSize())
		{
			for (i=oldDWArray.GetSize(); --i>=0; )
			{
				// Windows NT Bug: 132993, we need to make sure that
				// we don't delete the local interfaces
				SPIRtrMgrProtocolInterfaceInfo	spRmProtIfTemp;

				FindRtrMgrProtocolInterface(oldDWArray.GetAt(i),
											&spRmProtIfTemp);
				Assert(spRmProtIfTemp);
				if (spRmProtIfTemp->GetFlags() & RouterSnapin_InSyncWithRouter)
					DeleteRtrMgrProtocolInterface(oldDWArray.GetAt(i), FALSE);
			}
		}

		// newDWArray contains the protocols that should be added
		if (newDWArray.GetSize())
		{
			for (i=newDWArray.GetSize(); --i>= 0; )
			{
				hr = pNewRmIf->FindRtrMgrProtocolInterface(
										newDWArray.GetAt(i), &spRmProtIf);
				Assert(hr == hrOK);

				if (spRmProtIf)
                {
					AddRtrMgrProtocolInterface(spRmProtIf, NULL);
                    
                    // Remove this rmprotif from its old RMinterface
                    // ------------------------------------------------
                    pNewRmIf->ReleaseRtrMgrProtocolInterface(
                        spRmProtIf->GetProtocolId());
                }
                    
				spRmProtIf.Release();
			}
		}
		
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetInfo
		-
		This function updates the information in use by the router-manager
		if it is currently running.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetInfo(DWORD dwIfInfoSize,
										  PBYTE pInterfaceInfoData)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
    DWORD dwErr;
    MPR_SERVER_HANDLE hrouter = NULL;
    HANDLE hinterface = NULL;
	
	COM_PROTECT_TRY
	{
		//
		// Connect to the router
		//

		CWRg( ConnectRouter(OLE2CT(GetMachineName()), (HANDLE*)&hrouter) );

		do {
			//
			// Get the handle to the interface
			//
			WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
			StrCpyWFromT(wszInterface, GetInterfaceId());

			dwErr = ::MprAdminInterfaceGetHandle(
												hrouter,
												wszInterface,
												&hinterface,
												FALSE
												);

			if (dwErr != NO_ERROR) { hinterface = NULL; break; }

			//
			// Set the new info for the router-manager
			//
			dwErr = ::MprAdminInterfaceTransportSetInfo(
                    hrouter,
                    hinterface,
                    m_cb.dwTransportId,
                    pInterfaceInfoData,
                    dwIfInfoSize
                    );

			//
			// If that failed, we assume that the router-manager
			// has not been added, and we attempt an add;
			// otherwise, we set the new information
			//

			if (dwErr != NO_ERROR && dwErr != RPC_S_SERVER_UNAVAILABLE)
			{
				//
				// Attempt to add the router-manager on the interface
				//
				DWORD dwErr1 = ::MprAdminInterfaceTransportAdd(
                        hrouter,
                        hinterface,
                        m_cb.dwTransportId,
                        pInterfaceInfoData,
                        dwIfInfoSize
                        );
				if (dwErr1 == NO_ERROR)
					dwErr = dwErr1;
			}

		} while (FALSE);

		if ((dwErr == RPC_S_SERVER_UNAVAILABLE) ||
			(dwErr == RPC_S_UNKNOWN_IF))
			dwErr = NO_ERROR;
		
		CWRg(dwErr);

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

    // If we fail to contact the server, then we will get these
    // errors.  The most common occurrence is that the router is
    // not running.
    if ((hr == HResultFromWin32(RPC_S_SERVER_UNAVAILABLE)) ||
        (hr == HResultFromWin32(RPC_S_UNKNOWN_IF)))
        hr = hrOK;

	if (hrouter)
		::MprAdminServerDisconnect(hrouter);
	return hr;
}

	
/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetInfoBase
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetInfoBase(HANDLE hMachine,
											  HANDLE hInterface,
											  HANDLE hIfTransport,
											  IInfoBase *pInfoBase)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrOK;
    LPBYTE pIfBytes = NULL;
    DWORD dwIfBytesSize = 0;

	COM_PROTECT_TRY
	{
		if (pInfoBase)
		{
            //
            // If already loaded, the handles passed in are ignored.
            //
            // Otherwise, if not specified, a connection will be made.
            //
            CORg( TryToGetAllHandles(T2CW((LPTSTR)(LPCTSTR) m_stMachine),
                                     &hMachine, &hInterface, &hIfTransport) );

			//
			// Convert the CInfoBase to a byte-array
			//
			CWRg( pInfoBase->WriteTo(&pIfBytes, &dwIfBytesSize) );
		
			//
			// Save the information to the persistent store
			//	
			CWRg( ::MprConfigInterfaceTransportSetInfo(
                hMachine,
                hInterface,
                hIfTransport,
				pIfBytes,
				dwIfBytesSize
				) );
		}
		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;

	CoTaskMemFree( pIfBytes );

	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetInfoBase
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::GetInfoBase(HANDLE hMachine,
											  HANDLE hInterface,
											  HANDLE hIfTransport,
											  IInfoBase **ppInfoBase)
{
	Assert(ppInfoBase);
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	LPBYTE		pIfBytes = NULL;
	DWORD		dwIfBytesSize;
	SPIInfoBase	spInfoBase;
	
	COM_PROTECT_TRY
	{
		*ppInfoBase = NULL;

        //
        // If already loaded, the handles passed in are ignored.
        //
        // Otherwise, if not specified, a connection will be made.
        //
        CORg( TryToGetAllHandles(T2CW((LPTSTR)(LPCTSTR) m_stMachine),
                                 &hMachine, &hInterface, &hIfTransport) );

		CORg( CreateInfoBase(&spInfoBase) );

		//
		// Retrieve the info for the interface transport
		//
		CWRg( ::MprConfigInterfaceTransportGetInfo(
            hMachine, hInterface, hIfTransport,
			&pIfBytes,
			&dwIfBytesSize
			));
		//
		// Parse the interface info for the router-manager
		//
		CORg( spInfoBase->LoadFrom(dwIfBytesSize, pIfBytes) );

		*ppInfoBase = spInfoBase.Transfer();

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
    if (pIfBytes) { ::MprConfigBufferFree(pIfBytes); }
	
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfo::GetId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.stId;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetId(LPCOLESTR pszId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.stId = pszId;
	}
	COM_PROTECT_CATCH;
	return hr;
}
		
/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetTransportId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrInterfaceInfo::GetTransportId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwTransportId;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetInterfaceId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfo::GetInterfaceId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_cb.stInterfaceId;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetInterfaceType
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrInterfaceInfo::GetInterfaceType()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwIfType;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfo::GetTitle()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_cb.stTitle;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetTitle(LPCOLESTR pszTitle)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_cb.stTitle = pszTitle;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::CopyCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::CopyCB(RtrMgrInterfaceCB *pRmIfCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.SaveTo(pRmIfCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrInterfaceInfo::GetMachineName()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	//$UNICODE : kennt, assumes native unicode and OLECHAR==WCHAR
	return m_stMachine;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetMachineName
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetMachineName(LPCOLESTR pszMachineName)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_stMachine = pszMachineName;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::EnumRtrMgrProtocolInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::EnumRtrMgrProtocolInterface( IEnumRtrMgrProtocolInterfaceInfo **ppEnumRmProtIf)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		hr = CreateEnumFromRtrMgrProtocolInterfaceList(&m_RmProtIfList,
							ppEnumRmProtIf);
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::FindRtrMgrProtocolInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::FindRtrMgrProtocolInterface( DWORD dwProtocolId,
	IRtrMgrProtocolInterfaceInfo **ppInfo)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrFalse;
	POSITION	pos;
	SPIRtrMgrProtocolInterfaceInfo	spRmProtIf;
	
	COM_PROTECT_TRY
	{
		if (ppInfo)
			*ppInfo = NULL;
		
		// Look through the list of rtr mgrs for the one that matches
		pos = m_RmProtIfList.GetHeadPosition();
		while (pos)
		{
			spRmProtIf.Set(m_RmProtIfList.GetNext(pos));
			Assert(spRmProtIf);
			if (spRmProtIf->GetProtocolId() == dwProtocolId)
			{
				hr = hrOK;
				if (ppInfo)
					*ppInfo = spRmProtIf.Transfer();
				break;
			}
		}
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::AddRtrMgrProtocolInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::AddRtrMgrProtocolInterface( IRtrMgrProtocolInterfaceInfo *pInfo,
	IInfoBase *pInterfaceInfo)
{
	Assert(pInfo);
	
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		//
		// Fail if there is a duplicate
		//
		if (FHrOK(FindRtrMgrProtocolInterface(pInfo->GetProtocolId(), NULL)))
			CORg( E_INVALIDARG );

		//
		// Save the new information if specified
		//
		if (pInterfaceInfo)
		{
			CORg( Save(GetMachineName(),
					   m_hMachineConfig,
					   m_hInterface,
					   m_hIfTransport,
					   pInterfaceInfo,
					   0) );
		}


		//
		// Add the new routing-protocol to our list
		//
		m_RmProtIfList.AddTail(pInfo);
		pInfo->AddWeakRef();
		pInfo->SetParentRtrMgrInterfaceInfo(this);

        NotifyOfRmProtIfAdd(pInfo, m_pInterfaceInfoParent);
			
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::DeleteRtrMgrProtocolInterface
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::DeleteRtrMgrProtocolInterface( DWORD dwProtocolId, BOOL fRemove)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	SPIRtrMgrProtocolInterfaceInfo	spRmProtIf;
	SPIRtrMgrProtocolInfo			spRmProt;
	SPIRouterInfo					spRouterInfo;
	POSITION	pos;
	POSITION	posRmProtIf;
	HRESULT		hrT;
	
	COM_PROTECT_TRY
	{
		//
		// Find the routing-protocol to be deleted
		//
		pos = m_RmProtIfList.GetHeadPosition();
		while (pos)
		{
			posRmProtIf = pos;

			spRmProtIf.Set( m_RmProtIfList.GetNext(pos) );

			if (spRmProtIf->GetProtocolId() == dwProtocolId)
				break;
			spRmProtIf.Release();
		}

		if (spRmProtIf == NULL)
			CORg( E_INVALIDARG );

		//
		// Save the updated information, removing the protocol's block
		//
        if (fRemove)
        {
            hr= Save(GetMachineName(),
                     m_hMachineConfig,
                     m_hInterface,
                     m_hIfTransport,
                     NULL,
                     dwProtocolId) ;
            
            if (!FHrSucceeded(hr) &&
                (hr != HRESULT_FROM_WIN32(ERROR_NO_SUCH_INTERFACE)))
			CORg(hr);
        }
		
		//
		// Remove the protocol from our list
		//
		m_RmProtIfList.RemoveAt(posRmProtIf);
		spRmProtIf->Destruct();
		spRmProtIf->ReleaseWeakRef();

		m_AdviseList.NotifyChange(ROUTER_CHILD_DELETE, ROUTER_OBJ_RmProtIf, 0);

		// Also need to advise the RmProt
		if (m_pInterfaceInfoParent)
		{
			hrT = m_pInterfaceInfoParent->GetParentRouterInfo(&spRouterInfo);

			if (FHrOK(hrT))
				hrT = LookupRtrMgrProtocol(spRouterInfo,
										   spRmProtIf->GetTransportId(),
										   spRmProtIf->GetProtocolId(),
										   &spRmProt);

			if (FHrOK(hrT))
				spRmProt->RtrNotify(ROUTER_CHILD_DELETE, ROUTER_OBJ_RmProtIf, 0);
		}

        Assert(FindRtrMgrProtocolInterface(dwProtocolId, NULL) != hrOK);
		
		COM_PROTECT_ERROR_LABEL;

	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::ReleaseRtrMgrProtocolInterface
		This function will release the AddRef() that this object has
        on the child.  This allows us to transfer child objects from
        one router to another.
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::ReleaseRtrMgrProtocolInterface( DWORD dwProtocolId )
{
    HRESULT     hr = hrOK;
    POSITION    pos, posRmProtIf;
	SPIRtrMgrProtocolInterfaceInfo	spRmProtIf;
    
    COM_PROTECT_TRY
    {
		pos = m_RmProtIfList.GetHeadPosition();
		while (pos)
		{
            // Save the position (so that we can delete it)
            posRmProtIf = pos;
            spRmProtIf.Set( m_RmProtIfList.GetNext(pos) );

            if (spRmProtIf &&
                (spRmProtIf->GetProtocolId() == dwProtocolId))
            {
                
                // When releasing, we need to disconnect (since the
                // main handle is controlled by the router info).
                spRmProtIf->DoDisconnect();
        
                spRmProtIf->ReleaseWeakRef();
                spRmProtIf.Release();
                
                // release this node from the list
                m_RmProtIfList.RemoveAt(posRmProtIf);
                break;
            }
            spRmProtIf.Release();
		}        
    }
    COM_PROTECT_CATCH;
    return hr;
}

	

	
/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::RtrAdvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
											 LONG_PTR *pulConnection,
											 LPARAM lUserParam)
{
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	RtrCriticalSection	rtrCritSec(&m_critsec);
	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::RtrNotify
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::RtrUnadvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::RtrUnadvise( LONG_PTR ulConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(ulConnection);
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::LoadRtrMgrInterfaceInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::LoadRtrMgrInterfaceInfo(HANDLE hMachine,
													HANDLE hInterface,
													HANDLE hIfTransport)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
    DWORD		dwErr;
	SPIInfoBase	spInterfaceInfoBase;
	HRESULT		hr = hrOK;
	SPIEnumInfoBlock	spEnumBlock;
	SPIRouterInfo		spRouterInfo;
	SPIEnumRtrMgrProtocolCB	spEnumRmProtCB;
	SRtrMgrProtocolCBList	SRmProtCBList;
	InfoBlock *			pInfoBlock;
	RtrMgrProtocolCB	rmprotCB;
	SPIRtrMgrProtocolInterfaceInfo	spRmProtIf;


    //
    // If the caller doesn't want the data for the router-manager,
    // and we need to reload, use the infobase on the stack.
    // Otherwise, create an infobase to be loaded and returned to the caller
    //
	CORg( GetInfoBase(hMachine, hInterface, hIfTransport, &spInterfaceInfoBase) );

    //
    // Now we need to build the list of protocols active on this interface,
    // by examining the blocks in the interface's data.
    //
    // Get a list of the blocks in the interface info
    //
	CORg( spInterfaceInfoBase->QueryBlockList(&spEnumBlock) );

    //
    // Get a list of the routing-protocols installed
    //
    // If possible, we use the routing-protocol control-block list
    // loaded by our containing 'CRouterInfo', to save us from
    // having to load our own in order to interpret the protocols' blocks
    // inside the 'GlobalInfo'.
    //

	// Traverse back through the object hierarchy to get our RouterInfo
	// object
	if (m_pInterfaceInfoParent)
	{
		m_pInterfaceInfoParent->GetParentRouterInfo(&spRouterInfo);
	}

	if (spRouterInfo)
	{
		CORg( spRouterInfo->EnumRtrMgrProtocolCB(&spEnumRmProtCB) );
	}
	else
	{
		CORg( RouterInfo::LoadInstalledRtrMgrProtocolList(GetMachineName(),
											  GetTransportId(),
											  &SRmProtCBList,
											  spRouterInfo) );
		CORg( CreateEnumFromSRmProtCBList(&SRmProtCBList, &spEnumRmProtCB) );
    }

    //
    // Go through the blocks and for each one, see if the block type
    // is the same as the protocol ID for some protocol
    //

	spEnumBlock->Reset();
	while (spEnumBlock->Next(1, &pInfoBlock, NULL) == hrOK)
	{
        //
        // When a routing protocol is removed, its block is left in place,
        // but with zero-length data.
        // We skip such blocks since they don't represent installed protocols.
        //
		if (pInfoBlock->dwSize == 0)
			continue;

        //
        // Look through the installed protocols for a protocol
        // whose ID is the same as this block's type
        //
		spEnumRmProtCB->Reset();
		while (spEnumRmProtCB->Next(1, &rmprotCB, NULL) == hrOK)
		{
            //
            // If this isn't what we're looking for, continue
            //
			if ((pInfoBlock->dwType != rmprotCB.dwProtocolId) ||
				(GetTransportId() != rmprotCB.dwTransportId))
				continue;

            //
            // This is the block we're looking for;
            // construct a CRmProtInterfaceInfo using the control block
            //
			RtrMgrProtocolInterfaceInfo *pRmProtIf = new
				RtrMgrProtocolInterfaceInfo(rmprotCB.dwProtocolId,
											rmprotCB.szId,
											GetTransportId(),
											rmprotCB.szRtrMgrId,
											GetInterfaceId(),
											GetInterfaceType(),
											this);
			spRmProtIf = pRmProtIf;
			spRmProtIf->SetFlags(RouterSnapin_InSyncWithRouter);
			pRmProtIf->m_cb.stTitle = rmprotCB.szTitle;

            //
            // Add the new protocol to our list
            //
			m_RmProtIfList.AddTail(pRmProtIf);
			pRmProtIf->AddWeakRef();
			spRmProtIf.Release();

            NotifyOfRmProtIfAdd(pRmProtIf, m_pInterfaceInfoParent);

            break;
        }
    }


Error:

	//
	// Empty the list if we got data for it
	//
	if (!SRmProtCBList.IsEmpty())
	{
		while (!SRmProtCBList.IsEmpty())
			delete SRmProtCBList.RemoveHead();		
	}
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SaveRtrMgrInterfaceInfo
		-
		This function saves a router-manager's interface information,
		removing blocks for protocols which have been deleted,
		given an infobase derived from CInfoBase.
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::SaveRtrMgrInterfaceInfo(HANDLE hMachine,
									HANDLE hInterface,
									HANDLE hIfTransport,
									IInfoBase *pInterfaceInfoBase,
									DWORD dwDeleteProtocolId)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT		hr = hrOK;
	SPIInfoBase	spIfInfoBase;
    LPBYTE pIfBytes = NULL;
    DWORD dwIfBytesSize = 0;

	//
	// If the caller wants a protocol's block to be deleted first,
	// do so before saving the data.
	//	
	if (dwDeleteProtocolId)
	{	
		//
		// If no data was given but we've been asked to delete a protocol,
		// we need to load the existing data, so that the protocol's block
		// can be removed from the infobase.
		//
		if (pInterfaceInfoBase == NULL)
		{
			CORg( CreateInfoBase(&spIfInfoBase) );
			pInterfaceInfoBase = spIfInfoBase;
			
			//
			// Retrieve the existing data
			//
			CWRg( ::MprConfigInterfaceTransportGetInfo(
                            hMachine,
                            hInterface,
                            hIfTransport,
                            &pIfBytes,
                            &dwIfBytesSize
                            ) );
			//
			// Parse the data into a list of blocks
			//
			CWRg( pInterfaceInfoBase->LoadFrom(dwIfBytesSize, pIfBytes) );
		}

		//
		// Delete the protocol specified
		//
		pInterfaceInfoBase->SetData(dwDeleteProtocolId, 0, NULL, 0, 0);
	}

	//
	// Convert the CInfoBase to a byte-array
	//
	if (pInterfaceInfoBase)
		CWRg( pInterfaceInfoBase->WriteTo(&pIfBytes, &dwIfBytesSize) );
		
	//
	// Save the information to the persistent store
	//	
	CWRg( ::MprConfigInterfaceTransportSetInfo(
											   hMachine,
											   hInterface,
											   hIfTransport,
											   pIfBytes,
											   dwIfBytesSize
											  ) );
	//
	// Update the info of the running router-manager
	//
	if (pInterfaceInfoBase)	
		CWRg( SetInfo(dwIfBytesSize, pIfBytes) );


    // We have now saved the information to the registry and to
    // the running router.  We now mark it as such.
    m_dwFlags |= RouterSnapin_InSyncWithRouter;
                
Error:
	CoTaskMemFree( pIfBytes );

	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::TryToConnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::TryToConnect(LPCWSTR pswzMachine, HANDLE *phMachine)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	
	if (m_hMachineConfig)
		*phMachine = m_hMachineConfig;
	else if (*phMachine)
	{
		m_hMachineConfig = *phMachine;
		m_bDisconnect = FALSE;
	}
	else
	{
		//$ Review: kennt, this function does not take a LPCWSTR,
		// is this a mistake or does it modify the parameters?
		CWRg( ::MprConfigServerConnect((LPWSTR) pswzMachine, phMachine) );
		m_hMachineConfig = *phMachine;
		m_bDisconnect = TRUE;
	}

Error:
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::NotifyOfRmProtIfAdd
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::NotifyOfRmProtIfAdd(IRtrMgrProtocolInterfaceInfo *pRmProtIf,
    IInterfaceInfo *pParentIf)
{
    HRESULT     hr = hrOK;
    
    m_AdviseList.NotifyChange(ROUTER_CHILD_ADD, ROUTER_OBJ_RmProtIf, 0);

    // Also notify the RtrMgrProtocol object that interfaces have
    // been added.
    if (pParentIf)
    {
        SPIRouterInfo	spRouterInfo;
        SPIRtrMgrProtocolInfo	spRmProtInfo;
        HRESULT			hrT;	// this hr is ignored
        
        // If these calls fail, it doesn't matter the operation still
        // is considered successful
        hrT = pParentIf->GetParentRouterInfo(&spRouterInfo);
        
        if (FHrSucceeded(hrT))
        {
            hrT = LookupRtrMgrProtocol(spRouterInfo,
                                       pRmProtIf->GetTransportId(),
                                       pRmProtIf->GetProtocolId(),
                                       &spRmProtInfo);
        }
        if (FHrOK(hrT))
            hrT = spRmProtInfo->RtrNotify(ROUTER_CHILD_ADD,
                                          ROUTER_OBJ_RmProtIf, 0);
    }

    return hr;
    
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::TryToGetIfHandle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::TryToGetIfHandle(HANDLE hMachine,
											  LPCWSTR pswzInterface,
											  HANDLE *phInterface)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	
	if (m_hInterface)
		*phInterface = m_hInterface;
	else if (*phInterface)
		m_hInterface = *phInterface;
	else
	{
		//
		// Get a handle to the interface
		//
		CWRg(::MprConfigInterfaceGetHandle(hMachine,
										   (LPWSTR) pswzInterface,
										   phInterface
										  ) );
		m_hInterface = *phInterface;
	}
Error:
	return hr;
}
										



/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::GetParentInterfaceInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::GetParentInterfaceInfo(IInterfaceInfo **ppParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	*ppParent = m_pInterfaceInfoParent;
	if (*ppParent)
		(*ppParent)->AddRef();
	return hrOK;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::SetParentInterfaceInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::SetParentInterfaceInfo(IInterfaceInfo *pParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IInterfaceInfo *	pTemp;
	
	pTemp = m_pInterfaceInfoParent;
	m_pInterfaceInfoParent = NULL;
	
	if (m_fStrongRef)
	{
		if (pTemp)
			pTemp->Release();
		if (pParent)
			pParent->AddRef();
	}
	else
	{
		if (pTemp)
			pTemp->ReleaseWeakRef();
		if (pParent)
			pParent->AddWeakRef();
	}
	m_pInterfaceInfoParent = pParent;

	return hrOK;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::Disconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
void RtrMgrInterfaceInfo::Disconnect()
{
	if (m_bDisconnect && m_hMachineConfig)
		::MprConfigServerDisconnect(m_hMachineConfig);
	
	m_bDisconnect = FALSE;
	m_hMachineConfig = NULL;
	m_hInterface = NULL;
	m_hIfTransport = NULL;
}

/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::DoDisconnect
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrInterfaceInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;
	SPIEnumRtrMgrProtocolInterfaceInfo	spEnumRmProtIf;
	SPIRtrMgrProtocolInterfaceInfo		spRmProtIf;

	COM_PROTECT_TRY
	{
		// Disconnect our data.
		// ------------------------------------------------------------
		Disconnect();

		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);

		// Now tell all child objects to disconnect.
		// ------------------------------------------------------------
		HRESULT			hrIter = hrOK;

		EnumRtrMgrProtocolInterface(&spEnumRmProtIf);
		spEnumRmProtIf->Reset();
		while (spEnumRmProtIf->Next(1, &spRmProtIf, NULL) == hrOK)
		{
			spRmProtIf->DoDisconnect();
			spRmProtIf.Release();
		}
		
	}
	COM_PROTECT_CATCH;
	return hr;
}


/*!--------------------------------------------------------------------------
	RtrMgrInterfaceInfo::TryToGetAllHandles
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
HRESULT RtrMgrInterfaceInfo::TryToGetAllHandles(LPCOLESTR pszMachine,
                                                HANDLE *phMachine,
                                                HANDLE *phInterface,
                                                HANDLE *phTransport)
{
    HRESULT     hr = hrOK;


    Assert(phMachine);
    Assert(phInterface);
    
    //
    // If already loaded, the handle passed in is ignored.
    //
    // Otherwise, if 'hMachine' was not specified, connect to the config
    // on the specified machine
    //
    CORg( TryToConnect(pszMachine, phMachine) );
        
    //
    // If already loaded, the handle passed in is ignored;
    //
    // Otherwise, if 'hInterface' was not specified,
    // get the interface handle
    //
    CORg( TryToGetIfHandle(*phMachine, GetInterfaceId(), phInterface) );
    
    //
    // Get a handle to the interface-transport
    //

    //
    // If 'hIfTransport' was not specified, connect
    //
    if (phTransport)
    {
        if (m_hIfTransport)
            *phTransport = m_hIfTransport;
        else if (*phTransport)
            m_hIfTransport = *phTransport;
        else
        {
            //
            // Get a handle to the interface-transport
            //
            CWRg( ::MprConfigInterfaceTransportGetHandle(
                *phMachine,
                *phInterface,
                GetTransportId(),
                phTransport
                ) );
            m_hIfTransport = *phTransport;
        }
    }

Error:
    return hr;
}



/*---------------------------------------------------------------------------
	IRtrMgrProtocolInterfaceInfo Implementation
 ---------------------------------------------------------------------------*/

TFSCORE_API(HRESULT)	CreateRtrMgrProtocolInterfaceInfo(
							IRtrMgrProtocolInterfaceInfo **ppRmProtIfInfo,
							const RtrMgrProtocolInterfaceCB *pRmProtIfCB)
{
	Assert(ppRmProtIfInfo);
	Assert(pRmProtIfCB);

	HRESULT	hr = hrOK;
	IRtrMgrProtocolInterfaceInfo *	pRmProtIf = NULL;
	USES_CONVERSION;

	COM_PROTECT_TRY
	{
		*ppRmProtIfInfo = new RtrMgrProtocolInterfaceInfo(
								pRmProtIfCB->dwProtocolId,
								W2CT(pRmProtIfCB->szId),
								pRmProtIfCB->dwTransportId,
								W2CT(pRmProtIfCB->szRtrMgrId),
								W2CT(pRmProtIfCB->szInterfaceId),
								pRmProtIfCB->dwIfType,
								NULL);
	}
	COM_PROTECT_CATCH;

	return hr;
}


IMPLEMENT_WEAKREF_ADDREF_RELEASE(RtrMgrProtocolInterfaceInfo)

IMPLEMENT_SIMPLE_QUERYINTERFACE(RtrMgrProtocolInterfaceInfo, IRtrMgrProtocolInterfaceInfo)

DEBUG_DECLARE_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfo)

RtrMgrProtocolInterfaceInfo::RtrMgrProtocolInterfaceInfo(DWORD dwProtocolId,
										LPCTSTR pszId,
										DWORD dwTransportId,
										LPCTSTR pszRmId,
										LPCTSTR pszIfId,
										DWORD dwIfType,
										RtrMgrInterfaceInfo *pRmIf)
	: m_dwFlags(0)
{
	m_cb.dwProtocolId = dwProtocolId;
	m_cb.stId = pszId;
	m_cb.dwTransportId = dwTransportId;
	m_cb.stRtrMgrId = pszRmId;
	m_cb.stInterfaceId = pszIfId;
	m_cb.dwIfType = dwIfType;
	
	DEBUG_INCREMENT_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfo);

	m_pRtrMgrInterfaceInfoParent = pRmIf;
	if (m_pRtrMgrInterfaceInfoParent)
		m_pRtrMgrInterfaceInfoParent->AddRef();

	InitializeCriticalSection(&m_critsec);
}

RtrMgrProtocolInterfaceInfo::~RtrMgrProtocolInterfaceInfo()
{
	Assert(m_pRtrMgrInterfaceInfoParent == NULL);
	Destruct();
	DEBUG_DECREMENT_INSTANCE_COUNTER(RtrMgrProtocolInterfaceInfo);

	DeleteCriticalSection(&m_critsec);
}

void RtrMgrProtocolInterfaceInfo::ReviveStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRtrMgrInterfaceInfoParent)
	{
		CONVERT_TO_STRONGREF(m_pRtrMgrInterfaceInfoParent);
	}
}

void RtrMgrProtocolInterfaceInfo::OnLastStrongRef()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	if (m_pRtrMgrInterfaceInfoParent)
	{
		CONVERT_TO_WEAKREF(m_pRtrMgrInterfaceInfoParent);
	}
	if (m_fDestruct)
		Destruct();
}

STDMETHODIMP RtrMgrProtocolInterfaceInfo::Destruct()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRtrMgrInterfaceInfo *	pParent;
	m_fDestruct = TRUE;
	if (!m_fStrongRef)
	{
		pParent = m_pRtrMgrInterfaceInfoParent;
		m_pRtrMgrInterfaceInfoParent = NULL;
		if (pParent)
			pParent->ReleaseWeakRef();

//		Unload();
	}
	return hrOK;
}

STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfo::GetFlags()
{
 	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_dwFlags;
}

STDMETHODIMP RtrMgrProtocolInterfaceInfo::SetFlags(DWORD dwFlags)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_dwFlags = dwFlags;
	}
	COM_PROTECT_CATCH;
	return hr;	
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetProtocolId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfo::GetProtocolId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwProtocolId;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetTransportId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfo::GetTransportId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwTransportId;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetInterfaceId
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInterfaceInfo::GetInterfaceId()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.stInterfaceId;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetInterfaceType
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(DWORD) RtrMgrProtocolInterfaceInfo::GetInterfaceType()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.dwIfType;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCOLESTR) RtrMgrProtocolInterfaceInfo::GetTitle()
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_cb.stTitle;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::SetTitle
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::SetTitle(LPCOLESTR pszTitle)
{
	//$UNICODE
	// This assumes that we are native UNICODE
	// and that OLECHAR == WCHAR
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;

	COM_PROTECT_TRY
	{
		m_cb.stTitle = pszTitle;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::CopyCB
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::CopyCB(RtrMgrProtocolInterfaceCB * pRmProtCB)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_cb.SaveTo(pRmProtCB);
	}
	COM_PROTECT_CATCH;
	return hr;
}

	
/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::RtrAdvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::RtrAdvise( IRtrAdviseSink *pRtrAdviseSink,
					   LONG_PTR *pulConnection, LPARAM lUserParam)
{
	Assert(pRtrAdviseSink);
	Assert(pulConnection);

	RtrCriticalSection	rtrCritSec(&m_critsec);
	LONG_PTR	ulConnId;
	HRESULT	hr = hrOK;
	
	COM_PROTECT_TRY
	{
		ulConnId = (LONG_PTR) InterlockedIncrement(&s_cConnections);

		CORg( m_AdviseList.AddConnection(pRtrAdviseSink, ulConnId, lUserParam) );
		
		*pulConnection = ulConnId;

		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::RtrNotify
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::RtrNotify(DWORD dwChangeType, DWORD dwObjectType,
								  LPARAM lParam)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		m_AdviseList.NotifyChange(dwChangeType, dwObjectType, lParam);
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::RtrUnadvise
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::RtrUnadvise( LONG_PTR ulConnection)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	return m_AdviseList.RemoveConnection(ulConnection);
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::GetParentRtrMgrInterfaceInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::GetParentRtrMgrInterfaceInfo( IRtrMgrInterfaceInfo **ppParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	HRESULT	hr = hrOK;
	COM_PROTECT_TRY
	{
		*ppParent = m_pRtrMgrInterfaceInfoParent;
		if (*ppParent)
			(*ppParent)->AddRef();
	}
	COM_PROTECT_CATCH;
	return hr;
}

/*!--------------------------------------------------------------------------
	RtrMgrProtocolInterfaceInfo::SetParentRtrMgrInterfaceInfo
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
STDMETHODIMP RtrMgrProtocolInterfaceInfo::SetParentRtrMgrInterfaceInfo(IRtrMgrInterfaceInfo *pParent)
{
	RtrCriticalSection	rtrCritSec(&m_critsec);
	IRtrMgrInterfaceInfo *	pTemp;
	
	pTemp = m_pRtrMgrInterfaceInfoParent;
	m_pRtrMgrInterfaceInfoParent = NULL;
	
	if (m_fStrongRef)
	{
		if (pTemp)
			pTemp->Release();
		if (pParent)
			pParent->AddRef();
	}
	else
	{
		if (pTemp)
			pTemp->ReleaseWeakRef();
		if (pParent)
			pParent->AddWeakRef();
	}
	m_pRtrMgrInterfaceInfoParent = pParent;

	return hrOK;
}

void RtrMgrProtocolInterfaceInfo::Disconnect()
{
}

STDMETHODIMP RtrMgrProtocolInterfaceInfo::DoDisconnect()
{
	HRESULT		hr = hrOK;

	COM_PROTECT_TRY
	{
		// Disconnect our data.
		// ------------------------------------------------------------
		Disconnect();

		// Notify the advise sinks of a disconnect.
		// ------------------------------------------------------------
		RtrNotify(ROUTER_DO_DISCONNECT, 0, 0);
	}
	COM_PROTECT_CATCH;
	return hr;
}





/*!--------------------------------------------------------------------------
	LoadInfoBase
		-
	Author: KennT
 ---------------------------------------------------------------------------*/
TFSCORE_API(HRESULT) LoadInfoBase(HANDLE		hMachine,
								  HANDLE		hTransport,
								  IInfoBase **ppGlobalInfo,
								  IInfoBase **ppClientInfo)
{
	HRESULT		hr = hrOK;
	SPIInfoBase	spGlobalInfo;
	SPIInfoBase	spClientInfo;
	DWORD		dwGlobalBytesSize, dwClientBytesSize;
	BYTE *		pGlobalBytes = NULL;
	BYTE *		pClientBytes = NULL;
	
	COM_PROTECT_TRY
	{
		if (ppGlobalInfo)
			CORg( CreateInfoBase(&spGlobalInfo) );

		if (ppClientInfo)
			CORg( CreateInfoBase(&spClientInfo) );

		
        //
        // Retrieve information for the transport
        //
        CWRg( ::MprConfigTransportGetInfo(
									hMachine,
									hTransport,
									spGlobalInfo ? &pGlobalBytes : NULL,
									spGlobalInfo ? &dwGlobalBytesSize : NULL,
									spClientInfo ? &pClientBytes : NULL,
									spClientInfo ? &dwClientBytesSize : NULL,
									NULL
									));

        //
        // Load the global info for the router-manager
        //
        if (spGlobalInfo)
		{
            CWRg( spGlobalInfo->LoadFrom(dwGlobalBytesSize, pGlobalBytes) );
        }

        //
        // Load the client info for the router-manager
        //
        if (spClientInfo)
		{
            CWRg( spClientInfo->LoadFrom(dwClientBytesSize, pClientBytes) );
        }

		if (ppGlobalInfo)
			*ppGlobalInfo = spGlobalInfo.Transfer();

		if (ppClientInfo)
			*ppClientInfo = spClientInfo.Transfer();

		
		COM_PROTECT_ERROR_LABEL;
	}
	COM_PROTECT_CATCH;
	
    if (pGlobalBytes) { ::MprConfigBufferFree(pGlobalBytes); }
    if (pClientBytes) { ::MprConfigBufferFree(pClientBytes); }

	return hr;
}