able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/mprsnap/ifadmin.cpp

1593 lines
50 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
IFadmin
Interface node information
FILE HISTORY:
*/
#include "stdafx.h"
#include "ifadmin.h"
#include "iface.h" // to get InterfaceNodeHandler class
#include "rtrstrm.h" // for RouterAdminConfigStream
#include "rtrlib.h" // ContainerColumnInfo
#include "coldlg.h" // ColumnDlg
#include "column.h" // ComponentConfigStream
#include "refresh.h" // IRouterRefresh
#include "refrate.h" // CRefRate dialog
#include "machine.h"
#include "dmvcomp.h"
#include "rtrerr.h" // FormatRasError
#include "ports.h" // for PortsDataEntry
extern "C" {
#define _NOUIUTIL_H_
#include "dtl.h"
#include "pbuser.h"
};
#ifdef UNICODE
#define SZROUTERENTRYDLG "RouterEntryDlgW"
#else
#define SZROUTERENTRYDLG "RouterEntryDlgA"
#endif
IfAdminNodeData::IfAdminNodeData()
{
#ifdef DEBUG
StrCpyA(m_szDebug, "IfAdminNodeData");
#endif
}
IfAdminNodeData::~IfAdminNodeData()
{
}
/*!--------------------------------------------------------------------------
IfAdminNodeData::InitAdminNodeData
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeData::InitAdminNodeData(ITFSNode *pNode, RouterAdminConfigStream *pConfigStream)
{
HRESULT hr = hrOK;
IfAdminNodeData * pData = NULL;
pData = new IfAdminNodeData;
SET_IFADMINNODEDATA(pNode, pData);
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeData::FreeAdminNodeData
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeData::FreeAdminNodeData(ITFSNode *pNode)
{
IfAdminNodeData * pData = GET_IFADMINNODEDATA(pNode);
delete pData;
SET_IFADMINNODEDATA(pNode, NULL);
return hrOK;
}
STDMETHODIMP IfAdminNodeHandler::QueryInterface(REFIID riid, LPVOID *ppv)
{
// Is the pointer bad?
if (ppv == NULL)
return E_INVALIDARG;
// Place NULL in *ppv in case of failure
*ppv = NULL;
// This is the non-delegating IUnknown implementation
if (riid == IID_IUnknown)
*ppv = (LPVOID) this;
else if (riid == IID_IRtrAdviseSink)
*ppv = &m_IRtrAdviseSink;
else
return CHandler::QueryInterface(riid, ppv);
// If we're going to return an interface, AddRef it first
if (*ppv)
{
((LPUNKNOWN) *ppv)->AddRef();
return hrOK;
}
else
return E_NOINTERFACE;
}
/*---------------------------------------------------------------------------
NodeHandler implementation
---------------------------------------------------------------------------*/
extern const ContainerColumnInfo s_rgIfAdminColumnInfo[];
const ContainerColumnInfo s_rgIfAdminColumnInfo[] =
{
{ IDS_COL_INTERFACES, CON_SORT_BY_STRING, TRUE, COL_IF_NAME },
{ IDS_COL_TYPE, CON_SORT_BY_STRING, TRUE, COL_STRING },
{ IDS_COL_STATUS, CON_SORT_BY_STRING, TRUE, COL_STATUS },
{ IDS_COL_CONNECTION_STATE, CON_SORT_BY_STRING, TRUE, COL_STRING},
{ IDS_COL_DEVICE_NAME, CON_SORT_BY_STRING, TRUE, COL_IF_DEVICE},
};
IfAdminNodeHandler::IfAdminNodeHandler(ITFSComponentData *pCompData)
: BaseContainerHandler(pCompData, DM_COLUMNS_IFADMIN, s_rgIfAdminColumnInfo),
m_bExpanded(FALSE),
m_hInstRasDlg(NULL),
m_pfnRouterEntryDlg(NULL),
m_pConfigStream(NULL),
m_ulConnId(0),
m_ulRefreshConnId(0)
{
// Setup the verb states for this node
m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::Init
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::Init(IRouterInfo *pRouterInfo, RouterAdminConfigStream *pConfigStream)
{
HRESULT hr = hrOK;
HKEY hkeyMachine;
// If we don't have a router info then we probably failed to load
// or failed to connect. Bail out of this.
if (!pRouterInfo)
CORg( E_FAIL );
m_spRouterInfo.Set(pRouterInfo);
// Also need to register for change notifications
m_spRouterInfo->RtrAdvise(&m_IRtrAdviseSink, &m_ulConnId, 0);
if (m_hInstRasDlg == NULL)
m_hInstRasDlg = AfxLoadLibrary(_T("rasdlg.dll"));
if (m_hInstRasDlg)
{
m_pfnRouterEntryDlg= (PROUTERENTRYDLG)::GetProcAddress(m_hInstRasDlg,
SZROUTERENTRYDLG);
if (m_pfnRouterEntryDlg == NULL)
{
Trace0("MPRSNAP - Could not find function: RouterEntryDlg\n");
}
}
else
Trace0("MPRSNAP - failed to load rasdlg.dll\n");
m_pConfigStream = pConfigStream;
Error:
return hrOK;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::DestroyHandler
Implementation of ITFSNodeHandler::DestroyHandler
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::DestroyHandler(ITFSNode *pNode)
{
IfAdminNodeData::FreeAdminNodeData(pNode);
m_spDataObject.Release();
if (m_hInstRasDlg)
{
FreeLibrary(m_hInstRasDlg);
m_hInstRasDlg = NULL;
}
if (m_ulRefreshConnId)
{
SPIRouterRefresh spRefresh;
if (m_spRouterInfo)
m_spRouterInfo->GetRefreshObject(&spRefresh);
if (spRefresh)
spRefresh->UnadviseRefresh(m_ulRefreshConnId);
}
m_ulRefreshConnId = 0;
if (m_spRouterInfo)
{
m_spRouterInfo->RtrUnadvise(m_ulConnId);
m_spRouterInfo.Release();
}
return hrOK;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::HasPropertyPages
Implementation of ITFSNodeHandler::HasPropertyPages
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP
IfAdminNodeHandler::HasPropertyPages
(
ITFSNode * pNode,
LPDATAOBJECT pDataObject,
DATA_OBJECT_TYPES type,
DWORD dwType
)
{
return hrOK;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnAddMenuItems
Implementation of ITFSNodeHandler::OnAddMenuItems
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::OnAddMenuItems(
ITFSNode *pNode,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
LPDATAOBJECT lpDataObject,
DATA_OBJECT_TYPES type,
DWORD dwType,
long *pInsertionAllowed)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
CString stMenuItem;
DWORD dwWiz;
ULONG ulFlags;
SPIRouterRefresh spRefresh;
RouterVersionInfo routerVer;
BOOL fNt4;
COM_PROTECT_TRY
{
m_spRouterInfo->GetRouterVersionInfo(&routerVer);
fNt4 = (routerVer.dwRouterVersion == 4);
if ((type == CCT_SCOPE) || (dwType == TFS_COMPDATA_CHILD_CONTEXTMENU))
{
long lMenuText;
//
// If any more menus are added to this section, then the
// code for the InterfaceNodeHandler needs to be updated also.
//
// Add these menus at the top of the context menu
if (!fNt4)
{
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
{
lMenuText = IDS_MENU_NEW_DEMAND_DIAL_INTERFACE;
stMenuItem.LoadString( lMenuText );
hr = LoadAndAddMenuItem( pContextMenuCallback,
stMenuItem,
lMenuText,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
EnableAddInterface() ? 0 : MF_GRAYED);
#if 0
lMenuText = IDS_MENU_ADD_TUNNEL;
stMenuItem.LoadString( lMenuText );
hr = LoadAndAddMenuItem( pContextMenuCallback,
stMenuItem,
lMenuText,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
EnableAddInterface() ? 0 : MF_GRAYED);
#endif
}
}
// For NT4, we add the option to disable the wizard
// interface.
// --------------------------------------------------------
if (fNt4)
{
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
{
lMenuText = IDS_MENU_ADD_INTERFACE;
stMenuItem.LoadString(lMenuText);
hr = LoadAndAddMenuItem( pContextMenuCallback,
stMenuItem,
lMenuText,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
EnableAddInterface() ? 0 : MF_GRAYED);
}
hr = GetDemandDialWizardRegKey(OLE2CT(m_spRouterInfo->GetMachineName()),
&dwWiz);
if (!FHrSucceeded(hr))
dwWiz = TRUE;
ulFlags = dwWiz ? MF_CHECKED : MF_UNCHECKED;
if (!FHrSucceeded(hr))
ulFlags |= MF_GRAYED;
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
{
lMenuText = IDS_MENU_USE_DEMANDDIALWIZARD;
stMenuItem.LoadString(lMenuText);
hr = LoadAndAddMenuItem( pContextMenuCallback,
stMenuItem,
lMenuText,
CCM_INSERTIONPOINTID_PRIMARY_TOP,
ulFlags );
ASSERT( SUCCEEDED(hr) );
}
}
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnCommand
Implementation of ITFSNodeHandler::OnCommand
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::OnCommand(ITFSNode *pNode, long nCommandId,
DATA_OBJECT_TYPES type,
LPDATAOBJECT pDataObject,
DWORD dwType)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
COM_PROTECT_TRY
{
switch (nCommandId)
{
case IDS_MENU_NEW_DEMAND_DIAL_INTERFACE:
case IDS_MENU_ADD_INTERFACE:
OnAddInterface();
break;
#if 0
case IDS_MENU_ADD_TUNNEL:
OnNewTunnel();
break;
#endif
case IDS_MENU_USE_DEMANDDIALWIZARD:
OnUseDemandDialWizard();
break;
case IDS_MENU_REFRESH:
SynchronizeNodeData(pNode);
break;
default:
break;
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::GetString
Implementation of ITFSNodeHandler::GetString
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) IfAdminNodeHandler::GetString(ITFSNode *pNode, int nCol)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (m_stTitle.IsEmpty())
m_stTitle.LoadString(IDS_ROUTING_INTERFACES);
}
COM_PROTECT_CATCH;
return m_stTitle;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnCreateDataObject
Implementation of ITFSNodeHandler::OnCreateDataObject
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::OnCreateDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, IDataObject **ppDataObject)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (!m_spDataObject)
{
CORg( CreateDataObjectFromRouterInfo(m_spRouterInfo,
m_spRouterInfo->GetMachineName(),
type, cookie, m_spTFSCompData,
&m_spDataObject, NULL, FALSE) );
Assert(m_spDataObject);
}
*ppDataObject = m_spDataObject;
(*ppDataObject)->AddRef();
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnExpand
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::OnExpand(ITFSNode *pNode,
LPDATAOBJECT pDataObject,
DWORD dwType,
LPARAM arg,
LPARAM lParam)
{
HRESULT hr = hrOK;
SPIEnumInterfaceInfo spEnumIf;
SPIInterfaceInfo spIf;
// If we don't have a router object, then we don't have any info, don't
// try to expand.
if (!m_spRouterInfo)
return hrOK;
// Windows NT Bug: 288427
// This flag may also get set inside of the OnChange() call.
// The OnChange() will enumerate and all interfaces.
// They may have been added as the result of an OnChange()
// because they were added before the OnExpand() was called.
//
// WARNING! Be careful about adding anything to this function,
// since the m_bExpanded can be set in another function.
// ----------------------------------------------------------------
if (m_bExpanded)
{
return hrOK;
}
COM_PROTECT_TRY
{
CORg( m_spRouterInfo->EnumInterface(&spEnumIf) );
while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
{
AddInterfaceNode(pNode, spIf);
spIf.Release();
}
m_bExpanded = TRUE;
// Now that we have all of the nodes, update the data for
// all of the nodes
SynchronizeNodeData(pNode);
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnResultShow
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::OnResultShow(ITFSComponent *pTFSComponent,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM lParam)
{
BOOL bSelect = (BOOL) arg;
HRESULT hr = hrOK;
SPIRouterRefresh spRefresh;
SPITFSNode spNode;
BaseContainerHandler::OnResultShow(pTFSComponent, cookie, arg, lParam);
if (bSelect)
{
// Call synchronize on this node
m_spNodeMgr->FindNode(cookie, &spNode);
if (spNode)
SynchronizeNodeData(spNode);
}
// Un/Register for refresh advises
if (m_spRouterInfo)
m_spRouterInfo->GetRefreshObject(&spRefresh);
if (spRefresh)
{
if (bSelect)
{
if (m_ulRefreshConnId == 0)
spRefresh->AdviseRefresh(&m_IRtrAdviseSink, &m_ulRefreshConnId, 0);
}
else
{
if (m_ulRefreshConnId)
spRefresh->UnadviseRefresh(m_ulRefreshConnId);
m_ulRefreshConnId = 0;
}
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::ConstructNode
Initializes the Domain node (sets it up).
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::ConstructNode(ITFSNode *pNode)
{
HRESULT hr = hrOK;
IfAdminNodeData * pNodeData;
if (pNode == NULL)
return hrOK;
COM_PROTECT_TRY
{
// Need to initialize the data for the Domain node
pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_INTERFACES);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_INTERFACES);
pNode->SetData(TFS_DATA_SCOPEID, 0);
// This is a leaf node in the scope pane
pNode->SetData(TFS_DATA_SCOPE_LEAF_NODE, TRUE);
m_cookie = reinterpret_cast<LONG_PTR>(pNode);
pNode->SetData(TFS_DATA_COOKIE, m_cookie);
pNode->SetNodeType(&GUID_RouterIfAdminNodeType);
IfAdminNodeData::InitAdminNodeData(pNode, m_pConfigStream);
pNodeData = GET_IFADMINNODEDATA(pNode);
Assert(pNodeData);
// Copy over this data so that the Interface node can access
// this and use this to configure its interface.
pNodeData->m_hInstRasDlg = m_hInstRasDlg;
pNodeData->m_pfnRouterEntryDlg = m_pfnRouterEntryDlg;
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnAddInterface
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::OnAddInterface()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
CString stPhoneBook;
CString stRouter;
DWORD dwErr = NO_ERROR;
SPIConsole spConsole;
SPIInterfaceInfo spIfInfo;
BOOL bStatus;
MachineNodeData *pData;
SPITFSNode spNode, spParent;
DWORD dwRouterType;
CString stServiceDesc;
RouterVersionInfo routerVersion;
if (!EnableAddInterface())
{
AddHighLevelErrorStringId(IDS_ERR_TEMPNOADD);
CORg( E_FAIL );
}
m_spNodeMgr->FindNode(m_cookie, &spNode);
spNode->GetParent(&spParent);
pData = GET_MACHINENODEDATA(spParent);
// Get the router type, if WAN routing is not-enabled
// then we don't need to create demand-dial interfaces.
// ----------------------------------------------------------------
Assert(m_spRouterInfo);
dwRouterType = m_spRouterInfo->GetRouterType();
Trace1("Routertype is %d\n", dwRouterType);
if ((dwRouterType & ROUTER_TYPE_WAN) == 0)
{
AddHighLevelErrorStringId(IDS_ERR_NEEDS_WAN);
CORg( E_FAIL );
}
// Get the version info. Needed later on.
// ----------------------------------------------------------------
m_spRouterInfo->GetRouterVersionInfo(&routerVersion);
// Check to see if the router service is running, before
// continuing on.
// ----------------------------------------------------------------
hr = IsRouterServiceRunning(m_spRouterInfo->GetMachineName(), NULL);
if (hr == hrFalse)
{
// Ask the user if they want to start the service
// ------------------------------------------------------------
if (AfxMessageBox(IDS_PROMPT_SERVICESTART, MB_YESNO) != IDYES)
CWRg( ERROR_CANCELLED );
// Else start the service
// ------------------------------------------------------------
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
dwErr = TFSStartService(m_spRouterInfo->GetMachineName(), c_szRemoteAccess, stServiceDesc);
if (dwErr != NO_ERROR)
{
AddHighLevelErrorStringId(IDS_ERR_IFASERVICESTOPPED);
CWRg( dwErr );
}
//$todo: what to do about forcing a refresh through?
// ForceGlobalRefresh();
}
// Now we need to check to see if there are any routing-enabled ports
// (Here we can assume that rasman is running). We can make this
// check only for >= NT5, since this is when we got Rao's API.
// ----------------------------------------------------------------
if ((routerVersion.dwRouterVersion >= 5) &&
!FLookForRoutingEnabledPorts(m_spRouterInfo->GetMachineName()))
{
AfxMessageBox(IDS_ERR_NO_ROUTING_ENABLED_PORTS);
CWRg( ERROR_CANCELLED );
}
m_spTFSCompData->GetConsole(&spConsole);
// First create the phone book entry.
RASENTRYDLG info;
HWND hwnd;
ZeroMemory( &info, sizeof(info) );
info.dwSize = sizeof(info);
hwnd = NULL;
spConsole->GetMainWindow(&hwnd);
info.hwndOwner = hwnd;
//info.hwndOwner = IFGetApp()->m_hWndHost;
info.dwFlags |= RASEDFLAG_NewEntry;
TRACE0("RouterEntryDlg\n");
ASSERT(m_pfnRouterEntryDlg);
stRouter = m_spRouterInfo->GetMachineName();
GetPhoneBookPath(stRouter, &stPhoneBook);
if (stRouter.GetLength() == 0)
{
stRouter = CString(_T("\\\\")) + GetLocalMachineName();
}
bStatus = m_pfnRouterEntryDlg(
(LPTSTR)(LPCTSTR)stRouter, (LPTSTR)(LPCTSTR)stPhoneBook, NULL, &info);
Trace2("RouterEntryDlg=%f,e=%d\n", bStatus, info.dwError);
if (!bStatus)
{
if (info.dwError != NO_ERROR)
{
AddHighLevelErrorStringId(IDS_ERR_UNABLETOCONFIGPBK);
CWRg( info.dwError );
}
CWRg( ERROR_CANCELLED );
}
CORg( CreateInterfaceInfo(&spIfInfo,
info.szEntry,
ROUTER_IF_TYPE_FULL_ROUTER) );
CORg( spIfInfo->SetTitle(spIfInfo->GetId()) );
CORg( spIfInfo->SetMachineName(m_spRouterInfo->GetMachineName()) );
CORg( m_spRouterInfo->AddInterface(spIfInfo) );
// Ok, we've added the interfaces, we now need to add in
// the appropriate defaults for the router managers
if (info.reserved2 & RASNP_Ip)
{
CORg( AddRouterManagerToInterface(spIfInfo,
m_spRouterInfo,
PID_IP) );
}
if (info.reserved2 & RASNP_Ipx)
{
CORg( AddRouterManagerToInterface(spIfInfo,
m_spRouterInfo,
PID_IPX) );
}
Error:
if (!FHrSucceeded(hr) && (hr != HRESULT_FROM_WIN32(ERROR_CANCELLED)))
{
TCHAR szErr[2048] = _T(" ");
if (hr != E_FAIL) // E_FAIL doesn't give user any information
{
FormatRasError(hr, szErr, DimensionOf(szErr));
}
AddLowLevelErrorString(szErr);
// If there is no high level error string, add a
// generic error string. This will be used if no other
// high level error string is set.
SetDefaultHighLevelErrorStringId(IDS_ERR_GENERIC_ERROR);
DisplayTFSErrorMessage(NULL);
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnNewTunnel
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::OnNewTunnel()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
SPIConsole spConsole;
SPIInterfaceInfo spIfInfo;
int idsErr = 0;
RouterVersionInfo routerVersion;
TunnelDialog tunnel;
GUID guidNew;
TCHAR szGuid[128];
if (!EnableAddInterface())
{
idsErr = IDS_ERR_TEMPNOADD;
CORg( E_FAIL );
}
// Get the version info. Needed later on.
// ----------------------------------------------------------------
m_spRouterInfo->GetRouterVersionInfo(&routerVersion);
m_spTFSCompData->GetConsole(&spConsole);
// For now, popup a dialog asking for the tunnel information
// ----------------------------------------------------------------
if (tunnel.DoModal() == IDOK)
{
// We need to create a GUID for this tunnel.
// ------------------------------------------------------------
CORg( CoCreateGuid(&guidNew) );
// Convert the GUID into a string
// ------------------------------------------------------------
Verify( StringFromGUID2(guidNew, szGuid, DimensionOf(szGuid)) );
CORg( CreateInterfaceInfo(&spIfInfo,
szGuid,
ROUTER_IF_TYPE_TUNNEL1) );
CORg( spIfInfo->SetTitle(tunnel.m_stName) );
CORg( spIfInfo->SetMachineName(m_spRouterInfo->GetMachineName()) );
CORg( m_spRouterInfo->AddInterface(spIfInfo) );
// Need to add the IP Specific data
ForceGlobalRefresh(m_spRouterInfo);
}
Error:
if (!FHrSucceeded(hr) && (hr != HRESULT_FROM_WIN32(ERROR_CANCELLED)))
{
TCHAR szErr[2048];
if (idsErr)
AddHighLevelErrorStringId(idsErr);
FormatRasError(hr, szErr, DimensionOf(szErr));
AddLowLevelErrorString(szErr);
DisplayTFSErrorMessage(NULL);
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::AddRouterManagerToInterface
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::AddRouterManagerToInterface(IInterfaceInfo *pIf,
IRouterInfo *pRouter,
DWORD dwTransportId)
{
HRESULT hr = hrOK;
SPIRtrMgrInfo spRm;
SPIRtrMgrInterfaceInfo spRmIf;
SPIInfoBase spInfoBase;
// Get the router manager
hr = pRouter->FindRtrMgr(dwTransportId, &spRm);
// If this cannot find the RtrMgr, then just exit out.
if (!FHrOK(hr))
goto Error;
// Construct a new CRmInterfaceInfo object
CORg( CreateRtrMgrInterfaceInfo(&spRmIf,
spRm->GetId(),
spRm->GetTransportId(),
pIf->GetId(),
pIf->GetInterfaceType()) );
CORg( spRmIf->SetTitle(pIf->GetTitle()) );
CORg( spRmIf->SetMachineName(pRouter->GetMachineName()) );
// Add this interface to the router-manager
CORg( pIf->AddRtrMgrInterface(spRmIf, NULL) );
// get/create the infobase for this interface
CORg( spRmIf->Load(pIf->GetMachineName(), NULL, NULL, NULL) );
CORg( spRmIf->GetInfoBase(NULL, NULL, NULL, &spInfoBase) );
if (!spInfoBase)
CORg( CreateInfoBase(&spInfoBase) );
if (dwTransportId == PID_IP)
CORg( AddIpPerInterfaceBlocks(pIf, spInfoBase) );
else
{
Assert(dwTransportId == PID_IPX);
CORg( AddIpxPerInterfaceBlocks(pIf, spInfoBase) );
}
// Save the infobase
CORg( spRmIf->Save(pIf->GetMachineName(),
NULL, NULL, NULL, spInfoBase, 0) );
// Mark this interface (it can now be synced with the router)
spRmIf->SetFlags( spRmIf->GetFlags() | RouterSnapin_InSyncWithRouter );
// Notify RM of a new interface
spRm->RtrNotify(ROUTER_CHILD_ADD, ROUTER_OBJ_RmIf, 0);
Error:
if (!FHrSucceeded(hr))
{
// Cleanup
pIf->DeleteRtrMgrInterface(dwTransportId, TRUE);
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::OnUseDemandDialWizard
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::OnUseDemandDialWizard()
{
HRESULT hr = hrOK;
DWORD dwWiz;
hr = GetDemandDialWizardRegKey(OLE2CT(m_spRouterInfo->GetMachineName()),
&dwWiz);
if (FHrSucceeded(hr))
{
// Ok, now toggle the switch
SetDemandDialWizardRegKey(OLE2CT(m_spRouterInfo->GetMachineName()),
!dwWiz);
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::SynchronizeNodeData
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::SynchronizeNodeData(ITFSNode *pThisNode)
{
Assert(pThisNode);
SPITFSNodeEnum spEnum;
SPITFSNode spNode;
DWORD dwStatus;
DWORD dwConnState;
DWORD dwUnReachabilityReason;
int i;
HRESULT hr = hrOK;
InterfaceNodeData *pData;
SPMprAdminBuffer spIf0Table;
SPMprServerHandle sphMprServer;
MPR_INTERFACE_0 * if0Table = NULL;
DWORD if0Count = 0;
DWORD dwTotal;
DWORD dwErr;
// Get the status data from the running router
dwErr = ConnectRouter(m_spRouterInfo->GetMachineName(), &sphMprServer);
if (dwErr == NO_ERROR)
{
::MprAdminInterfaceEnum(sphMprServer,
0,
(BYTE **) &spIf0Table,
(DWORD) -1,
&if0Count,
&dwTotal,
NULL);
if0Table = (MPR_INTERFACE_0 *) (BYTE *) spIf0Table;
}
pThisNode->GetEnum(&spEnum);
spEnum->Reset();
while (spEnum->Next(1, &spNode, NULL) == hrOK)
{
pData = GET_INTERFACENODEDATA(spNode);
Assert(pData);
// default status/connection states
dwConnState = ROUTER_IF_STATE_UNREACHABLE;
dwUnReachabilityReason = MPR_INTERFACE_NOT_LOADED;
pData->dwLastError = 0;
// Match the status we find to the actual status
for (i=0; i<(int) if0Count; i++)
{
// There could be a client interface with the same name
// as a router interface, so filter the client interfaces
if ((if0Table[i].dwIfType != ROUTER_IF_TYPE_CLIENT) &&
!StriCmpW(pData->spIf->GetId(), if0Table[i].wszInterfaceName))
{
break;
}
}
// If we found an entry in the table, pull the data out
if (i < (int) if0Count)
{
dwConnState = if0Table[i].dwConnectionState;
dwUnReachabilityReason = if0Table[i].fUnReachabilityReasons;
if (dwUnReachabilityReason & MPR_INTERFACE_CONNECTION_FAILURE)
pData->dwLastError = if0Table[i].dwLastError;
}
dwStatus = pData->spIf->IsInterfaceEnabled();
// Place the data into the per-node data area
pData->m_rgData[IFADMIN_SUBITEM_TITLE].m_stData = pData->spIf->GetTitle();
pData->m_rgData[IFADMIN_SUBITEM_DEVICE_NAME].m_stData =
pData->spIf->GetDeviceName();
pData->m_rgData[IFADMIN_SUBITEM_TYPE].m_stData =
InterfaceTypeToCString(pData->spIf->GetInterfaceType());
pData->m_rgData[IFADMIN_SUBITEM_STATUS].m_stData = StatusToCString(dwStatus);
pData->m_rgData[IFADMIN_SUBITEM_CONNECTION_STATE].m_stData =
ConnectionStateToCString(dwConnState);
pData->dwUnReachabilityReason = dwUnReachabilityReason;
pData->dwConnectionState = dwConnState;
pData->fIsRunning = ::MprAdminIsServiceRunning((LPWSTR) pData->spIf->GetMachineName());
// Force MMC to redraw the nodes
spNode->ChangeNode(RESULT_PANE_CHANGE_ITEM_DATA);
// Cleanup
spNode.Release();
}
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::EnableAddInterface
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL IfAdminNodeHandler::EnableAddInterface()
{
return m_hInstRasDlg != 0;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::GetPhoneBookPath
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::GetPhoneBookPath(LPCTSTR pszMachine, CString *pstPath)
{
CString str = _T(""), stPath;
CString stRouter = pszMachine;
if (pszMachine && StrLen(pszMachine))
{
// add on the two slashes to the beginning of the machine name
if (stRouter.Left(2) != _T("\\\\"))
{
stRouter = _T("\\\\");
stRouter += pszMachine;
}
// If this is not the local machine, use this string
if (stRouter.GetLength() &&
StriCmp(stRouter, CString(_T("\\\\")) + GetLocalMachineName()))
str = stRouter;
}
Verify( FHrSucceeded(::GetRouterPhonebookPath(str, &stPath)) );
*pstPath = stPath;
return hrOK;
}
ImplementEmbeddedUnknown(IfAdminNodeHandler, IRtrAdviseSink)
STDMETHODIMP IfAdminNodeHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
InitPThis(IfAdminNodeHandler, IRtrAdviseSink);
SPIEnumInterfaceInfo spEnumIf;
SPIInterfaceInfo spIf;
SPITFSNode spThisNode;
SPITFSNode spNode;
SPITFSNodeEnum spEnumNode;
InterfaceNodeData * pNodeData;
BOOL fFound, fAdded;
HRESULT hr = hrOK;
pThis->m_spNodeMgr->FindNode(pThis->m_cookie, &spThisNode);
if (dwObjectType == ROUTER_OBJ_If)
{
// Force a data refresh of the current result pane
if (dwChangeType == ROUTER_CHILD_DELETE)
{
// Go through the list of nodes, if we cannot find this
// node in the list of interfaces, delete the node
spThisNode->GetEnum(&spEnumNode);
spEnumNode->Reset();
while (spEnumNode->Next(1, &spNode, NULL) == hrOK)
{
// Get the node data, look for the interface
pNodeData = GET_INTERFACENODEDATA(spNode);
pThis->m_spRouterInfo->FindInterface(pNodeData->spIf->GetId(),
&spIf);
if (spIf == NULL)
{
// cannot find the interface, release this node!
spThisNode->RemoveChild(spNode);
spNode->Destroy();
}
spNode.Release();
spIf.Release();
}
}
else if (dwChangeType == ROUTER_CHILD_ADD)
{
// Enumerate through the list of interfaces
// if we cannot find this interface in our current
// set of nodes, then add it.
spThisNode->GetEnum(&spEnumNode);
CORg( pThis->m_spRouterInfo->EnumInterface(&spEnumIf) );
fAdded = FALSE;
spEnumIf->Reset();
while (spEnumIf->Next(1, &spIf, NULL) == hrOK)
{
// Look for this interface in our list of nodes
fFound = FALSE;
spEnumNode->Reset();
while (spEnumNode->Next(1, &spNode, NULL) == hrOK)
{
pNodeData = GET_INTERFACENODEDATA(spNode);
Assert(pNodeData);
if (StriCmpW(pNodeData->spIf->GetId(),spIf->GetId()) == 0)
{
fFound = TRUE;
break;
}
spNode.Release();
}
//
// If the interface was not found in the list of nodes,
// then we should add the interface to the UI.
//
if (!fFound)
{
pThis->AddInterfaceNode(spThisNode, spIf);
fAdded = TRUE;
}
spNode.Release();
spIf.Release();
}
// Now that we have all of the nodes, update the data for
// all of the nodes
if (fAdded)
pThis->SynchronizeNodeData(spThisNode);
// Windows NT Bug : 288247
// Set this here, so that we can avoid the nodes being
// added in the OnExpand().
pThis->m_bExpanded = TRUE;
}
// Determine what nodes were deleted, changed, or added
// and do the appropriate action
}
else if (dwChangeType == ROUTER_REFRESH)
{
// Ok, just call the synchronize on this node
pThis->SynchronizeNodeData(spThisNode);
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::CompareItems
Implementation of ITFSResultHandler::CompareItems
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(int) IfAdminNodeHandler::CompareItems(
ITFSComponent * pComponent,
MMC_COOKIE cookieA,
MMC_COOKIE cookieB,
int nCol)
{
// Get the strings from the nodes and use that as a basis for
// comparison.
SPITFSNode spNode;
SPITFSResultHandler spResult;
m_spNodeMgr->FindNode(cookieA, &spNode);
spNode->GetResultHandler(&spResult);
return spResult->CompareItems(pComponent, cookieA, cookieB, nCol);
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::AddMenuItems
Implementation of ITFSResultHandler::AddMenuItems
Use this to add commands to the context menu of the blank areas
of the result pane.
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::AddMenuItems(ITFSComponent *pComponent,
MMC_COOKIE cookie,
LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pCallback,
long *pInsertionAllowed)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SPITFSNode spNode;
CString stMenu;
LONG lMenuText;
HRESULT hr = hrOK;
m_spNodeMgr->FindNode(cookie, &spNode);
hr = OnAddMenuItems(spNode,
pCallback,
pDataObject,
CCT_RESULT,
TFS_COMPDATA_CHILD_CONTEXTMENU,
pInsertionAllowed);
CORg( hr );
Error:
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::Command
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP IfAdminNodeHandler::Command(ITFSComponent *pComponent,
MMC_COOKIE cookie,
int nCommandID,
LPDATAOBJECT pDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SPITFSNode spNode;
HRESULT hr = hrOK;
m_spNodeMgr->FindNode(cookie, &spNode);
hr = OnCommand(spNode,
nCommandID,
CCT_RESULT,
pDataObject,
TFS_COMPDATA_CHILD_CONTEXTMENU);
return hr;
}
typedef DWORD (APIENTRY* PRASRPCCONNECTSERVER)(LPTSTR, HANDLE *);
typedef DWORD (APIENTRY* PRASRPCDISCONNECTSERVER)(HANDLE);
typedef DWORD (APIENTRY* PRASRPCREMOTEGETUSERPREFERENCES)(HANDLE, PBUSER *, DWORD);
typedef DWORD (APIENTRY* PRASRPCREMOTESETUSERPREFERENCES)(HANDLE, PBUSER *, DWORD);
/*!--------------------------------------------------------------------------
GetDemandDialWizardRegKey
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT GetDemandDialWizardRegKey(LPCTSTR szMachine, DWORD *pfWizard)
{
ASSERT(pfWizard);
BOOL fUnload = FALSE;
DWORD dwErr;
PBUSER pbUser;
PRASRPCCONNECTSERVER pRasRpcConnectServer;
PRASRPCDISCONNECTSERVER pRasRpcDisconnectServer;
PRASRPCREMOTEGETUSERPREFERENCES pRasRpcRemoteGetUserPreferences;
PRASRPCREMOTESETUSERPREFERENCES pRasRpcRemoteSetUserPreferences;
HINSTANCE hrpcdll = NULL;
HANDLE hConnection = NULL;
if (!(hrpcdll = LoadLibrary(TEXT("rasman.dll"))) ||
!(pRasRpcConnectServer =
(PRASRPCCONNECTSERVER)GetProcAddress(
hrpcdll, "RasRpcConnectServer"
)) ||
!(pRasRpcDisconnectServer =
(PRASRPCDISCONNECTSERVER)GetProcAddress(
hrpcdll, "RasRpcDisconnectServer"
)) ||
!(pRasRpcRemoteGetUserPreferences =
(PRASRPCREMOTEGETUSERPREFERENCES)GetProcAddress(
hrpcdll, "RasRpcRemoteGetUserPreferences"
)) ||
!(pRasRpcRemoteSetUserPreferences =
(PRASRPCREMOTESETUSERPREFERENCES)GetProcAddress(
hrpcdll, "RasRpcRemoteSetUserPreferences"
)))
{
if (hrpcdll) { FreeLibrary(hrpcdll); }
return HRESULT_FROM_WIN32(GetLastError());
}
dwErr = pRasRpcConnectServer((LPTSTR) szMachine, &hConnection);
if (dwErr)
goto Error;
fUnload = TRUE;
dwErr = pRasRpcRemoteGetUserPreferences(hConnection, &pbUser, UPM_Router);
if (dwErr)
goto Error;
*pfWizard = pbUser.fNewEntryWizard;
// Ignore error codes for these calls, we can't do
// anything about them if they fail.
pRasRpcRemoteSetUserPreferences(hConnection, &pbUser, UPM_Router);
DestroyUserPreferences((PBUSER *) &pbUser);
Error:
if (fUnload)
pRasRpcDisconnectServer(hConnection);
if (hrpcdll)
FreeLibrary(hrpcdll);
return HRESULT_FROM_WIN32(dwErr);
}
/*!--------------------------------------------------------------------------
SetDemandDialWizardRegistyKey
This is a function that was added for Beta1 of Steelhead. We want
to allow the user to use the wizard even though it was turned off.
So we have added this hack for the beta where we set the registry
key for the user/
Author: KennT
---------------------------------------------------------------------------*/
HRESULT SetDemandDialWizardRegKey(LPCTSTR szMachine, DWORD fEnableWizard)
{
DWORD dwErr;
PBUSER pbUser;
BOOL fUnload = FALSE;
PRASRPCCONNECTSERVER pRasRpcConnectServer;
PRASRPCDISCONNECTSERVER pRasRpcDisconnectServer;
PRASRPCREMOTEGETUSERPREFERENCES pRasRpcRemoteGetUserPreferences;
PRASRPCREMOTESETUSERPREFERENCES pRasRpcRemoteSetUserPreferences;
HINSTANCE hrpcdll = NULL;
HANDLE hConnection = NULL;
if (!(hrpcdll = LoadLibrary(TEXT("rasman.dll"))) ||
!(pRasRpcConnectServer =
(PRASRPCCONNECTSERVER)GetProcAddress(
hrpcdll, "RasRpcConnectServer"
)) ||
!(pRasRpcDisconnectServer =
(PRASRPCDISCONNECTSERVER)GetProcAddress(
hrpcdll, "RasRpcDisconnectServer"
)) ||
!(pRasRpcRemoteGetUserPreferences =
(PRASRPCREMOTEGETUSERPREFERENCES)GetProcAddress(
hrpcdll, "RasRpcRemoteGetUserPreferences"
)) ||
!(pRasRpcRemoteSetUserPreferences =
(PRASRPCREMOTESETUSERPREFERENCES)GetProcAddress(
hrpcdll, "RasRpcRemoteSetUserPreferences"
)))
{
if (hrpcdll) { FreeLibrary(hrpcdll); }
return HRESULT_FROM_WIN32(GetLastError());
}
dwErr = pRasRpcConnectServer((LPTSTR) szMachine, &hConnection);
if (dwErr)
goto Error;
fUnload = TRUE;
dwErr = pRasRpcRemoteGetUserPreferences(hConnection, &pbUser, UPM_Router);
if (dwErr)
goto Error;
pbUser.fNewEntryWizard = fEnableWizard;
pbUser.fDirty = TRUE;
// Ignore error codes for these calls, we can't do
// anything about them if they fail.
pRasRpcRemoteSetUserPreferences(hConnection, &pbUser, UPM_Router);
DestroyUserPreferences((PBUSER *) &pbUser);
Error:
if (fUnload)
pRasRpcDisconnectServer(hConnection);
if (hrpcdll)
FreeLibrary(hrpcdll);
return HRESULT_FROM_WIN32(dwErr);
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::AddInterfaceNode
Adds an interface to the UI. This will create a new result item
node for each interface.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT IfAdminNodeHandler::AddInterfaceNode(ITFSNode *pParent, IInterfaceInfo *pIf)
{
InterfaceNodeHandler * pHandler;
SPITFSResultHandler spHandler;
SPITFSNode spNode;
HRESULT hr = hrOK;
pHandler = new InterfaceNodeHandler(m_spTFSCompData);
spHandler = pHandler;
CORg( pHandler->Init(pIf, pParent) );
CORg( CreateLeafTFSNode(&spNode,
NULL,
static_cast<ITFSNodeHandler *>(pHandler),
static_cast<ITFSResultHandler *>(pHandler),
m_spNodeMgr) );
CORg( pHandler->ConstructNode(spNode, pIf) );
// Make the node immediately visible
CORg( spNode->SetVisibilityState(TFS_VIS_SHOW) );
CORg( pParent->AddChild(spNode) );
Error:
return hr;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::FLookForRoutingEnabledPorts
Returns TRUE if we find at least on routing-enabled port.
Author: KennT
---------------------------------------------------------------------------*/
BOOL IfAdminNodeHandler::FLookForRoutingEnabledPorts(LPCTSTR pszMachineName)
{
PortsDataEntry portsData;
PortsDeviceList portsList;
PortsDeviceEntry * pPorts = NULL;
BOOL fReturn = FALSE;
HRESULT hr = hrOK;
POSITION pos;
COM_PROTECT_TRY
{
CORg( portsData.Initialize(pszMachineName) );
CORg( portsData.LoadDevices(&portsList) );
// Now go through the list, looking for a routing-enabled port
pos = portsList.GetHeadPosition();
while (pos)
{
pPorts = portsList.GetNext(pos);
if ((pPorts->m_dwEnableRouting) ||
(pPorts->m_dwEnableOutboundRouting))
{
fReturn = TRUE;
break;
}
}
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
while (!portsList.IsEmpty())
delete portsList.RemoveHead();
return fReturn;
}
/*---------------------------------------------------------------------------
TunnelDialog implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
TunnelDialog::TunnelDialog
-
Author: KennT
---------------------------------------------------------------------------*/
TunnelDialog::TunnelDialog()
: CBaseDialog(TunnelDialog::IDD)
{
}
/*!--------------------------------------------------------------------------
TunnelDialog::~TunnelDialog
-
Author: KennT
---------------------------------------------------------------------------*/
TunnelDialog::~TunnelDialog()
{
}
BEGIN_MESSAGE_MAP(TunnelDialog, CBaseDialog)
//{{AFX_MSG_MAP(TunnelDialog)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/*!--------------------------------------------------------------------------
RadiusServerDialog::DoDataExchange
-
Author: KennT
---------------------------------------------------------------------------*/
void TunnelDialog::DoDataExchange(CDataExchange* pDX)
{
CBaseDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(TunnelDialog)
//}}AFX_DATA_MAP
}
/*!--------------------------------------------------------------------------
TunnelDialog::OnInitDialog
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL TunnelDialog::OnInitDialog()
{
CBaseDialog::OnInitDialog();
return TRUE;
}
/*!--------------------------------------------------------------------------
TunnelDialog::OnOK
-
Author: KennT
---------------------------------------------------------------------------*/
void TunnelDialog::OnOK()
{
CString stLocal, stRemote;
GetDlgItemText(IDC_TUNNEL_EDIT_NAME, m_stName);
m_stName.TrimLeft();
m_stName.TrimRight();
if (m_stName.IsEmpty())
{
AfxMessageBox(IDS_ERR_TUNNEL_NEEDS_A_NAME);
GetDlgItem(IDC_TUNNEL_EDIT_NAME)->SetFocus();
goto Error;
}
// Truncate the interface ID to MAX_INTERFACE_NAME_LEN characters
if (m_stName.GetLength() > MAX_INTERFACE_NAME_LEN)
{
m_stName.GetBufferSetLength(MAX_INTERFACE_NAME_LEN+1);
m_stName.ReleaseBuffer(MAX_INTERFACE_NAME_LEN);
}
CBaseDialog::OnOK();
Error:
return;
}
Reference in a new issue Copy permalink