//============================================================================
// Copyright (C) Microsoft Corporation, 1996 - 1999
//
// File: info.h
//
// History:
// Abolade Gbadegesin Feb. 10, 1996 Created.
//
// This file contains declarations for InfoBase parsing code.
// Also including are classes for loading and saving the Router's
// configuration tree (CRouterInfo, CRmInfo, etc.)
//
// The classes are as follows
// (in the diagrams, d => derives, c => contains-list-of):
//
//
// CInfoBase
// |
// c---SInfoBlock
//
//
// CInfoBase holds block of data broken up into a list
// of SInfoBlock structures using RTR_INFO_BLOCK_HEADER
// as a template (see rtinfo.h).
//
// CRouterInfo // router info
// |
// c---CRmInfo // router-manager info
// | |
// | c---CRmProtInfo // protocol info
// |
// c---CInterfaceInfo // router interface info
// |
// c---CRmInterfaceInfo // router-manager interface
// |
// c---CRmProtInterfaceInfo // protocol info
//
// CRouterInfo top-level container for Router registry info.
// holds list of router-managers and interfaces.
//
// CRmInfo global information for a router-manager,
// holds list of routing-protocols.
//
// CRmProtInfo global information for a routing-protocol.
//
// CInterfaceInfo global information for a router-interface.
// holds list of CRmInterfaceInfo structures,
// which hold per-interface info for router-managers.
//
// CRmInterfaceInfo per-interface info for a router-manager.
// holds list of CRmProtInterfaceInfo structures,
// which hold per-interface info for protocols.
//
// CRmProtInterfaceInfo per-interface info for a routing-protocol.
//
//============================================================================
#ifndef _INFOI_H_
#define _INFOI_H_
#include "router.h"
#ifndef _INFOPRIV_H
#include "infopriv.h"
#endif
#ifndef _RTRLIST_H
#include "rtrlist.h"
#endif
//
// Forward declarations of router-information classes.
//
class CRmInfo;
class CRmProtInfo;
class CInterfaceInfo;
class CRmInterfaceInfo;
class CRmProtInterfaceInfo;
class RouterRefreshObject;
typedef struct _SRouterCB
{
DWORD dwLANOnlyMode; // 0 or 1
void LoadFrom(const RouterCB *pcb);
void SaveTo(RouterCB *pcb);
} SRouterCB;
typedef struct _SRtrMgrCB
{
DWORD dwTransportId; // e.g. PID_IP (mprapi.h)
CString stId; // e.g. "Tcpip"
CString stTitle; // e.g. "TCP/IP Router Manager"
CString stDLLPath; // e.g. "%systemroot%\system32\iprtrmgr.dll"
//CString stConfigDLL; // e.g. "rtrui.dll"
// Internal data
DWORD dwPrivate; // private data (for use internally)
void LoadFrom(const RtrMgrCB *pcb);
void SaveTo(RtrMgrCB *pcb);
} SRtrMgrCB;
typedef struct _SRtrMgrProtocolCB
{
DWORD dwProtocolId; // e.g. IP_RIP (routprot.h)
CString stId; // e.g. "IPRIP"
DWORD dwFlags;
DWORD dwTransportId; // e.g. PID_IP
CString stRtrMgrId; // e.g. "Tcpip"
CString stTitle; // e.g. "RIP for Internet Protocol"
CString stDLLName; // e.g. "iprip2.dll"
//CString stConfigDLL; // e.g. "rtrui.dll"
GUID guidConfig; // CLSID for config object
GUID guidAdminUI; // CLSID for snapin
CString stVendorName;
// Internal data
DWORD dwPrivate; // private data (for use internally)
void LoadFrom(const RtrMgrProtocolCB *pcb);
void SaveTo(RtrMgrProtocolCB *pcb);
} SRtrMgrProtocolCB;
typedef struct _SInterfaceCB
{
CString stId; // e.g. "EPRO1"
DWORD dwIfType; // e.g. ROUTER_IF_TYPE_CLIENT (mprapi.h)
BOOL bEnable; // e.g. Enabled or Disabled
CString stTitle; // e.g. friendly name(NT5) or the device name(NT4)
CString stDeviceName; // e.g. "[1] Intel EtherPro"
DWORD dwBindFlags; // e.g. Bound to IP or IPX
// Internal data
DWORD dwPrivate; // private data (for use internally)
void LoadFrom(const InterfaceCB *pcb);
void SaveTo(InterfaceCB *pcb);
} SInterfaceCB;
typedef struct _SRtrMgrInterfaceCB
{
DWORD dwTransportId; // e.g. PID_IP (mprapi.h)
CString stId; // e.g. "Tcpip"
CString stInterfaceId; // e.g. "EPRO1"
DWORD dwIfType; // e.g. ROUTER_IF_TYPE_CLIENT (mprapi.h)
CString stTitle; // e.g. "[1] Intel Etherexpress PRO"
// Internal data
DWORD dwPrivate; // private data (for use internally)
void LoadFrom(const RtrMgrInterfaceCB *pcb);
void SaveTo(RtrMgrInterfaceCB *pcb);
} SRtrMgrInterfaceCB;
typedef struct _SRtrMgrProtocolInterfaceCB
{
DWORD dwProtocolId; // e.g. IP_RIP (routprot.h)
CString stId; // e.g. "IPRIP"
DWORD dwTransportId; // e.g. PID_IP
CString stRtrMgrId; // e.g. "Tcpip"
CString stInterfaceId; // e.g. "EPRO1"
DWORD dwIfType; // e.g. ROUTER_IF_TYPE_CLIENT (mprapi.h)
CString stTitle; // e.g. "[1] Intel Etherexpress PRO"
// Internal data
DWORD dwPrivate; // private data (for use internally)
void LoadFrom(const RtrMgrProtocolInterfaceCB *pcb);
void SaveTo(RtrMgrProtocolInterfaceCB *pcb);
} SRtrMgrProtocolInterfaceCB;
/*---------------------------------------------------------------------------
CList classes for the external structures
---------------------------------------------------------------------------*/
typedef CList<RtrMgrCB *, RtrMgrCB *> RtrMgrCBList;
typedef CList<RtrMgrProtocolCB *, RtrMgrProtocolCB *> RtrMgrProtocolCBList;
typedef CList<InterfaceCB *, InterfaceCB *> InterfaceCBList;
typedef CList<RtrMgrInterfaceCB *, RtrMgrInterfaceCB *> RtrMgrInterfaceCBList;
typedef CList<RtrMgrProtocolInterfaceCB *, RtrMgrProtocolInterfaceCB *> RtrMgrProtocolInterfaceCBList;
/*---------------------------------------------------------------------------
CList classes for the various internal structures
---------------------------------------------------------------------------*/
typedef CList<SRtrMgrCB *, SRtrMgrCB *> SRtrMgrCBList;
typedef CList<SRtrMgrProtocolCB *, SRtrMgrProtocolCB *> SRtrMgrProtocolCBList;
typedef CList<SInterfaceCB *, SInterfaceCB *> SInterfaceCBList;
typedef CList<SRtrMgrInterfaceCB *, SRtrMgrInterfaceCB *> SRtrMgrInterfaceCBList;
typedef CList<SRtrMgrProtocolInterfaceCB *, SRtrMgrProtocolInterfaceCB *> SRtrMgrProtocolInterfaceCBList;
/*---------------------------------------------------------------------------
Smart pointers for the various structures
---------------------------------------------------------------------------*/
DeclareSP(SRouterCB, SRouterCB)
DeclareSP(SRtrMgrCB, SRtrMgrCB)
DeclareSP(SRtrMgrProtocolCB, SRtrMgrProtocolCB)
DeclareSP(SInterfaceCB, SInterfaceCB)
DeclareSP(SRtrMgrInterfaceCB, SRtrMgrInterfaceCB)
DeclareSP(SRtrMgrProtocolInterfaceCB, SRtrMgrProtocolInterfaceCB)
struct SRmData
{
IRtrMgrInfo * m_pRmInfo;
SRmData() : m_pRmInfo(NULL){};
// Do this instead of using a destructor to avoid problems with
// destruction of temporaries.
static void Destroy(SRmData *pRmData);
};
typedef CList<SRmData, SRmData> RmDataList;
struct SIfData
{
IInterfaceInfo * pIfInfo;
DWORD dwConnection;
SIfData() : pIfInfo(NULL), dwConnection(0) {};
};
typedef CList<SIfData, SIfData> IfList;
/*---------------------------------------------------------------------------
CreateEnum for the various CBs
---------------------------------------------------------------------------*/
HRESULT CreateEnumFromSRmCBList(SRtrMgrCBList *pRmCBList,
IEnumRtrMgrCB **ppEnum);
HRESULT CreateEnumFromSRmProtCBList(SRtrMgrProtocolCBList *pRmProtCBList,
IEnumRtrMgrProtocolCB **ppEnum);
HRESULT CreateEnumFromSIfCBList(SInterfaceCBList *pIfCBList,
IEnumInterfaceCB **ppEnum);
HRESULT CreateEnumFromSRmIfCBList(SRtrMgrInterfaceCBList *pRmIfCBList,
IEnumRtrMgrInterfaceCB **ppEnum);
HRESULT CreateEnumFromSRmProtIfCBList(SRtrMgrProtocolInterfaceCBList *pRmIfProtCBList,
IEnumRtrMgrProtocolInterfaceCB **ppEnum);
/*---------------------------------------------------------------------------
CreateEnum for the various interface lists
---------------------------------------------------------------------------*/
// These lists are assumed to have arrays of WEAK references!
HRESULT CreateEnumFromRmList(RmDataList *pRmList,
IEnumRtrMgrInfo **ppEnum);
HRESULT CreateEnumFromRtrMgrProtocolList(PRtrMgrProtocolInfoList *pRmProtList,
IEnumRtrMgrProtocolInfo **ppEnum);
HRESULT CreateEnumFromInterfaceList(PInterfaceInfoList *pIfList,
IEnumInterfaceInfo **ppEnum);
HRESULT CreateEnumFromRtrMgrInterfaceList(PRtrMgrInterfaceInfoList *pRmIfList,
IEnumRtrMgrInterfaceInfo **ppEnum);
HRESULT CreateEnumFromRtrMgrProtocolInterfaceList(PRtrMgrProtocolInterfaceInfoList *pRmProtIfList,
IEnumRtrMgrProtocolInterfaceInfo **ppEnum);
/*---------------------------------------------------------------------------
Struct: SAdviseData
Helper class for management of advise connections.
---------------------------------------------------------------------------*/
struct SAdviseData
{
IRtrAdviseSink *m_pAdvise;
LONG_PTR m_ulConnection;
LPARAM m_lUserParam;
// This m_ulFlags parameter is used by the AdviseDataList.
ULONG m_ulFlags;
SAdviseData() : m_pAdvise(NULL), m_ulConnection(0) {};
static void Destroy(SAdviseData *pAdviseData);
};
typedef CList<SAdviseData, SAdviseData> _SAdviseDataList;
// Possible values for the m_ulFlags
#define ADVISEDATA_DELETED (1)
class AdviseDataList : public _SAdviseDataList
{
public:
HRESULT AddConnection(IRtrAdviseSink *pAdvise,
LONG_PTR ulConnection,
LPARAM lUserParam);
HRESULT RemoveConnection(LONG_PTR ulConnection);
HRESULT NotifyChange(DWORD dwChange, DWORD dwObj, LPARAM lParam);
protected:
// Need to have a private list to handle the notifies.
// This list is created while in a NotifyChange(). Any calls
// to RemoveConnection() DURING a notify, will mark entries as
// invalid (and are thus not called during the NotifyChange()).
_SAdviseDataList m_listNotify;
};
/*---------------------------------------------------------------------------
Class: RtrCriticalSection
This class is used to support entering/leaving of critical sections.
Put this class at the top of a function that you want protected.
---------------------------------------------------------------------------*/
class RtrCriticalSection
{
public:
RtrCriticalSection(CRITICAL_SECTION *pCritSec)
: m_pCritSec(pCritSec)
{
IfDebug(m_cEnter=0;)
Assert(m_pCritSec);
Enter();
}
~RtrCriticalSection()
{
Detach();
}
void Enter()
{
if (m_pCritSec)
{
IfDebug(m_cEnter++;)
EnterCriticalSection(m_pCritSec);
AssertSz(m_cEnter==1, "EnterCriticalSection called too much!");
}
}
BOOL TryToEnter()
{
if (m_pCritSec)
return TryEnterCriticalSection(m_pCritSec);
return TRUE;
}
void Leave()
{
if (m_pCritSec)
{
IfDebug(m_cEnter--;)
LeaveCriticalSection(m_pCritSec);
Assert(m_cEnter==0);
}
}
void Detach()
{
Leave();
m_pCritSec = NULL;
}
private:
CRITICAL_SECTION * m_pCritSec;
IfDebug(int m_cEnter;)
};
/*---------------------------------------------------------------------------
Class: RouterInfo
---------------------------------------------------------------------------*/
class RouterInfo :
public CWeakRef,
public IRouterInfo,
public IRouterAdminAccess
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIRouterRefreshAccessMembers(IMPL)
DeclareIRouterInfoMembers(IMPL)
DeclareIRtrAdviseSinkMembers(IMPL)
DeclareIRouterAdminAccessMembers(IMPL)
// Constructor
RouterInfo(HWND hWndSync, LPCWSTR machineName);
// If you are releasing ANY interface pointers do it in
// the Destruct() call instead.
virtual ~RouterInfo();
// Internal calls to help out with adding/removing interfaces
// ----------------------------------------------------------------
HRESULT AddInterfaceInternal(IInterfaceInfo *pInfo, BOOL fForce,
BOOL fAddToRouter);
HRESULT RemoveInterfaceInternal(LPCOLESTR pszIf, BOOL fRemoveFromRouter);
HRESULT RemoteRtrMgrInternal(DWORD dwTransportId, BOOL fRemoveFromRouter);
HRESULT FindInterfaceByName(LPCOLESTR pszIfName, IInterfaceInfo **ppInfo);
HRESULT NotifyRtrMgrInterfaceOfMove(IInterfaceInfo *pInfo);
// Functions to load up static information about the router.
// This will return information about the INSTALLED protocols/rms,
// not necessarily the RUNNING protocols/rms.
// ----------------------------------------------------------------
static HRESULT LoadInstalledRtrMgrList(LPCTSTR pszMachine,
SRtrMgrCBList *pRmCBList);
static HRESULT LoadInstalledInterfaceList(LPCTSTR pszMachine,
SInterfaceCBList *pIfCBList);
static HRESULT LoadInstalledRtrMgrProtocolList(LPCTSTR pszMachine,
DWORD dwTransportId, SRtrMgrProtocolCBList *pRmProtCBList,
LPCWSTR lpwszUserName, LPCWSTR lpwszPassword , LPCWSTR lpwszDomain );
static HRESULT LoadInstalledRtrMgrProtocolList(LPCTSTR pszMachine,
DWORD dwTransportId, SRtrMgrProtocolCBList *pRmProtCBList, RouterInfo * pRouter);
static HRESULT LoadInstalledRtrMgrProtocolList(LPCTSTR pszMachine,
DWORD dwTransportId, SRtrMgrProtocolCBList *pRmProtCBList, IRouterInfo * pRouter);
protected:
// The router control block for this router. There's not too much
// information here.
// ----------------------------------------------------------------
SRouterCB m_SRouterCB;
// List of Router-Managers that are running on the router.
// ----------------------------------------------------------------
RmDataList m_RmList;
// List of interfaces that have been added to the router.
// WEAK-REF ptrs to IInterfaceInfo objects.
// ----------------------------------------------------------------
PInterfaceInfoList m_IfList;
// Name of this machine.
// ----------------------------------------------------------------
CString m_stMachine;
// MPR_CONFIG_HANDLE to the router
// Obtained by MprAdminServerConnect();
// ----------------------------------------------------------------
MPR_CONFIG_HANDLE m_hMachineConfig;
// MPR_SERVER_HANDLE to the router
// Obtained by MprAdminServerConnect();
// ----------------------------------------------------------------
MPR_SERVER_HANDLE m_hMachineAdmin;
// This is set to TRUE if we are to disconnect the machine handles.
// ----------------------------------------------------------------
BOOL m_bDisconnect;
// This is the router type (LAN, WAN, RAS);
// ----------------------------------------------------------------
DWORD m_dwRouterType;
// Version info for the router and machine.
// ----------------------------------------------------------------
RouterVersionInfo m_VersionInfo;
// Pointer to the refresh object connected with this machine.
// ----------------------------------------------------------------
SPIRouterRefresh m_spRefreshObject;
HWND m_hWndSync; // hwnd of the background hidden window
SRtrMgrCBList m_RmCBList; // contains ptrs to RtrMgrCB objects
SRtrMgrProtocolCBList m_RmProtCBList; // ptrs to RtrMgrProtocolCB objects
SInterfaceCBList m_IfCBList; // ptrs to InterfaceCB objects
AdviseDataList m_AdviseList; // list of advises
DWORD m_dwFlags;
HRESULT LoadRtrMgrList();
HRESULT LoadInterfaceList();
HRESULT TryToConnect(LPCWSTR pswzMachine, HANDLE hMachine);
// Functions for merge support
HRESULT MergeRtrMgrCB(IRouterInfo *pNewRouter);
HRESULT MergeInterfaceCB(IRouterInfo *pNewRouter);
HRESULT MergeRtrMgrProtocolCB(IRouterInfo *pNewRouter);
HRESULT MergeRtrMgrs(IRouterInfo *pNewRouter);
HRESULT MergeInterfaces(IRouterInfo *pNewRouter);
SRtrMgrCB * FindRtrMgrCB(DWORD dwTransportId);
SInterfaceCB * FindInterfaceCB(LPCTSTR pszInterfaceId);
SRtrMgrProtocolCB * FindRtrMgrProtocolCB(DWORD dwTransportId, DWORD dwProtocolId);
// Disconnect
void Disconnect();
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
// Information for IRouterAdminAccess
BOOL m_fIsAdminInfoSet;
CString m_stUserName;
CString m_stDomain;
BYTE * m_pbPassword;
int m_cPassword;
};
/*---------------------------------------------------------------------------
Class: RtrMgrInfo
---------------------------------------------------------------------------*/
class RtrMgrInfo :
public IRtrMgrInfo,
public CWeakRef
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIRtrMgrInfoMembers(IMPL)
RtrMgrInfo(DWORD dwTransportId, LPCTSTR pszTransportName,
RouterInfo *pRouterInfo);
virtual ~RtrMgrInfo();
protected:
SRtrMgrCB m_cb; // router-manager control block
PRtrMgrProtocolInfoList m_RmProtList; // list of routing-protocols
// CObList m_protList; // list of routing-protocols
CString m_stMachine; // machine whose config is loaded
HANDLE m_hMachineConfig; // handle to machine's router-config
HANDLE m_hTransport; // handle to transport's config
BOOL m_bDisconnect;
AdviseDataList m_AdviseList; // list of advises
DWORD m_dwFlags;
// This will contain a weak/strong ref on the parent
IRouterInfo * m_pRouterInfoParent;
//--------------------------------------------------------------------
// Functions: LoadRtrMgrInfo
// SaveRtrMgrInfo
//
// The following handle loading and saving the routing-protocol list
// for the router-manager in the correct format in the registry.
//--------------------------------------------------------------------
HRESULT LoadRtrMgrInfo(HANDLE hMachine,
HANDLE hTransport
);
HRESULT SaveRtrMgrInfo(HANDLE hMachine,
HANDLE hTransport,
IInfoBase *pGlobalInfo,
IInfoBase *pClientInfo,
DWORD dwDeleteProtocolId);
HRESULT TryToConnect(LPCWSTR pswzMachine, HANDLE *phMachine);
HRESULT TryToGetAllHandles(LPCOLESTR pszMachine,
HANDLE *phMachine,
HANDLE *phTransport);
// Disconnects this object
void Disconnect();
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
};
/*---------------------------------------------------------------------------
Class: RtrMgrProtocolInfo
---------------------------------------------------------------------------*/
class RtrMgrProtocolInfo :
public IRtrMgrProtocolInfo,
public CWeakRef
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIRtrMgrProtocolInfoMembers(IMPL)
RtrMgrProtocolInfo(DWORD dwProtocolId,
LPCTSTR lpszId,
DWORD dwTransportId,
LPCTSTR lpszRm,
RtrMgrInfo * pRmInfo);
virtual ~RtrMgrProtocolInfo();
HRESULT SetCB(const RtrMgrProtocolCB *pcb);
protected:
// This will contain a weak/strong ref on the parent
IRtrMgrInfo * m_pRtrMgrInfoParent;
SRtrMgrProtocolCB m_cb; // protocol control block
AdviseDataList m_AdviseList; // list of advises
DWORD m_dwFlags;
// Disconnect
void Disconnect();
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
};
/*---------------------------------------------------------------------------
Class: InterfaceInfo
---------------------------------------------------------------------------*/
class InterfaceInfo :
public IInterfaceInfo,
public CWeakRef
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIInterfaceInfoMembers(IMPL)
InterfaceInfo(LPCTSTR lpszId,
DWORD dwIfType,
BOOL bEnable,
DWORD dwBindFlags,
RouterInfo* pRouterInfo);
~InterfaceInfo();
static HRESULT FindInterfaceTitle(LPCTSTR pszMachine,
LPCTSTR pszInterface,
LPTSTR *ppszTitle);
protected:
// CInterfaceInfo m_CInterfaceInfo;
SInterfaceCB m_cb; // interface control block
PRtrMgrInterfaceInfoList m_RmIfList; // list of IRtrMgrInterfaceInfo
// CObList m_rmIfList; // list of CRmInterfaceInfo
CString m_stMachine; // machine whose config is loaded
HANDLE m_hMachineConfig; // handle to machine's config
HANDLE m_hInterface; // handle to interface-config
BOOL m_bDisconnect;
AdviseDataList m_AdviseList; // list of advises
DWORD m_dwFlags;
IRouterInfo * m_pRouterInfoParent;
HRESULT LoadRtrMgrInterfaceList();
HRESULT TryToConnect(LPCWSTR pszMachine, HANDLE *phMachine);
HRESULT TryToGetIfHandle(HANDLE hMachine, LPCWSTR pswzInterface, HANDLE *phInterface);
// Disconnect
void Disconnect();
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
};
/*---------------------------------------------------------------------------
Class: RtrMgrInterfaceInfo
---------------------------------------------------------------------------*/
class RtrMgrInterfaceInfo :
public IRtrMgrInterfaceInfo,
public CWeakRef
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIRtrMgrInterfaceInfoMembers(IMPL)
RtrMgrInterfaceInfo(DWORD dwTransportId,
LPCTSTR lpszId,
LPCTSTR lpszIfId,
DWORD dwIfType,
InterfaceInfo * pIfInfo);
virtual ~RtrMgrInterfaceInfo();
protected:
// CRmInterfaceInfo m_CRmInterfaceInfo;
SRtrMgrInterfaceCB m_cb; // router-manager control block
PRtrMgrProtocolInterfaceInfoList m_RmProtIfList;
// CObList m_protList; // list of CRmProtInterfaceInfo
CString m_stMachine; // name of machine
HANDLE m_hMachineConfig; // handle to machine's config
HANDLE m_hInterface; // handle to interface-config
HANDLE m_hIfTransport; // handle to transport-config
BOOL m_bDisconnect;
DWORD m_dwFlags; // state of this interface
AdviseDataList m_AdviseList; // list of advises
IInterfaceInfo * m_pInterfaceInfoParent;
HRESULT LoadRtrMgrInterfaceInfo(HANDLE hMachine,
HANDLE hInterface,
HANDLE hIfTransport);
HRESULT SaveRtrMgrInterfaceInfo(HANDLE hMachine,
HANDLE hInterface,
HANDLE hIfTransport,
IInfoBase *pInterfaceInfoBase,
DWORD dwDeleteProtocolId);
HRESULT TryToGetAllHandles(LPCWSTR pszMachine,
HANDLE *phMachine,
HANDLE *phInterface,
HANDLE *phTransport);
HRESULT TryToConnect(LPCWSTR pswzMachine, HANDLE *phMachine);
HRESULT TryToGetIfHandle(HANDLE hMachine, LPCWSTR pswzInterface, HANDLE *phInterface);
// Disconnect
void Disconnect();
// Notification helper functions
HRESULT NotifyOfRmProtIfAdd(IRtrMgrProtocolInterfaceInfo *pRmProtIf,
IInterfaceInfo *pParentIf);
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
};
/*---------------------------------------------------------------------------
Class: RtrMgrProtocolInterfaceInfo
---------------------------------------------------------------------------*/
class RtrMgrProtocolInterfaceInfo :
public IRtrMgrProtocolInterfaceInfo,
public CWeakRef
{
public:
DeclareIUnknownMembers(IMPL)
DeclareIRtrMgrProtocolInterfaceInfoMembers(IMPL)
RtrMgrProtocolInterfaceInfo(DWORD dwProtocolId,
LPCTSTR pszId,
DWORD dwTransportId,
LPCTSTR pszRmId,
LPCTSTR pszIfId,
DWORD dwIfType,
RtrMgrInterfaceInfo *pRmIf);
virtual ~RtrMgrProtocolInterfaceInfo();
SRtrMgrProtocolInterfaceCB m_cb; // protocol control block
protected:
AdviseDataList m_AdviseList; // list of advises
DWORD m_dwFlags;
IRtrMgrInterfaceInfo * m_pRtrMgrInterfaceInfoParent;
// Disconnect
void Disconnect();
// Overrides of CWeakRef functions
virtual void OnLastStrongRef();
virtual void ReviveStrongRef();
// Critical section support
CRITICAL_SECTION m_critsec;
};
#endif