OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/net/mmc/mprsnap/machine.cpp

3061 lines
96 KiB
C++
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
machine.pp
FILE HISTORY:
Wei Jiang : 5/7/98 --- SECURE_ROUTERINFO
Postpone the loading of router info
Added function calls SecureRouterInfo before each usage of
router info to make sure router info is loaded.
Wei Jiang : 10/26/98 --- Move Auto Refresh from "Router Interfaces" node to machine node.
Wei Jiang : 10/27/98 --- Move Auto Refresh from "Machine" node to Root node, multiple machine shares
the same auto refresh settings.
*/
#include "stdafx.h"
#include "root.h"
#include "machine.h"
#include "ifadmin.h"
#include "dialin.h"
#include "ports.h"
#include "rtrutilp.h" // InitiateServerConnection
#include "rtrcfg.h"
#include "rtrwiz.h"
#include "cservice.h"
#include <htmlhelp.h>
#include "rrasqry.h"
#include "rtrres.h"
#include "dumbprop.h" // dummy property page
#include "refresh.h"
#include "refrate.h"
#include "cncting.h"
#include "dvsview.h"
#include "rrasutil.h"
#include "rtrcomn.h"
#include "routprot.h" // MS_IP_XXX
#include "raputil.h"
// result message view stuff
#define MACHINE_MESSAGE_MAX_STRING 5
typedef enum _MACHINE_MESSAGES
{
MACHINE_MESSAGE_NOT_CONFIGURED,
MACHINE_MESSAGE_MAX
};
UINT g_uMachineMessages[MACHINE_MESSAGE_MAX][MACHINE_MESSAGE_MAX_STRING] =
{
{IDS_MACHINE_MESSAGE_TITLE, Icon_Information, IDS_MACHINE_MESSAGE_BODY1, IDS_MACHINE_MESSAGE_BODY2, 0},
};
// if you want to test Qry
// #define __RRAS_QRY_TEST // to test the component
//
#ifdef __RRAS_QRY_TEST
#include "dlgtestdlg.h"
#endif
static CString c_stStatUnavail;
static CString c_stStatNotConfig;
static CString c_stStatAccessDenied;
static CString c_stServiceStopped;
static CString c_stServiceStartPending;
static CString c_stServiceStopPending;
static CString c_stServiceRunning;
static CString c_stServiceContinuePending;
static CString c_stServicePausePending;
static CString c_stServicePaused;
static CString c_stServiceStateUnknown;
const CStringMapEntry ServiceStateMap[] =
{
{ SERVICE_STOPPED, &c_stServiceStopped, IDS_SERVICE_STOPPED },
{ SERVICE_START_PENDING, &c_stServiceStartPending, IDS_SERVICE_START_PENDING },
{ SERVICE_STOP_PENDING, &c_stServiceStopPending, IDS_SERVICE_STOP_PENDING },
{ SERVICE_RUNNING, &c_stServiceRunning, IDS_SERVICE_RUNNING },
{ SERVICE_CONTINUE_PENDING, &c_stServiceContinuePending, IDS_SERVICE_CONTINUE_PENDING },
{ SERVICE_PAUSE_PENDING, &c_stServicePausePending, IDS_SERVICE_PAUSE_PENDING },
{ SERVICE_PAUSED, &c_stServicePaused, IDS_SERVICE_PAUSED },
{ -1, &c_stServiceStateUnknown, IDS_SERVICE_UNKNOWN }
};
CString& ServiceStateToCString(DWORD dwState)
{
return MapDWORDToCString(dwState, ServiceStateMap);
}
DEBUG_DECLARE_INSTANCE_COUNTER(MachineNodeData);
MachineNodeData::MachineNodeData()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
m_cRef = 1;
IfDebug(StrCpyA(m_szDebug, "MachineNodeData"));
m_fLocalMachine = TRUE;
m_fAddedAsLocal = TRUE;
m_stMachineName.Empty();
m_fExtension = FALSE;
m_machineState = machine_not_connected;
m_dataState = data_not_loaded;
m_stState.Empty();
m_stServerType.Empty();
m_stBuildNo.Empty();
m_dwPortsInUse = 0;
m_dwPortsTotal = 0;
m_dwUpTime = 0;
m_fStatsRetrieved = FALSE;
m_fIsServer = TRUE;
m_dwServerHandle = 0;
m_hRasAdmin = INVALID_HANDLE_VALUE;
m_routerType = ServerType_Unknown;
m_ulRefreshConnId = 0;
if (c_stStatUnavail.IsEmpty())
c_stStatUnavail.LoadString(IDS_DVS_STATUS_UNAVAILABLE);
if (c_stStatNotConfig.IsEmpty())
c_stStatNotConfig.LoadString(IDS_DVS_STATUS_NOTCONFIG);
if (c_stStatAccessDenied.IsEmpty())
c_stStatAccessDenied.LoadString(IDS_DVS_STATUS_ACCESSDENIED);
DEBUG_INCREMENT_INSTANCE_COUNTER(MachineNodeData);
}
MachineNodeData::~MachineNodeData()
{
if (m_hRasAdmin != INVALID_HANDLE_VALUE)
::CloseHandle(m_hRasAdmin);
m_hRasAdmin = INVALID_HANDLE_VALUE;
DEBUG_DECREMENT_INSTANCE_COUNTER(MachineNodeData);
}
ULONG MachineNodeData::AddRef()
{
return InterlockedIncrement(&m_cRef);
}
ULONG MachineNodeData::Release()
{
Assert(m_cRef > 0);
if (InterlockedDecrement(&m_cRef) == 0)
{
delete this;
return 0;
}
return m_cRef;
}
HRESULT MachineNodeData::Init(LPCTSTR pszMachineName)
{
HRESULT hr = hrOK;
m_stMachineName = pszMachineName;
m_fAddedAsLocal = m_stMachineName.IsEmpty();
m_fLocalMachine = IsLocalMachine(pszMachineName);
return hr;
}
HRESULT MachineNodeData::Merge(const MachineNodeData& data)
{
m_machineState = data.m_machineState;
m_serviceState = data.m_serviceState;
m_dataState = data.m_dataState;
m_stState = data.m_stState; // "started", "stopped", ...
m_stServerType = data.m_stServerType; // Actually the router version
m_stBuildNo = data.m_stBuildNo; // OS Build no.
m_dwPortsInUse = data.m_dwPortsInUse;
m_dwPortsTotal = data.m_dwPortsTotal;
m_dwUpTime = data.m_dwUpTime;
m_fStatsRetrieved = data.m_fStatsRetrieved;
m_routerType = data.m_routerType;
m_MachineConfig = data.m_MachineConfig;
m_routerVersion = data.m_routerVersion;
return S_OK;
}
HRESULT MachineNodeData::SetDefault()
{
// m_fLocalMachine = TRUE;
// m_stMachineName.Empty();
// m_fExtension = FALSE;
m_machineState = machine_not_connected;
m_dataState = data_not_loaded;
m_serviceState = service_unknown;
m_stState.Empty();
m_stServerType.Empty();
m_stBuildNo.Empty();
m_dwPortsInUse = 0;
m_dwPortsTotal = 0;
m_dwUpTime = 0;
m_fStatsRetrieved = FALSE;
// This data is reserved for setting/clearing by the
// MachineHandler().
// m_dwServerHandle = 0;
// m_ulRefreshConnId = 0;
m_routerType = ServerType_Unknown;
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineNodeData::Load
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineNodeData::Load()
{
CString szState;
HRESULT hr = hrOK;
DWORD dwErr;
CWaitCursor wait;
// HKEY hkeyMachine;
// RegKey rkeyMachine;
MIB_SERVER_HANDLE handle = INVALID_HANDLE_VALUE;
MPR_SERVER_0* pserver0 = NULL;
// set the defaults
// ----------------------------------------------------------------
SetDefault();
// Ok, we're no longer in the machine_not_connected (haven't tried yet)
// state.
// ----------------------------------------------------------------
m_machineState = machine_connecting;
// First, try to connect with the registry calls
// ----------------------------------------------------------------
dwErr = ValidateUserPermissions((LPCTSTR) m_stMachineName,
&m_routerVersion,
NULL);
// If this succeeded, then we have access to the right
// areas. We can continue on. This does NOT tell us about
// the service state.
// ----------------------------------------------------------------
if (dwErr == ERROR_ACCESS_DENIED)
{
// An access denied at this stage means that we can't
// do any machine configuration, so this value should
// not get changed by anything below.
// ------------------------------------------------------------
m_machineState = machine_access_denied;
}
else if (dwErr == ERROR_BAD_NETPATH)
{
m_machineState = machine_bad_net_path;
// If we get a bad net path, we can stop right now, since
// everything else will fail also.
// ------------------------------------------------------------
m_stState.LoadString(IDS_MACHINE_NAME_NOT_FOUND);
m_serviceState = service_bad_net_path;
m_dataState = data_unable_to_load;
goto Error;
}
else if (dwErr != ERROR_SUCCESS)
{
// I don't know why we can't connect
// ------------------------------------------------------------
m_machineState = machine_unable_to_connect;
}
// Try to connect to the mpradmin service, to get statistics
// and such.
// ----------------------------------------------------------------
if (m_machineState != machine_access_denied)
{
dwErr = ::MprAdminServerConnect((LPWSTR) (LPCTSTR) m_stMachineName, &handle);
if (dwErr == ERROR_SUCCESS)
dwErr = ::MprAdminServerGetInfo(handle, 0, (LPBYTE *) &pserver0);
if (dwErr == ERROR_SUCCESS)
{
// successful mpradmin fetch
m_dwPortsInUse = pserver0->dwPortsInUse;
m_dwPortsTotal = pserver0->dwTotalPorts;
m_dwUpTime = pserver0->dwUpTime;
m_fStatsRetrieved = TRUE;
}
}
hr = LoadServerVersion();
if (!FHrOK(hr))
{
// We've failed to get the version information.
// This is pretty bad. Assume that we are unable to
// connect.
// ------------------------------------------------------------
if (m_machineState == machine_connecting)
m_machineState = machine_unable_to_connect;
}
// If this is not a server, we need to adjust the states
// so that we don't show the state.
// ----------------------------------------------------------------
if (!m_fIsServer)
{
m_serviceState = service_not_a_server;
m_machineState = machine_unable_to_connect;
m_stState.LoadString(IDS_ERR_IS_A_WKS);
}
else
{
// This will set the service state (started, stopped, etc..)
// ------------------------------------------------------------
FetchServerState( szState );
m_stState = szState;
}
// If we have reached this point, then all is well!
// ----------------------------------------------------------------
if (m_machineState == machine_connecting)
m_machineState = machine_connected;
// load machine config info as well
hr = m_MachineConfig.GetMachineConfig(this);
Error:
if (pserver0) ::MprAdminBufferFree(pserver0);
if (handle != INVALID_HANDLE_VALUE) ::MprAdminServerDisconnect(handle);
return hr;
}
/*!--------------------------------------------------------------------------
MachineNodeData::Unload
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineNodeData::Unload()
{
// Unload the data (i.e. NULL it out).
SetDefault();
return 0;
}
/*!--------------------------------------------------------------------------
MachineNodeData::LoadServerVersion
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineNodeData::LoadServerVersion()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
HKEY hkMachine = 0;
CString skey, stVersion;
CString stServerType;
CString stBuildNo;
CString stProductType;
CString stProductName;
TCHAR szCurrentVersion[256];
TCHAR szCSDVersion[256];
TCHAR szBuffer[256];
DWORD dwErr;
RegKey regkeyWindows;
RegKey regkeyProduct;
int iProductType;
// Windows NT Bug: 274198
// If we couldn't find the path to the machine, just punt
// ----------------------------------------------------------------
if (m_machineState == machine_bad_net_path)
{
m_stState.LoadString(IDS_MACHINE_NAME_NOT_FOUND);
return HResultFromWin32(ERROR_BAD_NETPATH);
}
// Everything we do here uses read-only permissions. So
// we may able to do things even if our machine state is
// machine_access_denied.
// ----------------------------------------------------------------
COM_PROTECT_TRY
{
// This is the default (unknown)
m_stServerType.LoadString(IDS_UNKNOWN);
m_stBuildNo = m_stServerType;
CWRg( ConnectRegistry(m_stMachineName, &hkMachine) );
skey = c_szSoftware;
skey += TEXT('\\');
skey += c_szMicrosoft;
skey += TEXT('\\');
skey += c_szWindowsNT;
skey += TEXT('\\');
skey += c_szCurrentVersion;
CWRg( regkeyWindows.Open(hkMachine, (LPCTSTR) skey, KEY_READ) );
// Ok, now try to get the current version value
CWRg( regkeyWindows.QueryValue( c_szCurrentVersion, szCurrentVersion,
sizeof(szCurrentVersion),
FALSE) );
// Now get the SP version
// ----------------------------------------------------------------
szCSDVersion[0] = 0;
// We don't care if we get an error here
regkeyWindows.QueryValue( c_szCSDVersion, szCSDVersion,
sizeof(szCSDVersion),
FALSE);
if (szCSDVersion[0] == 0)
{
// Set this to a space (to make the print easier)
StrCpy(szCSDVersion, _T(" "));
}
// Determine the product type
// setup the default product type (NTS)
if (_ttoi(szCurrentVersion) >= 5)
{
// For NT5 and up, we can use the
// HKLM \ Software \ Microsoft \ Windows NT \ CurrentVersion
// ProductName : REG_SZ
// --------------------------------------------------------
iProductType = IDS_ROUTER_TYPE_WIN2000_SERVER;
dwErr = regkeyWindows.QueryValue( c_szRegValProductName, stProductName );
if (dwErr != ERROR_SUCCESS)
stProductName.LoadString(IDS_WIN2000);
}
else
iProductType = IDS_ROUTER_TYPE_NTS;
// Now that we've determine the version id, we
// need to determine the product type (wks or svr)
// ------------------------------------------------------------
dwErr = regkeyProduct.Open(hkMachine, c_szRegKeyProductOptions, KEY_READ);
if (dwErr == ERROR_SUCCESS)
{
// Ok, now get the product info
// The product type is used to determine if server or not.
regkeyProduct.QueryValue(c_szRegValProductType, stProductType);
if (stProductType.CompareNoCase(c_szWinNT) == 0)
{
if (_ttoi(szCurrentVersion) >= 5)
iProductType = IDS_ROUTER_TYPE_WIN2000_PRO;
else
iProductType = IDS_ROUTER_TYPE_NTW;
m_fIsServer = FALSE;
}
}
// If this is a Win2000 machine, show
// Win2000 (CSD)
// else
// NT 4.X (CSD)
// ------------------------------------------------------------
if ((iProductType == IDS_ROUTER_TYPE_WIN2000_SERVER) ||
(iProductType == IDS_ROUTER_TYPE_WIN2000_PRO))
AfxFormatString2(stVersion, iProductType,
stProductName, szCSDVersion);
else
AfxFormatString2(stVersion, iProductType,
szCurrentVersion, szCSDVersion);
// Now that we know that it is a workstation or server, adjust
// for RRAS
// If this is a workstation, then routertype is none.
// If this is NT5 or up, then this is a RRAS machine.
// If NT4, if the HKLM\Software\Microsoft\Router exists, this is RRAS
// Else if HKLM\System\CurrentControlSet\Services\RemoteAccess, RAS
// Else nothing is installed.
if (m_fIsServer == FALSE)
{
m_routerType = ServerType_Workstation;
}
else if (_ttoi(szCurrentVersion) >= 5)
{
DWORD dwConfigured;
// Check the configuration flags key.
if (FHrSucceeded(ReadRouterConfiguredReg(m_stMachineName, &dwConfigured)))
{
if (dwConfigured)
m_routerType = ServerType_Rras;
else
m_routerType = ServerType_RrasUninstalled;
}
else
m_routerType = ServerType_Unknown;
}
else
{
RegKey regkeyT;
// Now check for the Router key
dwErr = regkeyT.Open(hkMachine, c_szRegKeyRouter, KEY_READ);
if (dwErr == ERROR_SUCCESS)
m_routerType = ServerType_Rras;
else
{
dwErr = regkeyT.Open(hkMachine, c_szRemoteAccessKey, KEY_READ);
if (dwErr == ERROR_SUCCESS)
m_routerType = ServerType_Ras;
else
m_routerType = ServerType_Uninstalled;
}
regkeyT.Close();
// If the error code is anything other than ERROR_FILE_NOT_FOUND
// then we set the router type to be unknown.
if ((dwErr != ERROR_SUCCESS) &&
(dwErr != ERROR_FILE_NOT_FOUND))
{
m_routerType = ServerType_Unknown;
}
dwErr = ERROR_SUCCESS;
}
// Setup the default string
stServerType = stVersion;
if (_ttoi(szCurrentVersion) == 4)
{
UINT ids = 0;
if (m_routerType == ServerType_Rras)
ids = IDS_RRAS;
else if (m_routerType == ServerType_Ras)
ids = IDS_RAS;
if (ids)
{
CString stRras;
stRras.LoadString(ids);
AfxFormatString2(stServerType, IDS_ROUTER_TYPE_NTsteelhead,
stVersion, stRras);
}
}
m_stServerType = stServerType;
szBuffer[0] = 0;
regkeyWindows.QueryValue( c_szCurrentBuildNumber, szBuffer,
sizeof(szBuffer), FALSE);
m_stBuildNo = szBuffer;
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
if (hkMachine)
DisconnectRegistry( hkMachine );
return hr;
}
/*!--------------------------------------------------------------------------
MachineNodeData::FetchServerState
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineNodeData::FetchServerState(CString& szState)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
DWORD dwStatus, dwErrorCode;
// Windows NT Bug: 274198
// If we couldn't find the path to the machine, just punt
// ----------------------------------------------------------------
if (m_machineState == machine_bad_net_path)
{
szState.LoadString(IDS_MACHINE_NAME_NOT_FOUND);
return HResultFromWin32(ERROR_BAD_NETPATH);
}
// Note: We could be in machine_access_denied but still
// be able to access the service status.
// ----------------------------------------------------------------
hr = GetRouterServiceStatus((LPCTSTR) m_stMachineName,
&dwStatus,
&dwErrorCode);
if (FHrSucceeded(hr))
{
m_MachineConfig.m_dwServiceStatus = dwStatus;
if (dwStatus == SERVICE_RUNNING)
m_serviceState = service_started;
else
m_serviceState = service_stopped;
szState = ServiceStateToCString(dwStatus);
if (m_routerType == ServerType_RrasUninstalled)
{
CString stTemp;
stTemp.Format(IDS_ROUTER_UNINSTALLED,
(LPCTSTR) szState);
szState = stTemp;
}
}
else
{
m_MachineConfig.m_dwServiceStatus = 0;
if (hr == HResultFromWin32(ERROR_ACCESS_DENIED))
{
szState = c_stStatAccessDenied;
m_serviceState = service_access_denied;
}
else
{
szState = c_stStatUnavail;
m_serviceState = service_unknown;
}
}
return hr;
}
typedef struct
{
SERVICE_STATES m_serviceState;
LPARAM m_imageIndex;
} ServiceStateImageMapEntry;
static ServiceStateImageMapEntry s_rgImageMap[] =
{
{ service_unknown, IMAGE_IDX_MACHINE },
{ service_not_a_server, IMAGE_IDX_MACHINE_ERROR },
{ service_access_denied, IMAGE_IDX_MACHINE_ACCESS_DENIED },
{ service_bad_net_path, IMAGE_IDX_MACHINE_ERROR },
{ service_started, IMAGE_IDX_MACHINE_STARTED },
{ service_stopped, IMAGE_IDX_MACHINE_STOPPED },
{ service_rasadmin, IMAGE_IDX_MACHINE_STARTED },
{ service_enum_end, IMAGE_IDX_MACHINE },
};
LPARAM MachineNodeData::GetServiceImageIndex()
{
ServiceStateImageMapEntry * pEntry;
for (pEntry = s_rgImageMap; pEntry->m_serviceState != service_enum_end; pEntry++)
{
if (pEntry->m_serviceState == m_serviceState)
break;
}
return pEntry->m_imageIndex;
}
/*---------------------------------------------------------------------------
MachineHandler implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(MachineHandler)
MachineHandler::MachineHandler(ITFSComponentData *pCompData)
: BaseRouterHandler(pCompData),
m_bExpanded(FALSE),
m_pConfigStream(NULL),
m_bRouterInfoAddedToAutoRefresh(FALSE),
m_bMergeRequired(FALSE),
m_fTryToConnect(TRUE)
{
m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
m_bState[MMC_VERB_PROPERTIES_INDEX] = TRUE;
m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
m_pSumNodeHandler = NULL;
m_pSumNode=NULL;
m_fCreateNewDataObj = FALSE;
m_fNoConnectingUI = FALSE;
m_EventId = -1;
DEBUG_INCREMENT_INSTANCE_COUNTER(MachineHandler);
};
/*!--------------------------------------------------------------------------
MachineHandler::QueryInterface
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP MachineHandler::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 BaseRouterHandler::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;
}
/*!--------------------------------------------------------------------------
MachineHandler::Init
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::Init(LPCTSTR pszMachine,
RouterAdminConfigStream *pConfigStream,
ITFSNodeHandler* pSumNodeHandler /*=NULL*/,
ITFSNode* pSumNode /*=NULL*/)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
m_pConfigStream = pConfigStream;
m_pSumNodeHandler = pSumNodeHandler;
m_pSumNode = pSumNode;
Assert(m_spRouterInfo == NULL);
CORg( CreateRouterInfo(&m_spRouterInfo, m_spTFSCompData->GetHiddenWnd(), pszMachine) );
Assert(m_spRouterInfo != NULL);
// Windows NT Bug : 330939
// Add the delete button to the machine node
// -----------------------------------------------------------------
m_rgButtonState[MMC_VERB_DELETE_INDEX] = ENABLED;
m_bState[MMC_VERB_DELETE_INDEX] = TRUE;
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::GetString
Implementation of ITFSNodeHandler::GetString
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) MachineHandler::GetString(ITFSNode *pNode, int nCol)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
int nFormat;
Assert(pData);
if (m_stNodeTitle.IsEmpty())
{
if (pData->m_fExtension)
nFormat = IDS_RRAS_SERVICE_DESC;
else if (pData->m_fAddedAsLocal)
nFormat = IDS_RRAS_LOCAL_TITLE;
else
nFormat = IDS_RRAS_TITLE;
m_stNodeTitle.Format(nFormat, (LPCTSTR) pData->m_stMachineName);
}
return (LPCTSTR) m_stNodeTitle;
}
/*!--------------------------------------------------------------------------
IfAdminNodeHandler::CreatePropertyPages
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP
MachineHandler::CreatePropertyPages
(
ITFSNode * pNode,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT pDataObject,
LONG_PTR handle,
DWORD dwType
)
{
// Check to see if this router has been initialized
// if not, do the dummy page thing
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
HRESULT hr = hrOK;
SMenuData sData;
SRouterNodeMenu sRouterData;
RtrCfgSheet* pPropSheet = NULL;
SPIComponentData spComponentData;
CString stTitle;
CDummyProperties * pProp;
ULONG ulFlags;
int idsErr;
// Windows NT Bug : 177400
// If the machine is not configured, do not allow the properties
// page to be brought up
// ----------------------------------------------------------------
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
::ZeroMemory(&sRouterData, sizeof(sRouterData));
sRouterData.m_sidMenu = IDS_MENU_RTRWIZ;
sData.m_spNode.Set(pNode);
sData.m_pMachineConfig = &(pData->m_MachineConfig);
sData.m_spRouterInfo.Set(m_spRouterInfo);
CORg( m_spNodeMgr->GetComponentData(&spComponentData) );
ulFlags = MachineRtrConfWizFlags(&sRouterData,
reinterpret_cast<INT_PTR>(&sData));
if ((ulFlags == MF_ENABLED) ||
(ulFlags == 0xFFFFFFFF) ||
(pData->m_machineState < machine_connected))
{
// We are unable to connect.
if (pData->m_machineState == machine_bad_net_path)
idsErr = IDS_ERR_MACHINE_NAME_NOT_FOUND;
if (pData->m_machineState < machine_connected)
idsErr = IDS_ERR_NONADMIN_CANNOT_SEE_PROPERTIES;
// If this is an NT4 machine, we don't show the properties
else if (sData.m_pMachineConfig->m_fNt4)
idsErr = IDS_ERR_CANNOT_SHOW_NT4_PROPERTIES;
// This case means that the install menu should be shown
// and the properties menu hidden
else
idsErr = IDS_ERR_MUST_INSTALL_BEFORE_PROPERTIES;
AfxMessageBox(idsErr);
pProp = new CDummyProperties(pNode, spComponentData, NULL);
hr = pProp->CreateModelessSheet(lpProvider, handle);
}
else
{
pPropSheet = new RtrCfgSheet(pNode, m_spRouterInfo, spComponentData,
m_spTFSCompData, stTitle);
// added by WeiJiang 5/7/98, to postpone the Load of RouterInfo
CORg(SecureRouterInfo(pNode, !m_fNoConnectingUI));
pPropSheet->Init(m_spRouterInfo->GetMachineName());
if (lpProvider)
hr = pPropSheet->CreateModelessSheet(lpProvider, handle);
else
hr = pPropSheet->DoModelessSheet();
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::HasPropertyPages
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP
MachineHandler::HasPropertyPages
(
ITFSNode * pNode,
LPDATAOBJECT pDataObject,
DATA_OBJECT_TYPES type,
DWORD dwType
)
{
return hrOK;
}
// this is the set of menus for NT4 RRAS
static const SRouterNodeMenu s_rgIfNodeMenuNT4[] =
{
// Add items that go on the top menu here
{ IDS_DMV_MENU_START, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_DMV_MENU_STOP, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_MENU_PAUSE_SERVICE, MachineHandler::GetPauseFlags,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_MENU_RESUME_SERVICE, MachineHandler::GetPauseFlags,
CCM_INSERTIONPOINTID_PRIMARY_TASK }
};
// this is the set of menus for NT5
static const SRouterNodeMenu s_rgIfNodeMenu[] =
{
#ifdef kennt
// Add items that go on the top menu here
{ IDS_MENU_NEW_WIZARD_TEST, NULL,
CCM_INSERTIONPOINTID_PRIMARY_TOP },
#endif
{ IDS_MENU_RTRWIZ, MachineHandler::MachineRtrConfWizFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP, _T("_CONFIGURE_RRAS_WIZARD_") },
{ IDS_DMV_MENU_REMOVESERVICE, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TOP, _T("_DISABLE_RRAS_") },
{ IDS_DMV_MENU_START, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_DMV_MENU_STOP, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_MENU_PAUSE_SERVICE, MachineHandler::GetPauseFlags,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_MENU_RESUME_SERVICE, MachineHandler::GetPauseFlags,
CCM_INSERTIONPOINTID_PRIMARY_TASK },
{ IDS_MENU_RESTART_SERVICE, MachineHandler::QueryService,
CCM_INSERTIONPOINTID_PRIMARY_TASK }
};
static const SRouterNodeMenu s_rgIfNodeMenu_ExtensionOnly[] =
{
{ IDS_MENU_SEPARATOR, 0,
CCM_INSERTIONPOINTID_PRIMARY_TOP },
{ IDS_MENU_AUTO_REFRESH, MachineHandler::GetAutoRefreshFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP },
{ IDS_MENU_REFRESH_RATE, MachineHandler::GetAutoRefreshFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP },
};
ULONG MachineHandler::MachineRtrConfWizFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pData)
{
return GetServiceFlags(pMenuData, pData);
}
ULONG MachineHandler::GetServiceFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pUserData)
{
Assert(pUserData);
ULONG uStatus = MF_GRAYED;
SMenuData *pData = reinterpret_cast<SMenuData *>(pUserData);
ULONG ulMenuId = pMenuData->m_sidMenu;
BOOL fStarted = (pData->m_pMachineConfig->m_dwServiceStatus != SERVICE_STOPPED);
if ( ulMenuId == IDS_DMV_MENU_START )
{
// If this is an NT5 machine (or up), then the start menu
// will appear grayed if the machine has not been configured.
if ((pData->m_pMachineConfig->m_fNt4) || (pData->m_pMachineConfig->m_fConfigured))
uStatus = ( fStarted ? MF_GRAYED : MF_ENABLED);
else
{
// If this is an NT5 machine and if the machine is not configured
uStatus = MF_GRAYED;
}
}
else if (( ulMenuId == IDS_DMV_MENU_STOP ) ||
( ulMenuId == IDS_MENU_RESTART_SERVICE) )
{
if (pData->m_pMachineConfig->m_fConfigured)
uStatus = ( fStarted ? MF_ENABLED : MF_GRAYED);
else
uStatus = MF_GRAYED;
}
else if ( (ulMenuId == IDS_MENU_RTRWIZ) ||
(ulMenuId == IDS_DMV_MENU_REMOVESERVICE))
{
if ( pData->m_pMachineConfig->m_fReachable )
{
if ( pData->m_pMachineConfig->m_fNt4 )
{
// This is an NT4 machine, we can't bring
// this menu option up.
uStatus = 0xFFFFFFFF;
}
else
{
if (ulMenuId == IDS_MENU_RTRWIZ)
uStatus = (pData->m_pMachineConfig->m_fConfigured ? MF_GRAYED : MF_ENABLED);
else
uStatus = (pData->m_pMachineConfig->m_fConfigured ? MF_ENABLED : MF_GRAYED);
}
}
}
return uStatus;
}
/*!--------------------------------------------------------------------------
MachineHandler::GetPauseFlags
-
Author: KennT
---------------------------------------------------------------------------*/
ULONG MachineHandler::GetPauseFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pUserData)
{
ULONG ulReturn = MF_GRAYED;
SMenuData *pData = reinterpret_cast<SMenuData *>(pUserData);
ULONG ulMenuId = pMenuData->m_sidMenu;
// We can only pause when the service is started and configured
if ((pData->m_pMachineConfig->m_dwServiceStatus == SERVICE_RUNNING) &&
(ulMenuId == IDS_MENU_PAUSE_SERVICE) && (pData->m_pMachineConfig->m_fConfigured))
ulReturn = 0;
// We can only resume when the service is paused and configured
if ((pData->m_pMachineConfig->m_dwServiceStatus == SERVICE_PAUSED) &&
(ulMenuId == IDS_MENU_RESUME_SERVICE) && (pData->m_pMachineConfig->m_fConfigured))
ulReturn = 0;
return ulReturn;
}
/*!--------------------------------------------------------------------------
MachineHandler::GetAutoRefreshFlags
-
Author: KennT
---------------------------------------------------------------------------*/
ULONG MachineHandler::GetAutoRefreshFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pUserData)
{
ULONG uStatus = MF_GRAYED;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
Assert(pData);
while( pData->m_pMachineConfig->m_fReachable ) // Pseudo loop
{
SPIRouterRefresh spRefresh;
if(!pData->m_spRouterInfo)
break;
pData->m_spRouterInfo->GetRefreshObject(&spRefresh);
if (!spRefresh)
break;
uStatus = MF_ENABLED;
if (pMenuData->m_sidMenu == IDS_MENU_AUTO_REFRESH && (spRefresh->IsRefreshStarted() == hrOK))
{
uStatus |= MF_CHECKED;
}
break;
}
return uStatus;
}
HRESULT MachineHandler::SetExternalRefreshObject(IRouterRefresh *pRefresh)
{
Assert((IRouterInfo*)m_spRouterInfo);
return m_spRouterInfo->SetExternalRefreshObject(pRefresh);
}
ULONG MachineHandler::QueryService(const SRouterNodeMenu *pMenuData, INT_PTR pData)
{
return GetServiceFlags(pMenuData, pData);
}
STDMETHODIMP MachineHandler::OnAddMenuItems(
ITFSNode *pNode,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
LPDATAOBJECT lpDataObject,
DATA_OBJECT_TYPES type,
DWORD dwType,
long *pInsertionAllowed)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
BOOL bExtension = pData->m_fExtension;
UINT cMenu;
const SRouterNodeMenu *pMenu;
SMenuData menuData;
HRESULT hr = S_OK;
COM_PROTECT_TRY
{
// Windows NT Bug : 281492
// If we have not connected, attempt to connect
if (pData->m_machineState == machine_not_connected)
{
pData->Unload();
pData->Load();
}
// For down-level servers, we can't do anything with it.
if ((pData->m_routerType == ServerType_Rras) ||
(pData->m_routerType == ServerType_RrasUninstalled))
{
// Get some initial state data.
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
menuData.m_pMachineConfig = &(pData->m_MachineConfig);
// Now go through and add our menu items
menuData.m_spNode.Set(pNode);
menuData.m_spRouterInfo.Set(m_spRouterInfo);
// NT4 and NT5 have different menus
if (pData->m_MachineConfig.m_fNt4)
{
pMenu = s_rgIfNodeMenuNT4;
cMenu = DimensionOf(s_rgIfNodeMenuNT4);
}
else
{
pMenu = s_rgIfNodeMenu;
cMenu = DimensionOf(s_rgIfNodeMenu);
}
hr = AddArrayOfMenuItems(pNode,
pMenu,
cMenu,
pContextMenuCallback,
*pInsertionAllowed,
(INT_PTR) &menuData);
if(bExtension)
hr = AddArrayOfMenuItems(pNode, s_rgIfNodeMenu_ExtensionOnly,
DimensionOf(s_rgIfNodeMenu_ExtensionOnly),
pContextMenuCallback,
*pInsertionAllowed,
(INT_PTR) &menuData);
}
}
COM_PROTECT_CATCH;
return hr;
}
struct STimerParam
{
MachineHandler * pHandler;
ITFSNode * pNode;
};
extern CTimerMgr g_timerMgr;
void ExpandTimerProc(LPARAM lParam, DWORD dwTime)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
STimerParam * pParam = (STimerParam * )lParam;
pParam->pHandler->ExpandNode(pParam->pNode, TRUE);
}
void MachineHandler::ExpandNode
(
ITFSNode * pNode,
BOOL fExpand
)
{
SPIComponentData spCompData;
SPIDataObject spDataObject;
LPDATAOBJECT pDataObject;
SPIConsole spConsole;
HRESULT hr = hrOK;
RegKey regkey;
BOOL bFound = FALSE;
// don't expand the node if we are handling the EXPAND_SYNC message,
// this screws up the insertion of item, getting duplicates.
m_spNodeMgr->GetComponentData(&spCompData);
CORg ( spCompData->QueryDataObject((MMC_COOKIE) pNode, CCT_SCOPE, &pDataObject) );
spDataObject = pDataObject;
CORg ( m_spNodeMgr->GetConsole(&spConsole) );
CORg ( spConsole->UpdateAllViews(pDataObject, TRUE, RESULT_PANE_EXPAND) );
//set the regkey
if (ERROR_SUCCESS == regkey.Open ( HKEY_LOCAL_MACHINE,
c_szRemoteAccessKey,
KEY_ALL_ACCESS,
m_spRouterInfo->GetMachineName()
)
)
{
DWORD dwSet = 0;
CWRg(regkey.SetValue( c_szRegValOpenMPRSnap, dwSet));
dwSet = 1;
CWRg(regkey.SetValue( c_szRegValOpenIPSnap, dwSet));
}
Error:
if ( m_EventId != -1 )
{
g_timerMgr.FreeTimer(m_EventId);
m_EventId = -1;
}
return;
}
/*!--------------------------------------------------------------------------
MachineHandler::OnCommand
Implementation of ITFSNodeHandler::OnCommand
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP MachineHandler::OnCommand(ITFSNode *pNode, long nCommandId,
DATA_OBJECT_TYPES type,
LPDATAOBJECT pDataObject,
DWORD dwType)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
ClearTFSErrorInfo(0);
COM_PROTECT_TRY
{
switch (nCommandId)
{
case IDS_MENU_NEW_WIZARD_TEST:
{
hr = OnNewRtrRASConfigWiz(pNode, TRUE);
}
break;
case IDS_MENU_RTRWIZ:
hr = OnNewRtrRASConfigWiz(pNode, FALSE);
//hr = OnRtrRASConfigWiz(pNode);
// when summary node is not yet created, then refresh icon
// from machine node is needed
if (!m_pSumNodeHandler &&
(*pNode->GetNodeType()) == GUID_RouterMachineNodeType)
{
MachineNodeData* pData = GET_MACHINENODEDATA(pNode);
Assert(pData);
// Ignore the return value, if the load fails
// we still need to update the icon
// ------------------------------------------------
pData->Load();
hr = SynchronizeIcon(pNode);
//HACK Alert! This is the most
//hacky stuff I have seen around
//but cannot help it at all...
{
STimerParam * pParam = new STimerParam;
pParam ->pHandler = this;
pParam->pNode = pNode;
RegKey regkey;
//set the regkey
if (ERROR_SUCCESS == regkey.Open ( HKEY_LOCAL_MACHINE,
c_szRemoteAccessKey,
KEY_ALL_ACCESS,
m_spRouterInfo->GetMachineName()
)
)
{
DWORD dwSet = 1;
regkey.SetValue( c_szRegValOpenMPRSnap, dwSet);
}
//Give MMC enough time to settle down...
m_EventId = g_timerMgr.AllocateTimer ( ExpandTimerProc,
(LPARAM)pParam,
10000
);
}
}
break;
case IDS_DMV_MENU_START:
case IDS_DMV_MENU_STOP:
case IDS_DMV_MENU_REMOVESERVICE:
case IDS_MENU_PAUSE_SERVICE:
case IDS_MENU_RESUME_SERVICE:
case IDS_MENU_RESTART_SERVICE:
{
// Windows NT Bug : 285537
// First, ask the user if they really wish
// to disable the router.
if ((nCommandId != IDS_DMV_MENU_REMOVESERVICE) ||
(IDYES == AfxMessageBox(IDS_WRN_DISABLE_ROUTER, MB_YESNO)))
{
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
hr = ChgService(pNode,
pData->m_stMachineName,
nCommandId);
}
SynchronizeIcon(pNode);
}
case IDS_DMV_MENU_REFRESH:
{
SPITFSNode spRoutingNode;
SPITFSNodeEnum spMachineEnum;
SPITFSNode spMachineNode;
// when summary node is not yet created, then refresh icon from machine node is needed
if (!m_pSumNodeHandler && (*pNode->GetNodeType()) == GUID_RouterMachineNodeType)
{
MachineNodeData* pData = GET_MACHINENODEDATA(pNode);
Assert(pData);
// Ignore the return value, if the load fails
// we still need to update the icon
// --------------------------------------------
pData->Load();
hr = SynchronizeIcon(pNode);
}
}
break;
case IDS_MENU_REFRESH_RATE:
{
CRefRateDlg refrate;
SPIRouterRefresh spRefresh;
m_spRouterInfo->GetRefreshObject(&spRefresh);
if (spRefresh)
{
DWORD rate;
spRefresh->GetRefreshInterval(&rate);
refrate.m_cRefRate = rate;
if (refrate.DoModal() == IDOK)
{
spRefresh->SetRefreshInterval(refrate.m_cRefRate);
}
}
}
break;
case IDS_MENU_AUTO_REFRESH:
{
SPIRouterRefresh spRefresh;
m_spRouterInfo->GetRefreshObject(&spRefresh);
if(!spRefresh)
break;
if (spRefresh->IsRefreshStarted() == hrOK)
spRefresh->Stop();
else
{
DWORD rate;
spRefresh->GetRefreshInterval(&rate);
spRefresh->Start(rate);
}
}
break;
default:
break;
}
}
COM_PROTECT_CATCH;
if (!FHrSucceeded(hr))
{
DisplayTFSErrorMessage(NULL);
}
ForceGlobalRefresh(m_spRouterInfo);
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineHandler::SynchronizeIcon
-
Author: FlorinT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::SynchronizeIcon(ITFSNode *pNode)
{
HRESULT hr = hrOK;
MachineNodeData *pMachineData;
LPARAM imageIndex;
pMachineData = GET_MACHINENODEDATA(pNode);
Assert(pMachineData);
CString str;
pMachineData->FetchServerState(str);
imageIndex = pMachineData->GetServiceImageIndex();
pNode->SetData(TFS_DATA_IMAGEINDEX, imageIndex);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, imageIndex);
pNode->ChangeNode(SCOPE_PANE_CHANGE_ITEM_ICON);
if (m_bExpanded)
UpdateResultMessage(pNode);
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::ChgService
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::ChgService(ITFSNode *pNode, const CString& szServer, ULONG menuId)
{
CServiceManager sm;
DWORD dw;
ULONG ret;
HRESULT hr=S_OK;
CWaitCursor wait;
DWORD dwStartType = 0;
if (menuId == IDS_DMV_MENU_START)
{
// Windows NT Bug : 310919
// Check service state before starting service.
// ------------------------------------------------------------
hr = GetRouterServiceStartType(szServer, &dwStartType);
if (FHrSucceeded(hr))
{
if (dwStartType == SERVICE_DISABLED)
{
if (AfxMessageBox(IDS_PROMPT_START_DISABLED_SERVICE, MB_YESNO) == IDNO)
goto Error;
SetRouterServiceStartType(szServer, SERVICE_AUTO_START);
}
}
hr = StartRouterService(szServer);
if (!FHrSucceeded(hr))
{
AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_START_ROUTER);
CORg(hr);
}
}
else if (menuId == IDS_DMV_MENU_STOP)
{
hr = StopRouterService(szServer);
if (!FHrSucceeded(hr))
{
AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_STOP_ROUTER);
CORg(hr);
}
}
else if (menuId == IDS_DMV_MENU_REMOVESERVICE)
{
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
GUID guidConfig = GUID_RouterNull;
SPIRouterProtocolConfig spRouterConfig;
SPIRtrMgrProtocolInfo spRmProt;
RtrMgrProtocolCB RmProtCB;
// Stop the router service
hr = StopRouterService((LPCTSTR) szServer);
if (!FHrSucceeded(hr))
{
AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_REMOVE_ROUTER);
CORg(hr);
}
// remove router id object from DS if the it's an NT5 server
Assert(m_spRouterInfo);
if(FHrSucceeded( hr = SecureRouterInfo(pNode, !m_fNoConnectingUI)))
{
RouterVersionInfo RVI;
USES_CONVERSION;
if(S_OK == m_spRouterInfo->GetRouterVersionInfo(&RVI) && RVI.dwRouterVersion >= 5)
{
hr = RRASDelRouterIdObj(T2W((LPTSTR)(LPCTSTR)szServer));
Assert(hr == S_OK);
}
}
// Windows NT Bug : 389469
// This is hardcoded for NAT (I do not want to change too much).
// Find the config GUID for NAT, and then remove the protocol.
hr = LookupRtrMgrProtocol(m_spRouterInfo,
PID_IP,
MS_IP_NAT,
&spRmProt);
// If the lookup returns S_FALSE, then it couldn't find the
// protocol.
if (FHrOK(hr))
{
spRmProt->CopyCB(&RmProtCB);
CORg( CoCreateProtocolConfig(RmProtCB.guidConfig,
m_spRouterInfo,
PID_IP,
MS_IP_NAT,
&spRouterConfig) );
if (spRouterConfig)
hr = spRouterConfig->RemoveProtocol(m_spRouterInfo->GetMachineName(),
PID_IP,
MS_IP_NAT,
NULL,
0,
m_spRouterInfo,
0);
}
// Perform any removal/cleanup action
UninstallGlobalSettings(szServer,
m_spRouterInfo,
pData->m_MachineConfig.m_fNt4,
TRUE);
// Remove the router from the domain
if (m_spRouterInfo->GetRouterType() != ROUTER_TYPE_LAN)
RegisterRouterInDomain(szServer, FALSE);
// Disable the service
SetRouterServiceStartType((LPCTSTR) szServer,
SERVICE_DISABLED);
//
// Bug 519414
// Since IAS now has a Microsoft policy with the appropriate settings,
// there is no longer a single default policy. In addition there is
// no need to update any policy to have the required settings since the
// Microsoft VPN server policy does the job.
//
#if __DEFAULT_POLICY
//Now update the default policy
CORg( UpdateDefaultPolicy((LPTSTR)(LPCTSTR)szServer,
FALSE,
FALSE,
0
) );
#endif
}
else if (menuId == IDS_MENU_PAUSE_SERVICE)
{
hr = PauseRouterService(szServer);
if (!FHrSucceeded(hr))
{
AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_PAUSE_ROUTER);
CORg(hr);
}
}
else if (menuId == IDS_MENU_RESUME_SERVICE)
{
hr = ResumeRouterService(szServer);
if (!FHrSucceeded(hr))
{
AddHighLevelErrorStringId(IDS_ERR_COULD_NOT_RESUME_ROUTER);
CORg(hr);
}
}
else if (menuId == IDS_MENU_RESTART_SERVICE)
{
// Do a stop and then a start
//CORg( ChgService(pNode, szServer, IDS_DMV_MENU_STOP) );
//CORg( ChgService(pNode, szServer, IDS_DMV_MENU_START) );
COSERVERINFO csi;
COAUTHINFO cai;
COAUTHIDENTITY caid;
SPIRemoteRouterRestart spRestart;
IUnknown * punk = NULL;
ZeroMemory(&csi, sizeof(csi));
ZeroMemory(&cai, sizeof(cai));
ZeroMemory(&caid, sizeof(caid));
csi.pAuthInfo = &cai;
cai.pAuthIdentityData = &caid;
CORg( CoCreateRouterConfig(szServer,
m_spRouterInfo,
&csi,
IID_IRemoteRouterRestart,
&punk) );
spRestart = (IRemoteRouterRestart *) punk;
spRestart->RestartRouter(0);
//Get the current time before we begin restart the router
CTime timeStart = CTime::GetCurrentTime();
spRestart.Release();
// Put up the dialog with the funky spinning thing to
// let the user know that something is happening
CString stTitle;
CString stDescrption;
stTitle.LoadString(IDS_PROMPT_SERVICE_RESTART_TITLE);
stDescrption.Format(IDS_PROMPT_SERVICE_RESTART_DESC, szServer);
CRestartRouterDlg dlgRestartRouter(szServer, (LPCTSTR)stDescrption,
(LPCTSTR)stTitle, &timeStart);
dlgRestartRouter.DoModal();
if (NO_ERROR != dlgRestartRouter.m_dwError)
{
AddHighLevelErrorStringId(IDS_ERR_RESTART_SERVICE);
hr = HRESULT_FROM_WIN32(dlgRestartRouter.m_dwError);
}
else if (dlgRestartRouter.m_fTimeOut)
{
CString stErrMsg;
stErrMsg.Format(IDS_ERR_RESTART_TIMEOUT, szServer);
::AfxMessageBox((LPCTSTR)stErrMsg);
}
if (csi.pAuthInfo)
delete csi.pAuthInfo->pAuthIdentityData->Password;
}
Error:
if (!FHrSucceeded(hr))
{
AddSystemErrorMessage(hr);
TRACE0("MachineHandler::ChgService, unable to start/stop service");
}
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::OnCreateDataObject
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP MachineHandler::OnCreateDataObject(MMC_COOKIE cookie,
DATA_OBJECT_TYPES type,
IDataObject **ppDataObject)
{
Assert(ppDataObject);
HRESULT hr = hrOK;
MachineNodeData * pData;
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
pData = GET_MACHINENODEDATA(spNode);
COM_PROTECT_TRY
{
if (m_spDataObject)
{
// If our cached data object does not have the correct
// type, release it and create a new one.
// or if it doesn't have a RouterInfo object and one is now
// available, recreate
SPINTERNAL spInternal = ExtractInternalFormat(m_spDataObject);
SPIRouterInfo spRouterInfo;
if ( (spInternal != NULL && (spInternal->m_type != type)) ||
(FAILED(spRouterInfo.HrQuery(m_spDataObject)) && m_spRouterInfo) )
m_spDataObject.Set(NULL);
}
if (!m_spDataObject)
{
//if (FAILED(SecureRouterInfo(spNode)))
//{
// Trace0("SecureRouterInfo failed! Creating data object without RouterInfo\n");
//}
if (m_spRouterInfo)
{
CORg( CreateDataObjectFromRouterInfo(m_spRouterInfo,
pData->m_stMachineName,
type, cookie, m_spTFSCompData,
&m_spDataObject, &m_dynExtensions,
pData->m_fAddedAsLocal
) );
}
else
{
CORg( CreateRouterDataObject(pData->m_stMachineName,
type, cookie, m_spTFSCompData,
&m_spDataObject, &m_dynExtensions,
pData->m_fAddedAsLocal) );
}
Assert(m_spDataObject);
}
*ppDataObject = m_spDataObject;
(*ppDataObject)->AddRef();
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::ConstructNode
Initializes the node for a machine.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::ConstructNode(ITFSNode *pNode, LPCTSTR szMachine, MachineNodeData *pMachineData)
{
DWORD dwErr;
const GUID * pguid;
HRESULT hr = hrOK;
int i;
Assert(pMachineData);
pNode->SetData(TFS_DATA_IMAGEINDEX, IMAGE_IDX_MACHINE);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, IMAGE_IDX_MACHINE);
pNode->SetNodeType(&GUID_RouterMachineErrorNodeType);
// Save the machine type for this particular data type
pNode->SetData(TFS_DATA_TYPE, ROUTER_NODE_MACHINE);
// Assume that there's nothing in the node at this point
Assert(pNode->GetData(TFS_DATA_USER) == 0);
// If szMachine == NULL, then this is the local machine and
// we have to get the name of the local machine
// added the first condition m_fLocalMachine, to fix bug 223062
pMachineData->m_fAddedAsLocal = FALSE;
if (pMachineData->m_fLocalMachine || szMachine == NULL || *szMachine == 0)
{
pMachineData->m_stMachineName = GetLocalMachineName();
pMachineData->m_fLocalMachine = TRUE;
if(szMachine == NULL || *szMachine == 0)
{
pMachineData->m_fAddedAsLocal = TRUE;
// set flag in routeInfo, so other component will get this piece
Assert(m_spRouterInfo); // should have been initialized at this point
// append add as local flag
m_spRouterInfo->SetFlags(m_spRouterInfo->GetFlags() | RouterInfo_AddedAsLocal);
}
}
else
{
// Strip out the "\\" if there are any
if ((szMachine[0] == _T('\\')) && (szMachine[1] == _T('\\')))
pMachineData->m_stMachineName = szMachine + 2;
else
pMachineData->m_stMachineName = szMachine;
pMachineData->m_fLocalMachine = FALSE;
}
pMachineData->m_cookie = (MMC_COOKIE) pNode->GetData(TFS_DATA_COOKIE);
// Save the machine data back to the node
pMachineData->AddRef();
SET_MACHINENODEDATA(pNode, pMachineData);
/*-----------------------------------------------------------------------
* ALL data for the node that holds true, even if we can't get to
* the machine, must be set before the call to QueryRouterType()!
------------------------------------------------------------------------*/
pNode->SetNodeType(&GUID_RouterMachineNodeType);
SynchronizeIcon(pNode);
EnumDynamicExtensions(pNode);
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::DestroyHandler
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP MachineHandler::DestroyHandler(ITFSNode *pNode)
{
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
// Release the refresh advise sinks
// ----------------------------------------------------------------
if ( m_spRouterInfo )
{
SPIRouterRefresh spRefresh;
SPIRouterRefreshModify spModify;
m_spRouterInfo->GetRefreshObject(&spRefresh);
if(spRefresh && m_bRouterInfoAddedToAutoRefresh)
{
spModify.HrQuery(spRefresh);
if (spModify)
spModify->RemoveRouterObject(IID_IRouterInfo, m_spRouterInfo);
}
if (spRefresh && pData->m_ulRefreshConnId )
spRefresh->UnadviseRefresh(pData->m_ulRefreshConnId);
}
pData->Release();
SET_MACHINENODEDATA(pNode, NULL);
m_spDataObject.Release();
m_spRouterInfo.Release();
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineHandler::SetExtensionStatus
Sets whether this node is operating as an extension (network console).
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT MachineHandler::SetExtensionStatus(ITFSNode * pNode, BOOL bExtension)
{
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
pData->m_fExtension = bExtension;
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineHandler::SecureRouterInfo
to postpone the loading of RouterInfo from Init, till it's used
function SecureRouterInfo is introduced to make sure RouterInfo is Loaded
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::SecureRouterInfo(ITFSNode *pNode, BOOL fShowUI)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
HRESULT hr = S_OK;
Assert(m_spRouterInfo);
// If the name is invalid, skip this attempt.
// ----------------------------------------------------------------
// if (pData->m_machineState == machine_bad_net_path)
// {
// pData->m_dataState = data_unable_to_load;
// return hr;
// }
// If this is an NT4 RAS server, we don't need to do this
// ----------------------------------------------------------------
if (pData->m_routerType == ServerType_Ras)
{
pData->m_dataState = data_unable_to_load;
SynchronizeIcon(pNode);
return hr;
}
// If this is a workstation, we don't need to connect
// ----------------------------------------------------------------
if (pData->m_fIsServer == FALSE)
{
pData->m_dataState = data_unable_to_load;
SynchronizeIcon(pNode);
return hr;
}
// This function should try to connect
// (or reconnect).
if ((pData->m_dataState == data_not_loaded) ||
(pData->m_dataState == data_unable_to_load) ||
(pData->m_machineState == machine_access_denied))
{
pData->m_dataState = data_loading;
CORg(InitiateServerConnection(pData->m_stMachineName,
NULL,
!fShowUI,
m_spRouterInfo));
if (!FHrOK(hr))
{
// though this case when user chooses cancel on user/password dlg,
// this is considered as FAIL to connect
if (hr == S_FALSE)
hr = HResultFromWin32(ERROR_CANCELLED);
goto Error;
}
{
CWaitCursor wc;
if (m_bMergeRequired)
{
SPIRouterInfo spNewRouter;
CORg( CreateRouterInfo(&spNewRouter, NULL , (LPCTSTR) pData->m_stMachineName));
TransferCredentials ( m_spRouterInfo,
spNewRouter
);
CORg( spNewRouter->Load(T2COLE((LPTSTR) (LPCTSTR) pData->m_stMachineName),
NULL) );
m_spRouterInfo->Merge(spNewRouter);
}
else
{
CORg( m_spRouterInfo->Load(T2COLE((LPTSTR) (LPCTSTR) pData->m_stMachineName),
NULL) );
m_bMergeRequired = TRUE;
}
pData->Load();
}
pData->m_dataState = data_loaded;
}
Error:
if (FAILED(hr))
{
pData->m_dataState = data_unable_to_load;
if (hr == HResultFromWin32(ERROR_BAD_NETPATH))
{
pData->m_machineState = machine_bad_net_path;
pData->m_stState.LoadString(IDS_MACHINE_NAME_NOT_FOUND);
pData->m_serviceState = service_bad_net_path;
}
else if (hr == HResultFromWin32(ERROR_CANCELLED))
{
pData->m_machineState = machine_access_denied;
pData->m_stState = c_stStatAccessDenied;
pData->m_serviceState = service_access_denied;
}
}
// No matter what, try to synchronize the icon
// ----------------------------------------------------------------
SynchronizeIcon(pNode);
return hr;
};
/*!--------------------------------------------------------------------------
MachineHandler::OnExpandSync
If this gets called, then MMC is initalizing and we don't want to
put up UI which can cause messages to start flying around....
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnExpandSync(ITFSNode *pNode,
LPDATAOBJECT pDataObject,
LPARAM arg,
LPARAM lParam)
{
m_fNoConnectingUI = TRUE;
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineHandler::OnExpand
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnExpand(ITFSNode *pNode,
LPDATAOBJECT pDataObject,
DWORD dwType,
LPARAM arg,
LPARAM lParam)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
SPITFSNode spNode;
SPITFSNodeHandler spHandler;
IfAdminNodeHandler * pHandler = NULL;
DialInNodeHandler * pDialInHandler = NULL;
PortsNodeHandler * pPortsHandler = NULL;
RouterVersionInfo versionInfo;
DWORD dwRouterFlags = 0;
DWORD dwRouterType = 0;
MachineNodeData * pData = NULL;
if (m_bExpanded)
return hr;
CComPtr<IConsole2> spConsole;
m_spTFSCompData->GetConsole(&spConsole);
if(spConsole != NULL)
{
HWND hMainWnd = NULL;
spConsole->GetMainWindow(&hMainWnd);
if (hMainWnd)
SetForegroundWindow(hMainWnd);
}
// If this is an error node, don't show the child nodes
// ----------------------------------------------------------------
if (*(pNode->GetNodeType()) == GUID_RouterMachineErrorNodeType)
return hrOK;
Assert(m_spRouterInfo);
// We need the machine node data, that is where the connection id
// is stored.
// ----------------------------------------------------------------
pData = GET_MACHINENODEDATA(pNode);
// Load the data if we need to:
// ----------------------------------------------------------------
if (pData->m_machineState == machine_not_connected)
pData->Load();
SynchronizeIcon(pNode);
// Windows Nt Bug : 302430
// If this is an NT4 machine, we don't need to do the rest
// ----------------------------------------------------------------
if (pData->m_routerType == ServerType_Ras)
goto Error;
// Connect to the target router
// ----------------------------------------------------------------
CORg( SecureRouterInfo(pNode, m_fNoConnectingUI) );
// Windows NT Bug : ?
// Need to check the machine state.
// ----------------------------------------------------------------
if (pData->m_dataState < data_loaded)
return hrOK;
{
CWaitCursor wc;
// Setup the refresh advise sinks
// ----------------------------------------------------------------
if ( m_spRouterInfo )
{
SPIRouterRefresh spRefresh;
SPIRouterRefreshModify spModify;
m_spRouterInfo->GetRefreshObject(&spRefresh);
if(spRefresh)
{
spModify.HrQuery(spRefresh);
if (spModify)
spModify->AddRouterObject(IID_IRouterInfo, m_spRouterInfo);
m_bRouterInfoAddedToAutoRefresh = TRUE;
// The lUserParam for this refresh connection, must be the
// cookie.
// ------------------------------------------------------------
if ( pData->m_ulRefreshConnId == 0 )
spRefresh->AdviseRefresh(&m_IRtrAdviseSink,
&(pData->m_ulRefreshConnId),
pNode->GetData(TFS_DATA_COOKIE));
}
}
dwRouterType = m_spRouterInfo->GetRouterType();
m_spRouterInfo->GetRouterVersionInfo(&versionInfo);
dwRouterFlags = versionInfo.dwRouterFlags;
// Routing interfaces is enabled only if NOT a RAS-only router
AddRemoveRoutingInterfacesNode(pNode, dwRouterType, dwRouterFlags);
AddRemoveDialinNode(pNode, dwRouterType, dwRouterFlags);
AddRemovePortsNode(pNode, dwRouterType, dwRouterFlags);
// update status node, and Icon
if (m_pSumNodeHandler && m_pSumNode)
m_pSumNodeHandler->OnCommand(m_pSumNode,IDS_MENU_REFRESH,CCT_RESULT, NULL, 0);
m_bExpanded = TRUE;
CORg(AddDynamicNamespaceExtensions(pNode));
}
Error:
// Windows NT Bug : 274198
// If we have an error and if the error is not "ERROR_BAD_NETPATH"
// then we continue to load the info
// ----------------------------------------------------------------
// Setup the machine state at this point
// ----------------------------------------------------------------
if (!FHrSucceeded(hr))
{
if (hr == HResultFromWin32(ERROR_BAD_NETPATH))
{
pData->m_machineState = machine_bad_net_path;
pData->m_serviceState = service_bad_net_path;
pData->m_stState.LoadString(IDS_MACHINE_NAME_NOT_FOUND);
}
else
{
// Try to load up the data if we can
if ((pData->m_machineState == machine_unable_to_connect) ||
(pData->m_machineState == machine_not_connected))
pData->Load();
if (pData->m_routerType == ServerType_Ras)
hr = StartRasAdminExe(pData);
else if (hr != HResultFromWin32(ERROR_CANCELLED))
DisplayErrorMessage(NULL, hr);
}
m_fTryToConnect = FALSE;
// snapin relies on registry service, check if it's running.
// check if Remote Registry Service is not running
CServiceManager csm;
CService svr;
DWORD dwState = 0;
BOOL RRWrong = TRUE; // if any problem with RemoteRegistry Service
if (!IsLocalMachine(m_spRouterInfo->GetMachineName()) && SUCCEEDED( csm.HrOpen(SC_MANAGER_CONNECT, m_spRouterInfo->GetMachineName(), NULL)))
{
if (SUCCEEDED(csm.HrOpenService(&svr, L"RemoteRegistry", SERVICE_QUERY_STATUS)))
{
if (SUCCEEDED(svr.HrQueryState(&dwState)))
{
if(dwState == SERVICE_RUNNING)
RRWrong = FALSE;
}
}
if (RRWrong)
{
CString str1;
str1.LoadString(IDS_ERR_RR_SERVICE_NOT_RUNNING);
CString str;
str.Format(str1, m_spRouterInfo->GetMachineName());
::AfxMessageBox(str);
}
}
// end of remote registry service checking
}
return hr;
}
HRESULT MachineHandler::OnResultRefresh(ITFSComponent * pComponent,
LPDATAOBJECT pDataObject,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode;
m_spResultNodeMgr->FindNode(cookie, &spNode);
MachineNodeData * pData = GET_MACHINENODEDATA(spNode);
int nOldState = pData->m_dataState;
if (pData->m_dataState != data_loaded)
{
SPIDataObject spDataObject;
// change state to not connected here
pData->m_dataState = data_not_loaded;
hr = SecureRouterInfo(spNode, m_fNoConnectingUI);
}
// force an update if the machine was able to load
// or the state has changed
if (hr == S_OK &&
m_spRouterInfo &&
( (pData->m_dataState >= data_loaded) ||
(nOldState != pData->m_dataState) ) )
{
ForceGlobalRefresh(m_spRouterInfo);
hr = OnCommand(spNode, IDS_DMV_MENU_REFRESH, CCT_RESULT, NULL, 0);
}
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::AddMenuItems
Over-ride this to add our view menu item
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
MachineHandler::AddMenuItems
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPDATAOBJECT pDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long * pInsertionAllowed
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
HRESULT hr = S_OK;
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::Command
Handles commands for the current view
Author: EricDav
---------------------------------------------------------------------------*/
STDMETHODIMP
MachineHandler::Command
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCommandID,
LPDATAOBJECT pDataObject
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
switch (nCommandID)
{
case MMCC_STANDARD_VIEW_SELECT:
break;
}
return hr;
}
/*---------------------------------------------------------------------------
MachineHandler::OnGetResultViewType
Return the result view that this node is going to support
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT
MachineHandler::OnGetResultViewType
(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPOLESTR * ppViewType,
long * pViewOptions
)
{
LPWSTR lpwszFormat = NULL;
LPWSTR lpwszURL = NULL;
WCHAR wszSystemDirectory[MAX_PATH+1] = {0};
SPITFSNode spNode;
m_spResultNodeMgr->FindNode(cookie, &spNode);
MachineNodeData * pData = GET_MACHINENODEDATA(spNode);
if ( !pData->m_MachineConfig.m_fConfigured )
{
lpwszFormat = L"res://%s\\mprsnap.dll/configure.htm";
}
else
{
lpwszFormat = L"res://%s\\mprsnap.dll/cfgdone.htm";
}
GetSystemDirectoryW ( wszSystemDirectory, MAX_PATH);
lpwszURL = (LPWSTR)CoTaskMemAlloc( ( ::lstrlen(wszSystemDirectory) + ::lstrlen(lpwszFormat) ) * sizeof(WCHAR) );
if ( lpwszURL )
{
wsprintf( lpwszURL, lpwszFormat, wszSystemDirectory );
*pViewOptions = MMC_VIEW_OPTIONS_NOLISTVIEWS;
*ppViewType = lpwszURL;
return S_OK;
}
else
{
return E_OUTOFMEMORY;
}
//return BaseRouterHandler::OnGetResultViewType(pComponent, cookie, ppViewType, pViewOptions);
}
/*!--------------------------------------------------------------------------
MachineHandler::OnResultSelect
Update the result pane
Author: EricDav
---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnResultSelect(ITFSComponent *pComponent,
LPDATAOBJECT pDataObject,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM lParam)
{
HRESULT hr = hrOK;
SPITFSNode spNode;
CORg(BaseRouterHandler::OnResultSelect(pComponent, pDataObject, cookie, arg, lParam));
m_spNodeMgr->FindNode(cookie, &spNode);
UpdateResultMessage(spNode);
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::UpdateResultMessage
Determines what (if anything) to put in the result pane message
Author: EricDav
---------------------------------------------------------------------------*/
void MachineHandler::UpdateResultMessage(ITFSNode * pNode)
{
HRESULT hr = hrOK;
int nMessage = -1; // default none
int i;
CString strTitle, strBody, strTemp;
// Only do this if the node we are looking at is a
// machine node.
if ((pNode == NULL) ||
(*(pNode->GetNodeType()) != GUID_RouterMachineNodeType))
return;
MachineNodeData * pData = GET_MACHINENODEDATA(pNode);
if (pData == NULL)
return;
if (pData->m_routerType == ServerType_RrasUninstalled)
{
nMessage = MACHINE_MESSAGE_NOT_CONFIGURED;
// now build the text strings
// first entry is the title
strTitle.LoadString(g_uMachineMessages[nMessage][0]);
// second entry is the icon
// third ... n entries are the body strings
for (i = 2; g_uMachineMessages[nMessage][i] != 0; i++)
{
strTemp.LoadString(g_uMachineMessages[nMessage][i]);
strBody += strTemp;
}
}
if (nMessage == -1)
{
ClearMessage(pNode);
}
else
{
ShowMessage(pNode, strTitle, strBody, (IconIdentifier) g_uMachineMessages[nMessage][1]);
}
}
/*!--------------------------------------------------------------------------
MachineHandler::UserResultNotify
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::UserResultNotify(ITFSNode *pNode,
LPARAM lParam1,
LPARAM lParam2)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
// Do not handle RRAS_ON_SAVE, since there isn't any column
// information for us to save.
// ------------------------------------------------------------
if (lParam1 != RRAS_ON_SAVE)
{
hr = BaseRouterHandler::UserResultNotify(pNode, lParam1, lParam2);
}
}
COM_PROTECT_CATCH;
return hr;
}
/*---------------------------------------------------------------------------
Embedded IRtrAdviseSink
---------------------------------------------------------------------------*/
ImplementEmbeddedUnknown(MachineHandler, IRtrAdviseSink)
/*!--------------------------------------------------------------------------
MachineHandler::EIRtrAdviseSink::OnChange
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP MachineHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
InitPThis(MachineHandler, IRtrAdviseSink);
SPITFSNode spThisNode;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
//$ TODO : this is bogus, this is tied to the cookie
// for this handler. What we need is a mapping between
// the connection ids (for this handler) and the appropriate
// nodes.
// ------------------------------------------------------------
// The lUserParam passed into the refresh is the cookie for
// this machine node.
// ------------------------------------------------------------
pThis->m_spNodeMgr->FindNode(lUserParam, &spThisNode);
if(spThisNode)
pThis->SynchronizeIcon(spThisNode);
if (dwChangeType == ROUTER_REFRESH)
{
DWORD dwNewRouterType, dwNewRouterFlags;
RouterVersionInfo versionInfo;
dwNewRouterType = pThis->m_spRouterInfo->GetRouterType();
pThis->m_spRouterInfo->GetRouterVersionInfo(&versionInfo);
dwNewRouterFlags = versionInfo.dwRouterFlags;
// Ok, we have to take a look see and what nodes
// we can add/remove
// ----------------------------------------------------
// Look to see if we need the Routing Interfaces node
// ----------------------------------------------------
pThis->AddRemoveRoutingInterfacesNode(spThisNode, dwNewRouterType,
dwNewRouterFlags);
// Look to see if we need the ports node
// ----------------------------------------------------
pThis->AddRemovePortsNode(spThisNode, dwNewRouterType,
dwNewRouterFlags);
// Look to see if we need the Dial-In Clients node
// ----------------------------------------------------
pThis->AddRemoveDialinNode(spThisNode, dwNewRouterType,
dwNewRouterFlags);
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::AddRemoveRoutingInterfacesNode
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::AddRemoveRoutingInterfacesNode(ITFSNode *pNode, DWORD dwRouterType, DWORD dwRouterFlags)
{
HRESULT hr = hrOK;
SPITFSNodeHandler spHandler;
IfAdminNodeHandler * pHandler = NULL;
SPITFSNode spChild;
// Search for an already existing node
// ----------------------------------------------------------------
SearchChildNodesForGuid(pNode, &GUID_RouterIfAdminNodeType, &spChild);
if ((dwRouterType & (ROUTER_TYPE_WAN | ROUTER_TYPE_LAN)) &&
(dwRouterFlags & RouterSnapin_IsConfigured))
{
// Create the new node if we don't already have one
// ------------------------------------------------------------
if (spChild == NULL)
{
// as a default, add the routing interfaces node
// --------------------------------------------------------
pHandler = new IfAdminNodeHandler(m_spTFSCompData);
CORg( pHandler->Init(m_spRouterInfo, m_pConfigStream) );
spHandler = pHandler;
CreateContainerTFSNode(&spChild,
&GUID_RouterIfAdminNodeType,
static_cast<ITFSNodeHandler *>(pHandler),
static_cast<ITFSResultHandler *>(pHandler),
m_spNodeMgr);
// Call to the node handler to init the node data
// --------------------------------------------------------
pHandler->ConstructNode(spChild);
// Make the node immediately visible
// --------------------------------------------------------
spChild->SetVisibilityState(TFS_VIS_SHOW);
//$ TODO : We should add this in the right place (where is that?)
// --------------------------------------------------------
pNode->AddChild(spChild);
}
}
else
{
if (spChild)
{
// Remove this node
// --------------------------------------------------------
pNode->RemoveChild(spChild);
spChild->Destroy();
spChild.Release();
}
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::AddRemovePortsNode
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::AddRemovePortsNode(ITFSNode *pNode, DWORD dwRouterType,
DWORD dwRouterFlags)
{
HRESULT hr = hrOK;
SPITFSNodeHandler spHandler;
PortsNodeHandler * pPortsHandler = NULL;
SPITFSNode spChild;
// Search for an already existing node
// ----------------------------------------------------------------
SearchChildNodesForGuid(pNode, &GUID_RouterPortsNodeType, &spChild);
if ( (dwRouterType & (ROUTER_TYPE_RAS | ROUTER_TYPE_WAN) ) &&
(dwRouterFlags & RouterSnapin_IsConfigured))
{
// Create the new node if we don't already have one
// ------------------------------------------------------------
if (spChild == NULL)
{
// as a default, add the routing interfaces node
// --------------------------------------------------------
pPortsHandler = new PortsNodeHandler(m_spTFSCompData);
CORg( pPortsHandler->Init(m_spRouterInfo, m_pConfigStream) );
spHandler = pPortsHandler;
CreateContainerTFSNode(&spChild,
&GUID_RouterPortsNodeType,
static_cast<ITFSNodeHandler *>(pPortsHandler),
static_cast<ITFSResultHandler *>(pPortsHandler),
m_spNodeMgr);
// Call to the node handler to init the node data
// --------------------------------------------------------
pPortsHandler->ConstructNode(spChild);
// Make the node immediately visible
// --------------------------------------------------------
spChild->SetVisibilityState(TFS_VIS_SHOW);
//$ TODO : We should add this in the right place (where is that?)
// --------------------------------------------------------
pNode->AddChild(spChild);
}
}
else
{
if (spChild)
{
// Remove this node
// --------------------------------------------------------
pNode->RemoveChild(spChild);
spChild->Destroy();
spChild.Release();
}
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::AddRemoveDialinNode
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::AddRemoveDialinNode(ITFSNode *pNode, DWORD dwRouterType,
DWORD dwRouterFlags)
{
HRESULT hr = hrOK;
SPITFSNodeHandler spHandler;
DialInNodeHandler * pDialInHandler = NULL;
SPITFSNode spChild;
// Search for an already existing node
// ----------------------------------------------------------------
SearchChildNodesForGuid(pNode, &GUID_RouterDialInNodeType, &spChild);
if ((dwRouterType & ROUTER_TYPE_RAS ) &&
(dwRouterFlags & RouterSnapin_IsConfigured))
{
// Create the new node if we don't already have one
// ------------------------------------------------------------
if (spChild == NULL)
{
// as a default, add the dial in node
pDialInHandler = new DialInNodeHandler(m_spTFSCompData);
CORg( pDialInHandler->Init(m_spRouterInfo, m_pConfigStream) );
spHandler = pDialInHandler;
CreateContainerTFSNode(&spChild,
&GUID_RouterDialInNodeType,
static_cast<ITFSNodeHandler *>(pDialInHandler),
static_cast<ITFSResultHandler *>(pDialInHandler),
m_spNodeMgr);
// Call to the node handler to init the node data
pDialInHandler->ConstructNode(spChild);
// Make the node immediately visible
spChild->SetVisibilityState(TFS_VIS_SHOW);
//$ TODO : We should add this in the right place (where is that?)
// --------------------------------------------------------
pNode->AddChild(spChild);
}
}
else
{
if (spChild)
{
// Remove this node
// --------------------------------------------------------
pNode->RemoveChild(spChild);
spChild->Destroy();
spChild.Release();
}
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
MachineConfig::GetMachineConfig
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineConfig::GetMachineConfig(MachineNodeData *pData)
{
// m_fReachable
m_fReachable = (pData->m_machineState == machine_connected);
// m_fNt4
m_fNt4 = (pData->m_routerVersion.dwRouterVersion <= 4);
// m_fConfigured
m_fConfigured = (pData->m_routerType != ServerType_RrasUninstalled);
// m_dwServiceStatus
// Set in FetchServerState();
// m_fLocalMachine
m_fLocalMachine = IsLocalMachine((LPCTSTR) pData->m_stMachineName);
return hrOK;
}
/*!--------------------------------------------------------------------------
MachineHandler::StartRasAdminExe
-
Author: MikeG (a-migall)
---------------------------------------------------------------------------*/
HRESULT MachineHandler::StartRasAdminExe(MachineNodeData *pData)
{
// Locals.
CString sRasAdminExePath;
CString stCommandLine;
LPTSTR pszRasAdminExe = NULL;
STARTUPINFO si;
PROCESS_INFORMATION pi;
HRESULT hr = S_OK;
UINT nCnt = 0;
DWORD cbAppCnt = 0;
// Check the handle to see if rasadmin is running
if (pData->m_hRasAdmin != INVALID_HANDLE_VALUE)
{
DWORD dwReturn = 0;
// If the state is not signalled, then the process has
// not exited (or some other occurred).
dwReturn = WaitForSingleObject(pData->m_hRasAdmin, 0);
if (dwReturn == WAIT_TIMEOUT)
{
// The process has not signalled (it's still running);
return hrOK;
}
else
{
// the process has signalled or the call failed, close the handle
// and call up RasAdmin
::CloseHandle(pData->m_hRasAdmin);
pData->m_hRasAdmin = INVALID_HANDLE_VALUE;
}
}
try
{
// Looks like the RasAdmin.Exe is not running on this
// workstation's desktop; so, start it!
// Figure out where the \\WinNt\System32 directory is.
pszRasAdminExe = sRasAdminExePath.GetBuffer(((MAX_PATH+1)*sizeof(TCHAR)));
nCnt = ::GetSystemDirectory(pszRasAdminExe, MAX_PATH);
sRasAdminExePath.ReleaseBuffer();
if (nCnt == 0)
throw (HRESULT_FROM_WIN32(::GetLastError()));
// Complete the construction of the executable's name.
sRasAdminExePath += _T("\\rasadmin.exe");
Assert(!::IsBadStringPtr((LPCTSTR)sRasAdminExePath,
sRasAdminExePath.GetLength()));
// Build command line string
stCommandLine.Format(_T("%s \\\\%s"),
(LPCTSTR) sRasAdminExePath,
(LPCTSTR) pData->m_stMachineName);
// Start RasAdmin.Exe.
::ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwX = si.dwY = si.dwXSize = si.dwYSize = 0L;
si.wShowWindow = SW_SHOW;
::ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
if (!::CreateProcess(NULL, // pointer to name of executable module
(LPTSTR) (LPCTSTR) stCommandLine, // pointer to command line string
NULL, // process security attributes
NULL, // thread security attributes
FALSE, // handle inheritance flag
CREATE_NEW_CONSOLE, // creation flags
NULL, // pointer to new environment block
NULL, // pointer to current directory name
&si, // pointer to STARTUPINFO
&pi)) // pointer to PROCESS_INFORMATION
{
hr = HRESULT_FROM_WIN32(::GetLastError());
::CloseHandle(pi.hProcess);
}
else
{
Assert(pData->m_hRasAdmin == INVALID_HANDLE_VALUE);
pData->m_hRasAdmin = pi.hProcess;
}
::CloseHandle(pi.hThread);
//
// OPT: Maybe we should have used the ShellExecute() API rather than
// the CreateProcess() API. Why? The ShellExecute() API will
// give the shell the opportunity to check the current user's
// system policy settings before allowing the executable to execute.
//
}
catch (CException * e)
{
hr = E_OUTOFMEMORY;
}
catch (HRESULT hrr)
{
hr = hrr;
}
catch (...)
{
hr = E_UNEXPECTED;
}
//Assert(SUCCEEDED(hr));
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::OnResultShow
-
Author: MikeG (a-migall)
---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnResultShow(ITFSComponent *pComponent,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM lParam)
{
BOOL bSelect = static_cast<BOOL>(arg);
HRESULT hr = hrOK;
SPITFSNode spNode;
MachineNodeData * pData = NULL;
hr = BaseRouterHandler::OnResultShow(pComponent, cookie, arg, lParam);
if (bSelect)
{
m_spNodeMgr->FindNode(cookie, &spNode);
// We need the machine node data.
// ------------------------------------------------------------
pData = GET_MACHINENODEDATA(spNode);
if (pData->m_routerType == ServerType_Ras)
hr = StartRasAdminExe(pData);
else if ((pData->m_machineState == machine_access_denied) ||
(pData->m_machineState == machine_bad_net_path))
{
// Try to connect again
// --------------------------------------------------------
if (m_fTryToConnect)
OnExpand(spNode, NULL, 0, 0, 0);
// If we have failed, keep on trucking!
// --------------------------------------------------------
m_fTryToConnect = TRUE;
}
}
return hr;
}
/*!--------------------------------------------------------------------------
MachineHandler::OnDelete
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT MachineHandler::OnDelete(ITFSNode *pNode,
LPARAM arg,
LPARAM param)
{
SPITFSNode spNode;
SPITFSNode spStatusNode;
SPITFSNodeHandler spHoldHandler;
SPITFSNode spParent;
SPITFSNode spGrandParent;
SPITFSNode spthis;
SPITFSNode spMachineNode;
DMVNodeData* pData;
MachineNodeData * pMachineData = NULL;
MachineNodeData * pNodeData = NULL;
SPITFSNodeEnum spNodeEnum;
SPITFSNode spResultNode;
MMC_COOKIE cookie;
// This will be the machine node, in the scope pane, that
// we wish to delete.
Assert(pNode);
cookie = pNode->GetData(TFS_DATA_COOKIE);
// Addref this node so that it won't get deleted before we're out
// of this function
spHoldHandler.Set( this );
spthis.Set( pNode );
pNode->GetParent( &spParent );
Assert( spParent );
// Given this node, find the node in the result pane that
// corresponds to this scope node.
// Iterate through the nodes of our parent node to find the
// server status node.
// ----------------------------------------------------------------
spParent->GetEnum(&spNodeEnum);
while (spNodeEnum->Next(1, &spStatusNode, NULL) == hrOK)
{
if ((*spStatusNode->GetNodeType()) == GUID_DomainStatusNodeType)
break;
spStatusNode.Release();
}
Assert(spStatusNode != NULL);
// Now iterate through the status node to find the appropriate
// machine.
// ----------------------------------------------------------------
spNodeEnum.Release();
spStatusNode->GetEnum(&spNodeEnum);
while (spNodeEnum->Next(1, &spResultNode, NULL) == hrOK)
{
pData = GET_DMVNODEDATA( spResultNode );
Assert( pData );
pMachineData = pData->m_spMachineData;
if (pMachineData->m_cookie == cookie)
break;
spResultNode.Release();
}
// Note: if the server status node has not been expanded yet
// we could hit this case.
// ----------------------------------------------------------------
if (pMachineData && (pMachineData->m_cookie == cookie))
{
// fetch & delete server node (the node in the result pane)
spStatusNode->RemoveChild( spResultNode );
spResultNode.Release();
}
else
{
// If this is the case, we need to remove the server from
// the list before it is expanded.
// ------------------------------------------------------------
SPITFSNodeHandler spHandler;
spParent->GetHandler(&spHandler);
// Get the node data (for this specific machine node)
// ------------------------------------------------------------
pNodeData = GET_MACHINENODEDATA(pNode);
spHandler->UserNotify(spParent,
DMV_DELETE_SERVER_ENTRY,
(LPARAM) (LPCTSTR) pNodeData->m_stMachineName
);
}
// delete the machine node (the node in the scope pane)
spParent->RemoveChild( pNode );
return hrOK;
}
STDMETHODIMP MachineHandler::UserNotify(ITFSNode *pNode, LPARAM lParam, LPARAM lParam2)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
switch (lParam)
{
case MACHINE_SYNCHRONIZE_ICON:
{
SynchronizeIcon(pNode);
}
break;
default:
hr = BaseRouterHandler::UserNotify(pNode, lParam, lParam2);
break;
}
}
COM_PROTECT_CATCH;
return hr;
}
Copy Permalink