You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1160 lines
34 KiB
1160 lines
34 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
root.cpp
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "root.h"
|
|
#include "server.h"
|
|
#include "tregkey.h"
|
|
#include "service.h"
|
|
#include "ncglobal.h" // network console global defines
|
|
#include "addserv.h"
|
|
|
|
unsigned int g_cfMachineName = RegisterClipboardFormat(L"MMC_SNAPIN_MACHINE_NAME");
|
|
|
|
LPOLESTR g_RootTaskOverBitmaps[ROOT_TASK_MAX] =
|
|
{
|
|
L"/wlcmroll.bmp",
|
|
L"/srvrroll.bmp",
|
|
};
|
|
|
|
LPOLESTR g_RootTaskOffBitmaps[ROOT_TASK_MAX] =
|
|
{
|
|
L"/wlcm.bmp",
|
|
L"/srvr.bmp",
|
|
};
|
|
|
|
UINT g_RootTaskText[ROOT_TASK_MAX] =
|
|
{
|
|
IDS_ROOT_TASK_GETTING_STARTED,
|
|
IDS_ROOT_TASK_ADD_SERVER,
|
|
};
|
|
|
|
UINT g_RootTaskHelp[ROOT_TASK_MAX] =
|
|
{
|
|
IDS_ROOT_TASK_GETTING_STARTED_HELP,
|
|
IDS_ROOT_TASK_ADD_SERVER_HELP,
|
|
};
|
|
|
|
HRESULT
|
|
CRootTasks::Init(BOOL bExtension, BOOL bThisMachine, BOOL bNetServices)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
MMC_TASK mmcTask;
|
|
int nPos = 0;
|
|
int nFinish = ROOT_TASK_MAX;
|
|
|
|
m_arrayMouseOverBitmaps.SetSize(ROOT_TASK_MAX);
|
|
m_arrayMouseOffBitmaps.SetSize(ROOT_TASK_MAX);
|
|
m_arrayTaskText.SetSize(ROOT_TASK_MAX);
|
|
m_arrayTaskHelp.SetSize(ROOT_TASK_MAX);
|
|
|
|
// setup path for reuse
|
|
OLECHAR szBuffer[MAX_PATH*2]; // that should be enough
|
|
lstrcpy (szBuffer, L"res://");
|
|
::GetModuleFileName(_Module.GetModuleInstance(), szBuffer + lstrlen(szBuffer), MAX_PATH);
|
|
OLECHAR * temp = szBuffer + lstrlen(szBuffer);
|
|
|
|
if (bExtension)
|
|
nPos = ROOT_TASK_MAX;
|
|
/*
|
|
if (bExtension && bThisMachine)
|
|
{
|
|
nPos = ROOT_TASK_MAX - 2;
|
|
nFinish = ROOT_TASK_MAX - 1;
|
|
}
|
|
else
|
|
if (bExtension && bNetServices)
|
|
{
|
|
nPos = ROOT_TASK_MAX - 1;
|
|
nFinish = ROOT_TASK_MAX;
|
|
}
|
|
*/
|
|
|
|
for (nPos; nPos < nFinish; nPos++)
|
|
{
|
|
m_arrayMouseOverBitmaps[nPos] = szBuffer;
|
|
m_arrayMouseOffBitmaps[nPos] = szBuffer;
|
|
m_arrayMouseOverBitmaps[nPos] += g_RootTaskOverBitmaps[nPos];
|
|
m_arrayMouseOffBitmaps[nPos] += g_RootTaskOffBitmaps[nPos];
|
|
|
|
m_arrayTaskText[nPos].LoadString(g_RootTaskText[nPos]);
|
|
m_arrayTaskHelp[nPos].LoadString(g_RootTaskHelp[nPos]);
|
|
|
|
AddTask((LPTSTR) (LPCTSTR) m_arrayMouseOverBitmaps[nPos],
|
|
(LPTSTR) (LPCTSTR) m_arrayMouseOffBitmaps[nPos],
|
|
(LPTSTR) (LPCTSTR) m_arrayTaskText[nPos],
|
|
(LPTSTR) (LPCTSTR) m_arrayTaskHelp[nPos],
|
|
MMC_ACTION_ID,
|
|
nPos);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::CIpsmRootHandler
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
CIpsmRootHandler::CIpsmRootHandler(ITFSComponentData *pCompData) : CIpsmHandler(pCompData)
|
|
{
|
|
//m_bTaskPadView = FUseTaskpadsByDefault(NULL);
|
|
m_bTaskPadView = FALSE;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::InitializeNode
|
|
Initializes node specific data
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::InitializeNode
|
|
(
|
|
ITFSNode * pNode
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
CString strTemp;
|
|
strTemp.LoadString(IDS_ROOT_NODENAME);
|
|
|
|
SetDisplayName(strTemp);
|
|
|
|
// Make the node immediately visible
|
|
//pNode->SetVisibilityState(TFS_VIS_SHOW);
|
|
pNode->SetData(TFS_DATA_COOKIE, 0);
|
|
pNode->SetData(TFS_DATA_IMAGEINDEX, ICON_IDX_PRODUCT);
|
|
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, ICON_IDX_PRODUCT);
|
|
pNode->SetData(TFS_DATA_USER, (LPARAM) this);
|
|
pNode->SetData(TFS_DATA_TYPE, IPSMSNAP_ROOT);
|
|
|
|
SetColumnStringIDs(&aColumns[IPSMSNAP_ROOT][0]);
|
|
SetColumnWidths(&aColumnWidths[IPSMSNAP_ROOT][0]);
|
|
|
|
m_strTaskpadTitle.LoadString(IDS_ROOT_TASK_TITLE);
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Overridden base handler functions
|
|
---------------------------------------------------------------------------*/
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::GetString
|
|
Implementation of ITFSNodeHandler::GetString
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP_(LPCTSTR)
|
|
CIpsmRootHandler::GetString
|
|
(
|
|
ITFSNode * pNode,
|
|
int nCol
|
|
)
|
|
{
|
|
if (nCol == 0 || nCol == -1)
|
|
return GetDisplayName();
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnExpand
|
|
Handles enumeration of a scope item
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::OnExpand
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DWORD dwType,
|
|
LPARAM arg,
|
|
LPARAM param
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
if (m_bExpanded)
|
|
return hr;
|
|
|
|
// do the default handling
|
|
hr = CIpsmHandler::OnExpand(pNode, pDataObject, dwType, arg, param);
|
|
|
|
if (dwType & TFS_COMPDATA_EXTENSION)
|
|
{
|
|
// we are extending somebody. Get the computer name and check that machine
|
|
hr = CheckMachine(pNode, pDataObject);
|
|
}
|
|
else
|
|
{
|
|
int iVisibleCount = 0;
|
|
int iTotalCount = 0;
|
|
|
|
pNode->GetChildCount(&iVisibleCount, &iTotalCount);
|
|
|
|
if (0 == iTotalCount)
|
|
{
|
|
// check to see if we need to add the local machine to the list
|
|
hr = CheckMachine(pNode, NULL);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnAddMenuItems
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::OnAddMenuItems
|
|
(
|
|
ITFSNode * pNode,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
LPDATAOBJECT lpDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType,
|
|
long * pInsertionAllowed
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = S_OK;
|
|
CString strMenuItem;
|
|
|
|
if (type == CCT_SCOPE)
|
|
{
|
|
// these menu items go in the new menu,
|
|
// only visible from scope pane
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_TOP)
|
|
{
|
|
#if 0
|
|
/* TODO: Re-enable when iterface needs to be remoteable */
|
|
strMenuItem.LoadString(IDS_ADD_MACHINE);
|
|
hr = LoadAndAddMenuItem( pContextMenuCallback,
|
|
strMenuItem,
|
|
IDS_ADD_MACHINE,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0 );
|
|
#endif //0
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnCommand
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::OnCommand
|
|
(
|
|
ITFSNode * pNode,
|
|
long nCommandId,
|
|
DATA_OBJECT_TYPES type,
|
|
LPDATAOBJECT pDataObject,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
switch (nCommandId)
|
|
{
|
|
case IDS_ADD_MACHINE:
|
|
OnAddMachine(pNode);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::AddMenuItems
|
|
Over-ride this to add our view menu item
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::AddMenuItems
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObject,
|
|
LPCONTEXTMENUCALLBACK pContextMenuCallback,
|
|
long * pInsertionAllowed
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = S_OK;
|
|
CString strMenuItem;
|
|
/*
|
|
if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW)
|
|
{
|
|
strMenuItem.LoadString(IDS_VIEW_TASKPAD);
|
|
hr = LoadAndAddMenuItem( pContextMenuCallback,
|
|
strMenuItem,
|
|
IDS_VIEW_TASKPAD,
|
|
CCM_INSERTIONPOINTID_PRIMARY_VIEW,
|
|
(m_bTaskPadView) ? MF_CHECKED : 0 );
|
|
}
|
|
*/
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::Command
|
|
Handles commands for the current view
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::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:
|
|
m_bTaskPadView = FALSE;
|
|
break;
|
|
|
|
case IDS_VIEW_TASKPAD:
|
|
{
|
|
// if we are not viewing the taskpad presently, re-select the node
|
|
// so that the taskpad is visible
|
|
SPIConsole spConsole;
|
|
SPITFSNode spNode;
|
|
|
|
m_bTaskPadView = !m_bTaskPadView;
|
|
|
|
m_spResultNodeMgr->FindNode(cookie, &spNode);
|
|
m_spTFSCompData->GetConsole(&spConsole);
|
|
spConsole->SelectScopeItem(spNode->GetData(TFS_DATA_SCOPEID));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::HasPropertyPages
|
|
Implementation of ITFSNodeHandler::HasPropertyPages
|
|
NOTE: the root node handler has to over-ride this function to
|
|
handle the snapin manager property page (wizard) case!!!
|
|
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::HasPropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataObject,
|
|
DATA_OBJECT_TYPES type,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
|
|
if (dwType & TFS_COMPDATA_CREATE)
|
|
{
|
|
// This is the case where we are asked to bring up property
|
|
// pages when the user is adding a new snapin. These calls
|
|
// are forwarded to the root node to handle.
|
|
hr = hrFalse;
|
|
}
|
|
else
|
|
{
|
|
// we have property pages in the normal case
|
|
hr = hrFalse;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::CreatePropertyPages
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::CreatePropertyPages
|
|
(
|
|
ITFSNode * pNode,
|
|
LPPROPERTYSHEETCALLBACK lpProvider,
|
|
LPDATAOBJECT pDataObject,
|
|
LONG_PTR handle,
|
|
DWORD dwType
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = hrOK;
|
|
HPROPSHEETPAGE hPage;
|
|
|
|
Assert(pNode->GetData(TFS_DATA_COOKIE) == 0);
|
|
|
|
if (dwType & TFS_COMPDATA_CREATE)
|
|
{
|
|
//
|
|
// We are loading this snapin for the first time, put up a property
|
|
// page to allow them to name this thing.
|
|
//
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Object gets deleted when the page is destroyed
|
|
//
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnPropertyChange
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::OnPropertyChange
|
|
(
|
|
ITFSNode * pNode,
|
|
LPDATAOBJECT pDataobject,
|
|
DWORD dwType,
|
|
LPARAM arg,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::TaskPadNotify
|
|
-
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::TaskPadNotify
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObject,
|
|
VARIANT * arg,
|
|
VARIANT * param
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
if (arg->vt == VT_I4)
|
|
{
|
|
switch (arg->lVal)
|
|
{
|
|
case ROOT_TASK_GETTING_STARTED:
|
|
{
|
|
SPIDisplayHelp spDisplayHelp;
|
|
SPIConsole spConsole;
|
|
|
|
pComponent->GetConsole(&spConsole);
|
|
|
|
HRESULT hr = spConsole->QueryInterface (IID_IDisplayHelp, (LPVOID*) &spDisplayHelp);
|
|
ASSERT (SUCCEEDED (hr));
|
|
if ( SUCCEEDED (hr) )
|
|
{
|
|
LPCTSTR pszHelpFile = m_spTFSCompData->GetHTMLHelpFileName();
|
|
if (pszHelpFile == NULL)
|
|
break;
|
|
|
|
CString szHelpFilePath;
|
|
UINT nLen = ::GetWindowsDirectory (szHelpFilePath.GetBufferSetLength(2 * MAX_PATH), 2 * MAX_PATH);
|
|
if (nLen == 0)
|
|
return E_FAIL;
|
|
|
|
szHelpFilePath.ReleaseBuffer();
|
|
szHelpFilePath += g_szDefaultHelpTopic;
|
|
|
|
hr = spDisplayHelp->ShowTopic (T2OLE ((LPTSTR)(LPCTSTR) szHelpFilePath));
|
|
ASSERT (SUCCEEDED (hr));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ROOT_TASK_ADD_SERVER:
|
|
{
|
|
SPITFSNode spNode;
|
|
|
|
m_spResultNodeMgr->FindNode(cookie, &spNode);
|
|
OnAddMachine(spNode);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Panic1("CIpsmRootHandler::TaskPadNotify - Unrecognized command! %d", arg->lVal);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CBaseResultHandler::EnumTasks
|
|
-
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::EnumTasks
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPDATAOBJECT pDataObject,
|
|
LPOLESTR pszTaskGroup,
|
|
IEnumTASK ** ppEnumTask
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = hrOK;
|
|
CRootTasks * pTasks = NULL;
|
|
SPIEnumTask spEnumTasks;
|
|
SPINTERNAL spInternal = ExtractInternalFormat(pDataObject);
|
|
BOOL bExtension = FALSE;
|
|
BOOL bAddThisMachineTasks = FALSE;
|
|
BOOL bAddNetServicesTasks = FALSE;
|
|
const CLSID * pNodeClsid = &CLSID_IpsmSnapin;
|
|
CString strMachineGroup = NETCONS_ROOT_THIS_MACHINE;
|
|
CString strNetServicesGroup = NETCONS_ROOT_NET_SERVICES;
|
|
|
|
if ((spInternal == NULL) || (*pNodeClsid != spInternal->m_clsid))
|
|
bExtension = TRUE;
|
|
|
|
if (bExtension &&
|
|
strMachineGroup.CompareNoCase(pszTaskGroup) == 0)
|
|
{
|
|
// There are multiple taskpad groups in the network console
|
|
// we need to make sure we are extending the correct one.
|
|
bAddThisMachineTasks = TRUE;
|
|
}
|
|
|
|
if (bExtension &&
|
|
strNetServicesGroup.CompareNoCase(pszTaskGroup) == 0)
|
|
{
|
|
// There are multiple taskpad groups in the network console
|
|
// we need to make sure we are extending the correct one.
|
|
bAddNetServicesTasks = TRUE;
|
|
}
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
pTasks = new CRootTasks();
|
|
spEnumTasks = pTasks;
|
|
|
|
if (!(bExtension && !bAddThisMachineTasks && !bAddNetServicesTasks))
|
|
CORg (pTasks->Init(bExtension, bAddThisMachineTasks, bAddNetServicesTasks));
|
|
|
|
CORg (pTasks->QueryInterface (IID_IEnumTASK, (void **)ppEnumTask));
|
|
|
|
COM_PROTECT_ERROR_LABEL;
|
|
}
|
|
COM_PROTECT_CATCH
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::TaskPadGetTitle
|
|
-
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP
|
|
CIpsmRootHandler::TaskPadGetTitle
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPOLESTR pszGroup,
|
|
LPOLESTR * ppszTitle
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
if (ppszTitle == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
}
|
|
|
|
*ppszTitle = (LPOLESTR) CoTaskMemAlloc (sizeof(OLECHAR)*
|
|
(lstrlen(m_strTaskpadTitle)+1));
|
|
if (*ppszTitle == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
}
|
|
|
|
lstrcpy (*ppszTitle, m_strTaskpadTitle);
|
|
|
|
error:
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnGetResultViewType
|
|
Return the result view that this node is going to support
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::OnGetResultViewType
|
|
(
|
|
ITFSComponent * pComponent,
|
|
MMC_COOKIE cookie,
|
|
LPOLESTR * ppViewType,
|
|
long * pViewOptions
|
|
)
|
|
{
|
|
// if we aren't displaying the taskpad, use the default stuff...
|
|
if (!m_bTaskPadView)
|
|
return CIpsmHandler::OnGetResultViewType(pComponent, cookie, ppViewType, pViewOptions);
|
|
|
|
//TODO Should we keep that?
|
|
//
|
|
// In this code we are defaulting to a taskpad view for this node all the time.
|
|
// It is the snapins responsibility to put up a view menu selection that has a
|
|
// selection for the taskpad. Do that in AddMenuItems.
|
|
//
|
|
//
|
|
// We will use the default DHTML provided by MMC. It actually resides as a
|
|
// resource inside MMC.EXE. We just get the path to it and use that.
|
|
// The one piece of magic here is the text following the '#'. That is the special
|
|
// way we have of identifying they taskpad we are talking about. Here we say we are
|
|
// wanting to show a taskpad that we refer to as "CMTP1". We will actually see this
|
|
// string pass back to us later. If someone is extending our taskpad, they also need
|
|
// to know what this secret string is.
|
|
//
|
|
*pViewOptions = MMC_VIEW_OPTIONS_NONE;
|
|
OLECHAR szBuffer[MAX_PATH*2]; // a little extra
|
|
|
|
lstrcpy (szBuffer, L"res://");
|
|
OLECHAR * temp = szBuffer + lstrlen(szBuffer);
|
|
|
|
//TODO need to hook up the ipsecmon help file
|
|
// get "res://"-type string for custom taskpad
|
|
// the string after the # gets handed back to us in future calls...
|
|
// should be unique for each node
|
|
::GetModuleFileName (NULL, temp, MAX_PATH);
|
|
lstrcat (szBuffer, L"/default.htm#TAPIROOT");
|
|
|
|
// alloc and copy bitmap resource string
|
|
*ppViewType = (LPOLESTR)CoTaskMemAlloc (sizeof(OLECHAR)*(lstrlen(szBuffer)+1));
|
|
|
|
if (!*ppViewType)
|
|
return E_OUTOFMEMORY; // or S_FALSE ???
|
|
|
|
lstrcpy (*ppViewType, szBuffer);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnResultSelect
|
|
For nodes with task pads, we override the select message to set
|
|
the selected node. Nodes with taskpads do not get the MMCN_SHOW
|
|
message which is where we normall set the selected node
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT CIpsmRootHandler::OnResultSelect(ITFSComponent *pComponent, LPDATAOBJECT pDataObject, MMC_COOKIE cookie, LPARAM arg, LPARAM lParam)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
CORg(DoTaskpadResultSelect(pComponent, pDataObject, cookie, arg, lParam, m_bTaskPadView));
|
|
|
|
CORg(CIpsmHandler::OnResultSelect(pComponent, pDataObject, cookie, arg, lParam));
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
Command handlers
|
|
---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::OnAddMachine
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::OnAddMachine
|
|
(
|
|
ITFSNode * pNode
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = hrOK;
|
|
|
|
/*
|
|
GETCOMPUTERSELECTIONINFO info;
|
|
PDSSELECTIONLIST pSelList = NULL;
|
|
|
|
LPCTSTR attrs[] = {_T("dNSHostName")};
|
|
|
|
ZeroMemory(&info, sizeof(GETCOMPUTERSELECTIONINFO));
|
|
info.cbSize = sizeof(GETCOMPUTERSELECTIONINFO);
|
|
info.hwndParent = FindMMCMainWindow();
|
|
info.flObjectPicker = 0; // not allow multiple selection
|
|
info.flDsObjectPicker = DSOP_SCOPE_DIRECTORY |
|
|
DSOP_SCOPE_DOMAIN_TREE |
|
|
DSOP_SCOPE_EXTERNAL_TRUSTED_DOMAINS;
|
|
info.flStartingScope = DSOP_SCOPE_DIRECTORY;
|
|
info.ppDsSelList = &pSelList;
|
|
info.cRequestedAttributes = 1;
|
|
info.aptzRequestedAttributes = attrs;
|
|
|
|
hr = GetComputerSelection(&info);
|
|
if(hr != S_OK) // assume the API will display error message, if there is
|
|
return hr;
|
|
|
|
CString strTemp = pSelList->aDsSelection[0].pwzName;
|
|
if (strTemp.Left(2) == _T("\\\\"))
|
|
strTemp = pSelList->aDsSelection[0].pwzName[2];
|
|
*/
|
|
|
|
CAddServ dlgAddServ(CWnd::FromHandle(FindMMCMainWindow()));
|
|
if (IDOK != dlgAddServ.DoModal())
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
CString strTemp = dlgAddServ.m_stComputerName;
|
|
|
|
// if the machine is already in the list, don't bother.
|
|
if (IsServerInList(pNode, strTemp))
|
|
{
|
|
AfxMessageBox(IDS_ERR_SERVER_IN_LIST);
|
|
}
|
|
else
|
|
{
|
|
AddServer(_T(""), strTemp, TRUE, IPSMSNAP_OPTIONS_REFRESH, IPSECMON_REFRESH_INTERVAL_DEFAULT);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::AddServer
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::AddServer
|
|
(
|
|
LPCWSTR pServerIp,
|
|
LPCTSTR pServerName,
|
|
BOOL bNewServer,
|
|
DWORD dwServerOptions,
|
|
DWORD dwRefreshInterval,
|
|
BOOL bExtension,
|
|
DWORD dwLineBuffSize,
|
|
DWORD dwPhoneBuffSize
|
|
)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
HRESULT hr = hrOK;
|
|
CIpsmServer * pServer = NULL;
|
|
SPITFSNodeHandler spHandler;
|
|
SPITFSNode spNode, spRootNode;
|
|
|
|
// Create a handler for the node
|
|
try
|
|
{
|
|
pServer = new CIpsmServer(m_spTFSCompData);
|
|
//pServer->SetName(pServerName);
|
|
|
|
// Do this so that it will get released correctly
|
|
spHandler = pServer;
|
|
}
|
|
catch(...)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
CORg( hr );
|
|
|
|
//
|
|
// Create the server container information
|
|
//
|
|
CreateContainerTFSNode(&spNode,
|
|
&GUID_IpsmServerNodeType,
|
|
pServer,
|
|
pServer,
|
|
m_spNodeMgr);
|
|
|
|
// Tell the handler to initialize any specific data
|
|
pServer->SetName(pServerName);
|
|
|
|
pServer->InitializeNode((ITFSNode *) spNode);
|
|
|
|
if (dwServerOptions & IPSMSNAP_OPTIONS_EXTENSION)
|
|
{
|
|
pServer->SetExtensionName();
|
|
}
|
|
|
|
// Mask out the auto refresh option because we set it next
|
|
pServer->SetOptions(dwServerOptions & ~IPSMSNAP_OPTIONS_REFRESH);
|
|
|
|
// if we got a valid refresh interval, then set it.
|
|
pServer->SetAutoRefresh(spNode, dwServerOptions & IPSMSNAP_OPTIONS_REFRESH, dwRefreshInterval);
|
|
|
|
pServer->SetDnsResolve(spNode, dwServerOptions & IPSMSNAP_OPTIONS_DNS);
|
|
|
|
AddServerSortedName(spNode, bNewServer);
|
|
|
|
if (bNewServer)
|
|
{
|
|
// need to get our node descriptor
|
|
CORg(m_spNodeMgr->GetRootNode(&spRootNode));
|
|
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
|
|
}
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::IsServerInList
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
BOOL
|
|
CIpsmRootHandler::IsServerInList
|
|
(
|
|
ITFSNode * pRootNode,
|
|
LPCTSTR pszMachineName
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
ULONG nNumReturned = 0;
|
|
DWORD dwIpAddressCurrent;
|
|
BOOL bFound = FALSE;
|
|
CString strNewName = pszMachineName;
|
|
|
|
// get the enumerator for this node
|
|
pRootNode->GetEnum(&spNodeEnum);
|
|
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
while (nNumReturned)
|
|
{
|
|
// walk the list of servers and see if it already exists
|
|
CIpsmServer * pServer = GETHANDLER(CIpsmServer, spCurrentNode);
|
|
if (strNewName.CompareNoCase(pServer->GetName()) == 0)
|
|
{
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
|
|
// get the next Server in the list
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
}
|
|
|
|
return bFound;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::AddServerSortedIp
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::AddServerSortedIp
|
|
(
|
|
ITFSNode * pNewNode,
|
|
BOOL bNewServer
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
SPITFSNode spPrevNode;
|
|
SPITFSNode spRootNode;
|
|
ULONG nNumReturned = 0;
|
|
DWORD dwIpAddressCurrent = 0;
|
|
DWORD dwIpAddressTarget;
|
|
|
|
CIpsmServer * pServer;
|
|
|
|
// get our target address
|
|
pServer = GETHANDLER(CIpsmServer, pNewNode);
|
|
//pServer->GetIpAddress(&dwIpAddressTarget);
|
|
|
|
// need to get our node descriptor
|
|
CORg(m_spNodeMgr->GetRootNode(&spRootNode));
|
|
|
|
// get the enumerator for this node
|
|
CORg(spRootNode->GetEnum(&spNodeEnum));
|
|
|
|
CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
|
|
while (nNumReturned)
|
|
{
|
|
// walk the list of servers and see if it already exists
|
|
pServer = GETHANDLER(CIpsmServer, spCurrentNode);
|
|
//pServer->GetIpAddress(&dwIpAddressCurrent);
|
|
|
|
//if (dwIpAddressCurrent > dwIpAddressTarget)
|
|
//{
|
|
// Found where we need to put it, break out
|
|
break;
|
|
//}
|
|
|
|
// get the next Server in the list
|
|
spPrevNode.Set(spCurrentNode);
|
|
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
}
|
|
|
|
// Add the node in based on the PrevNode pointer
|
|
if (spPrevNode)
|
|
{
|
|
if (bNewServer)
|
|
{
|
|
if (spPrevNode->GetData(TFS_DATA_SCOPEID) != NULL)
|
|
{
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
|
|
}
|
|
}
|
|
|
|
CORg(spRootNode->InsertChild(spPrevNode, pNewNode));
|
|
}
|
|
else
|
|
{
|
|
// add to the head
|
|
if (m_bExpanded)
|
|
{
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);
|
|
}
|
|
CORg(spRootNode->AddChild(pNewNode));
|
|
}
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::AddServerSortedName
|
|
Description
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::AddServerSortedName
|
|
(
|
|
ITFSNode * pNewNode,
|
|
BOOL bNewServer
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
SPITFSNode spPrevNode;
|
|
SPITFSNode spRootNode;
|
|
ULONG nNumReturned = 0;
|
|
CString strTarget, strCurrent;
|
|
|
|
CIpsmServer * pServer;
|
|
|
|
// get our target address
|
|
pServer = GETHANDLER(CIpsmServer, pNewNode);
|
|
strTarget = pServer->GetName();
|
|
|
|
// need to get our node descriptor
|
|
CORg(m_spNodeMgr->GetRootNode(&spRootNode));
|
|
|
|
// get the enumerator for this node
|
|
CORg(spRootNode->GetEnum(&spNodeEnum));
|
|
|
|
CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
|
|
while (nNumReturned)
|
|
{
|
|
// walk the list of servers and see if it already exists
|
|
pServer = GETHANDLER(CIpsmServer, spCurrentNode);
|
|
strCurrent = pServer->GetName();
|
|
|
|
if (strTarget.Compare(strCurrent) < 0)
|
|
{
|
|
// Found where we need to put it, break out
|
|
break;
|
|
}
|
|
|
|
// get the next Server in the list
|
|
spPrevNode.Set(spCurrentNode);
|
|
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
}
|
|
|
|
// Add the node in based on the PrevNode pointer
|
|
if (spPrevNode)
|
|
{
|
|
if (bNewServer)
|
|
{
|
|
if (spPrevNode->GetData(TFS_DATA_SCOPEID) != NULL)
|
|
{
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_PREVIOUS);
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_SCOPEID, spPrevNode->GetData(TFS_DATA_SCOPEID));
|
|
}
|
|
}
|
|
|
|
CORg(spRootNode->InsertChild(spPrevNode, pNewNode));
|
|
}
|
|
else
|
|
{
|
|
// add to the head
|
|
if (m_bExpanded)
|
|
{
|
|
pNewNode->SetData(TFS_DATA_RELATIVE_FLAGS, SDI_FIRST);
|
|
}
|
|
CORg(spRootNode->AddChild(pNewNode));
|
|
}
|
|
|
|
Error:
|
|
return hr;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CIpsmRootHandler::CheckMachine
|
|
adds the machine to the list of servers.
|
|
Author: NSun
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CIpsmRootHandler::CheckMachine
|
|
(
|
|
ITFSNode * pRootNode,
|
|
LPDATAOBJECT pDataObject
|
|
)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
|
|
// Get the local machine name and check to see if the service
|
|
// is installed.
|
|
CString strMachineName;
|
|
LPTSTR pBuf;
|
|
DWORD dwLength = MAX_COMPUTERNAME_LENGTH + 1;
|
|
BOOL bExtension = (pDataObject != NULL);
|
|
|
|
if (!bExtension)
|
|
{
|
|
pBuf = strMachineName.GetBuffer(dwLength);
|
|
GetComputerName(pBuf, &dwLength);
|
|
strMachineName.ReleaseBuffer();
|
|
}
|
|
else
|
|
{
|
|
strMachineName = Extract<TCHAR>(pDataObject, (CLIPFORMAT) g_cfMachineName, COMPUTERNAME_LEN_MAX);
|
|
}
|
|
|
|
if (strMachineName.IsEmpty())
|
|
{
|
|
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
|
|
LPTSTR pBuf = strMachineName.GetBuffer(dwSize);
|
|
|
|
::GetComputerName(pBuf, &dwSize);
|
|
|
|
strMachineName.ReleaseBuffer();
|
|
}
|
|
|
|
// if the machine is already in the list, don't bother.
|
|
if (IsServerInList(pRootNode, strMachineName))
|
|
return hr;
|
|
|
|
if (bExtension)
|
|
RemoveOldEntries(pRootNode, strMachineName);
|
|
|
|
// we always add the local machine or whatever machine we are pointed at even if
|
|
// we are an extension
|
|
|
|
// OK. add it to the list.
|
|
DWORD dwFlags = 0;
|
|
|
|
if (bExtension)
|
|
dwFlags |= IPSMSNAP_OPTIONS_EXTENSION;
|
|
|
|
dwFlags |= IPSMSNAP_OPTIONS_REFRESH;
|
|
|
|
AddServer(_T(""), strMachineName, TRUE, dwFlags, IPSECMON_REFRESH_INTERVAL_DEFAULT, bExtension);
|
|
return hr;
|
|
}
|
|
|
|
// when running as an extension, it is possible that we were saved as "local machine"
|
|
// which means that if the saved console file was moved to another machine we need to remove
|
|
// the old entry that was saved
|
|
HRESULT
|
|
CIpsmRootHandler::RemoveOldEntries(ITFSNode * pNode, LPCTSTR pszAddr)
|
|
{
|
|
HRESULT hr = hrOK;
|
|
SPITFSNodeEnum spNodeEnum;
|
|
SPITFSNode spCurrentNode;
|
|
ULONG nNumReturned = 0;
|
|
CIpsmServer * pServer;
|
|
CString strCurAddr;
|
|
|
|
// get the enumerator for this node
|
|
CORg(pNode->GetEnum(&spNodeEnum));
|
|
|
|
CORg(spNodeEnum->Next(1, &spCurrentNode, &nNumReturned));
|
|
while (nNumReturned)
|
|
{
|
|
// walk the list of servers and see if it already exists
|
|
pServer = GETHANDLER(CIpsmServer, spCurrentNode);
|
|
|
|
strCurAddr = pServer->GetName();
|
|
|
|
if (strCurAddr.CompareNoCase(pszAddr) != 0)
|
|
{
|
|
CORg (pNode->RemoveChild(spCurrentNode));
|
|
}
|
|
|
|
spCurrentNode.Release();
|
|
spNodeEnum->Next(1, &spCurrentNode, &nNumReturned);
|
|
}
|
|
|
|
Error:
|
|
return hr;
|
|
}
|