able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/mprsnap/iface.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1630 lines
43 KiB
C++
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
IFadmin
Interface node information
FILE HISTORY:
*/
#include "stdafx.h"
#include "ifadmin.h" // need to use node data
#include "iface.h"
#include "raserror.h"
#include "rtrres.h" // common router resources
#include "column.h" // ComponentConfigStream
#include "mprfltr.h"
#include "rtrutilp.h"
#include "rtrui.h" // for IsWanInterface
#include "dmvcomp.h"
#include "timeofday.h" // for timeofday dialog
#include "dumbprop.h" // dummy property page
InterfaceNodeData::InterfaceNodeData()
: lParamPrivate(0)
{
#ifdef DEBUG
StrCpyA(m_szDebug, "InterfaceNodeData");
#endif
}
InterfaceNodeData::~InterfaceNodeData()
{
}
HRESULT InterfaceNodeData::Init(ITFSNode *pNode, IInterfaceInfo *pIf)
{
HRESULT hr = hrOK;
InterfaceNodeData * pData = NULL;
pData = new InterfaceNodeData;
pData->spIf.Set(pIf);
SET_INTERFACENODEDATA(pNode, pData);
return hr;
}
HRESULT InterfaceNodeData::Free(ITFSNode *pNode)
{
InterfaceNodeData * pData = GET_INTERFACENODEDATA(pNode);
pData->spIf.Release();
delete pData;
SET_INTERFACENODEDATA(pNode, NULL);
return hrOK;
}
/*---------------------------------------------------------------------------
InterfaceNodeHandler implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(InterfaceNodeHandler)
IMPLEMENT_ADDREF_RELEASE(InterfaceNodeHandler)
STDMETHODIMP InterfaceNodeHandler::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 CBaseResultHandler::QueryInterface(riid, ppv);
// If we're going to return an interface, AddRef it first
if (*ppv)
{
((LPUNKNOWN) *ppv)->AddRef();
return hrOK;
}
else
return E_NOINTERFACE;
}
/*---------------------------------------------------------------------------
NodeHandler implementation
---------------------------------------------------------------------------*/
InterfaceNodeHandler::InterfaceNodeHandler(ITFSComponentData *pCompData)
: BaseRouterHandler(pCompData),
m_ulConnId(0)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(InterfaceNodeHandler);
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::Init
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::Init(IInterfaceInfo *pIfInfo, ITFSNode *pParent)
{
SPIRouterInfo spRouter;
SRouterNodeMenu menuData;
Assert(pIfInfo);
m_spInterfaceInfo.Set(pIfInfo);
pIfInfo->GetParentRouterInfo(&spRouter);
m_spRouterInfo.Set(spRouter);
// Also need to register for change notifications
// ----------------------------------------------------------------
m_spInterfaceInfo->RtrAdvise(&m_IRtrAdviseSink, &m_ulConnId, 0);
m_pIfAdminData = GET_IFADMINNODEDATA(pParent);
// Setup the verb states
// ----------------------------------------------------------------
// Always enable refresh
// ----------------------------------------------------------------
m_rgButtonState[MMC_VERB_REFRESH_INDEX] = ENABLED;
m_bState[MMC_VERB_REFRESH_INDEX] = TRUE;
// Need to enable properties only for certain cases
// ----------------------------------------------------------------
if (IsWanInterface(m_spInterfaceInfo->GetInterfaceType()))
{
m_rgButtonState[MMC_VERB_DELETE_INDEX] = ENABLED;
m_bState[MMC_VERB_DELETE_INDEX] = TRUE;
m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
m_bState[MMC_VERB_PROPERTIES_INDEX] = TRUE;
m_verbDefault = MMC_VERB_PROPERTIES;
}
else
{
// Windows NT Bugs : 206524
// Need to add a special case for IP-in-IP tunnel
// Enable DELETE for the tunnel
if (m_spInterfaceInfo->GetInterfaceType() == ROUTER_IF_TYPE_TUNNEL1)
{
m_rgButtonState[MMC_VERB_DELETE_INDEX] = ENABLED;
m_bState[MMC_VERB_DELETE_INDEX] = TRUE;
}
m_rgButtonState[MMC_VERB_PROPERTIES_INDEX] = ENABLED;
m_bState[MMC_VERB_PROPERTIES_INDEX] = FALSE;
}
return hrOK;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::DestroyResultHandler
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceNodeHandler::DestroyResultHandler(MMC_COOKIE cookie)
{
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
InterfaceNodeData::Free(spNode);
m_pIfAdminData = NULL;
m_spInterfaceInfo->RtrUnadvise(m_ulConnId);
m_spInterfaceInfo.Release();
CHandler::DestroyResultHandler(cookie);
return hrOK;
}
static DWORD s_rgInterfaceImageMap[] =
{
ROUTER_IF_TYPE_HOME_ROUTER, IMAGE_IDX_WAN_CARD,
ROUTER_IF_TYPE_FULL_ROUTER, IMAGE_IDX_WAN_CARD,
ROUTER_IF_TYPE_CLIENT, IMAGE_IDX_WAN_CARD,
ROUTER_IF_TYPE_DEDICATED, IMAGE_IDX_LAN_CARD,
ROUTER_IF_TYPE_INTERNAL, IMAGE_IDX_LAN_CARD,
ROUTER_IF_TYPE_LOOPBACK, IMAGE_IDX_LAN_CARD,
-1, IMAGE_IDX_WAN_CARD, // sentinel value
};
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::ConstructNode
Initializes the Domain node (sets it up).
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::ConstructNode(ITFSNode *pNode, IInterfaceInfo *pIfInfo)
{
HRESULT hr = hrOK;
int i;
if (pNode == NULL)
return hrOK;
COM_PROTECT_TRY
{
// Need to initialize the data for the Domain node
// Find the right image index for this type of node
for (i=0; i<DimensionOf(s_rgInterfaceImageMap); i+=2)
{
if ((pIfInfo->GetInterfaceType() == s_rgInterfaceImageMap[i]) ||
(-1 == s_rgInterfaceImageMap[i]))
break;
}
pNode->SetData(TFS_DATA_IMAGEINDEX, s_rgInterfaceImageMap[i+1]);
pNode->SetData(TFS_DATA_OPENIMAGEINDEX, s_rgInterfaceImageMap[i+1]);
pNode->SetData(TFS_DATA_SCOPEID, 0);
pNode->SetData(TFS_DATA_COOKIE, reinterpret_cast<LONG_PTR>(pNode));
//$ Review: kennt, what are the different type of interfaces
// do we distinguish based on the same list as above? (i.e. the
// one for image indexes).
pNode->SetNodeType(&GUID_RouterLanInterfaceNodeType);
InterfaceNodeData::Init(pNode, pIfInfo);
}
COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::GetString
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) InterfaceNodeHandler::GetString(ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol)
{
Assert(m_spNodeMgr);
Assert(m_pIfAdminData);
SPITFSNode spNode;
InterfaceNodeData * pData;
ConfigStream * pConfig;
m_spNodeMgr->FindNode(cookie, &spNode);
Assert(spNode);
pData = GET_INTERFACENODEDATA(spNode);
Assert(pData);
pComponent->GetUserData((LONG_PTR *) &pConfig);
Assert(pConfig);
return pData->m_rgData[pConfig->MapColumnToSubitem(DM_COLUMNS_IFADMIN, nCol)].m_stData;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::CompareItems
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(int) InterfaceNodeHandler::CompareItems(ITFSComponent * pComponent,
MMC_COOKIE cookieA,
MMC_COOKIE cookieB,
int nCol)
{
return StriCmpW(GetString(pComponent, cookieA, nCol),
GetString(pComponent, cookieB, nCol));
}
static const SRouterNodeMenu s_rgIfNodeMenu[] =
{
{ IDS_MENU_SET_CREDENTIALS, InterfaceNodeHandler::GetRemoveIfMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_SEPARATOR, 0,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_CONNECT, InterfaceNodeHandler::GetConnectMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_DISCONNECT, InterfaceNodeHandler::GetConnectMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_SEPARATOR, 0,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_ENABLE, InterfaceNodeHandler::GetEnableMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_DISABLE, InterfaceNodeHandler::GetEnableMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_SEPARATOR, 0,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_UNREACHABILITY_REASON, InterfaceNodeHandler::GetUnreachMenuFlags,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_SEPARATOR, 0,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_DEMAND_DIAL_FILTERS, InterfaceNodeHandler::GetDDFiltersFlag,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
{ IDS_MENU_DIALIN_HOURS, InterfaceNodeHandler::GetDDFiltersFlag,
CCM_INSERTIONPOINTID_PRIMARY_TOP},
};
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::AddMenuItems
Implementation of ITFSNodeHandler::OnAddMenuItems
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceNodeHandler::AddMenuItems(ITFSComponent *pComponent,
MMC_COOKIE cookie,
LPDATAOBJECT lpDataObject,
LPCONTEXTMENUCALLBACK pContextMenuCallback,
long *pInsertionAllowed)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
SPITFSNode spNode;
InterfaceNodeHandler::SMenuData menuData;
COM_PROTECT_TRY
{
m_spNodeMgr->FindNode(cookie, &spNode);
// Now go through and add our menu items
menuData.m_spNode.Set(spNode);
menuData.m_fRouterIsRunning = (IsRouterServiceRunning(
m_spInterfaceInfo->GetMachineName(),
NULL) == hrOK);
hr = AddArrayOfMenuItems(spNode, s_rgIfNodeMenu,
DimensionOf(s_rgIfNodeMenu),
pContextMenuCallback,
*pInsertionAllowed,
reinterpret_cast<INT_PTR>(&menuData));
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::Command
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceNodeHandler::Command(ITFSComponent *pComponent,
MMC_COOKIE cookie,
int nCommandId,
LPDATAOBJECT pDataObject)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = S_OK;
SPITFSNode spNode;
SPITFSNode spNodeParent;
SPITFSNodeHandler spParentHandler;
COM_PROTECT_TRY
{
switch (nCommandId)
{
case IDS_MENU_SET_CREDENTIALS:
hr = OnSetCredentials();
break;
case IDS_MENU_CONNECT:
case IDS_MENU_DISCONNECT:
hr = OnConnectDisconnect(cookie,nCommandId);
break;
case IDS_MENU_ENABLE:
case IDS_MENU_DISABLE:
hr = OnEnableDisable(cookie, nCommandId);
break;
case IDS_MENU_UNREACHABILITY_REASON:
hr = OnUnreachabilityReason(cookie);
break;
case IDS_MENU_DEMAND_DIAL_FILTERS:
hr = OnDemandDialFilters(cookie);
break;
case IDS_MENU_DIALIN_HOURS:
hr = OnDialinHours(pComponent, cookie);
break;
default:
Panic0("InterfaceNodeHandler: Unknown menu command!");
break;
}
if (!FHrSucceeded(hr))
{
DisplayErrorMessage(NULL, hr);
}
}
COM_PROTECT_CATCH;
return hr;
}
ImplementEmbeddedUnknown(InterfaceNodeHandler, IRtrAdviseSink)
STDMETHODIMP InterfaceNodeHandler::EIRtrAdviseSink::OnChange(LONG_PTR ulConn,
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
InitPThis(InterfaceNodeHandler, IRtrAdviseSink);
HRESULT hr = hrOK;
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::GetRemoveIfMenuFlags
-
Author: KennT
---------------------------------------------------------------------------*/
ULONG InterfaceNodeHandler::GetRemoveIfMenuFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pUserData)
{
InterfaceNodeData * pNodeData;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
Assert(pNodeData);
ULONG ulType = pNodeData->spIf->GetInterfaceType();
if (!IsWanInterface(ulType) || (!pData->m_fRouterIsRunning))
return MF_GRAYED;
else
return 0;
}
ULONG InterfaceNodeHandler::GetEnableMenuFlags(const SRouterNodeMenu *pMenuData,
INT_PTR pUserData)
{
ULONG ulFlags;
InterfaceNodeData * pNodeData;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
Assert(pNodeData);
ulFlags = GetRemoveIfMenuFlags(pMenuData, pUserData);
if (pNodeData->spIf->IsInterfaceEnabled())
ulFlags |= pMenuData->m_sidMenu == IDS_MENU_ENABLE ? MF_GRAYED : 0;
else
ulFlags |= pMenuData->m_sidMenu == IDS_MENU_ENABLE ? 0 : MF_GRAYED;
return ulFlags;
}
ULONG InterfaceNodeHandler::GetConnectMenuFlags(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
ULONG ulFlags;
InterfaceNodeData * pNodeData;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
ulFlags = GetRemoveIfMenuFlags(pMenuData, pUserData);
pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
Assert(pNodeData);
if ((pNodeData->dwConnectionState == ROUTER_IF_STATE_DISCONNECTED) ||
(pNodeData->dwConnectionState == ROUTER_IF_STATE_UNREACHABLE))
{
ulFlags |= (pMenuData->m_sidMenu == IDS_MENU_CONNECT ? 0 : MF_GRAYED);
}
else
{
ulFlags |= (pMenuData->m_sidMenu == IDS_MENU_CONNECT ? MF_GRAYED : 0);
}
return ulFlags;
}
ULONG InterfaceNodeHandler::GetUnreachMenuFlags(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
ULONG ulFlags;
InterfaceNodeData * pNodeData;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
Assert(pNodeData);
return pNodeData->dwConnectionState == ROUTER_IF_STATE_UNREACHABLE ?
0 : MF_GRAYED;
}
ULONG InterfaceNodeHandler::GetDDFiltersFlag(const SRouterNodeMenu *pMenuData, INT_PTR pUserData)
{
InterfaceNodeData * pNodeData;
DWORD dwIfType;
SPIRouterInfo spRouter;
SMenuData * pData = reinterpret_cast<SMenuData *>(pUserData);
pNodeData = GET_INTERFACENODEDATA(pData->m_spNode);
Assert(pNodeData);
// For NT4 and NT5 Beta1, we didn't have DD filters
pNodeData->spIf->GetParentRouterInfo(&spRouter);
if (spRouter)
{
RouterVersionInfo routerVer;
spRouter->GetRouterVersionInfo(&routerVer);
if (routerVer.dwOsBuildNo <= 1717)
{
return 0xFFFFFFFF;
}
}
dwIfType = pNodeData->spIf->GetInterfaceType();
if (!IsWanInterface(dwIfType))
return 0xFFFFFFFF;
else
return 0;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnCreateDataObject
Implementation of ITFSResultHandler::OnCreateDataObject
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceNodeHandler::OnCreateDataObject(ITFSComponent *pComp,
MMC_COOKIE cookie,
DATA_OBJECT_TYPES type,
IDataObject **ppDataObject)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
CORg( CreateDataObjectFromInterfaceInfo(m_spInterfaceInfo,
type, cookie, m_spTFSCompData,
ppDataObject) );
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::CreatePropertyPages
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP InterfaceNodeHandler::CreatePropertyPages(
ITFSComponent * pComponent,
MMC_COOKIE cookie,
LPPROPERTYSHEETCALLBACK lpProvider,
LPDATAOBJECT pDataObject,
LONG_PTR handle)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
BOOL fIsServiceRunning;
DWORD dwErr;
IfAdminNodeData * pAdminData;
SPITFSNode spParent;
SPITFSNode spNode;
SPIConsole spConsole;
HWND hwndMain;
DWORD dwIfType;
CString stServiceDesc;
SPIComponentData spComponentData;
CDummyProperties * pProp;
// Bring up the RASDLG instead
// Start the service if the service is stopped
CORg( IsRouterServiceRunning(m_spInterfaceInfo->GetMachineName(), NULL) );
fIsServiceRunning = (hr == hrOK);
if (!fIsServiceRunning)
{
// Ask the user if they want to start the service
if (AfxMessageBox(IDS_PROMPT_SERVICESTART, MB_YESNO) != IDYES)
CWRg( ERROR_CANCELLED );
// Else start the service
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
dwErr = TFSStartService(m_spInterfaceInfo->GetMachineName(),
c_szRemoteAccess,
stServiceDesc);
if (dwErr != NO_ERROR)
{
CWRg( dwErr );
}
}
m_spNodeMgr->FindNode(cookie, &spNode);
spNode->GetParent(&spParent);
pAdminData = GET_IFADMINNODEDATA(spParent);
if (pAdminData->m_hInstRasDlg == NULL)
{
AfxMessageBox(IDS_ERR_EDITPBKLOCAL);
}
else
{
// First edit the phone book entry.
// Only for wan interfaces.
dwIfType = m_spInterfaceInfo->GetInterfaceType();
if (IsWanInterface(dwIfType))
{
pComponent->GetConsole(&spConsole);
spConsole->GetMainWindow(&hwndMain);
// First create the phone book entry.
RASENTRYDLG info;
CString sPhoneBook;
CString sRouter;
ZeroMemory( &info, sizeof(info) );
info.dwSize = sizeof(info);
info.hwndOwner = hwndMain;
info.dwFlags |= RASEDFLAG_NoRename;
TRACE0("RouterEntryDlg\n");
Assert(pAdminData->m_pfnRouterEntryDlg);
sRouter = m_spInterfaceInfo->GetMachineName();
IfAdminNodeHandler::GetPhoneBookPath(sRouter, &sPhoneBook);
BOOL bStatus = pAdminData->m_pfnRouterEntryDlg(
(LPTSTR)(LPCTSTR)sRouter,
(LPTSTR)(LPCTSTR)sPhoneBook,
(LPTSTR)(LPCTSTR)m_spInterfaceInfo->GetTitle(),
&info);
TRACE2("RouterEntryDlg=%f,e=%d\n", bStatus, info.dwError);
if (!bStatus)
{
if (info.dwError != NO_ERROR)
{
AfxMessageBox(IDS_ERR_UNABLETOCONFIGPBK);
}
}
else
{
//
// Inform DDM about changes to phonebook entry.
//
UpdateDDM( m_spInterfaceInfo );
}
}
}
Error:
CORg( m_spNodeMgr->GetComponentData(&spComponentData) );
pProp = new CDummyProperties(spNode, spComponentData, NULL);
hr = pProp->CreateModelessSheet(lpProvider, handle);
return hr;
}
STDMETHODIMP InterfaceNodeHandler::HasPropertyPages (
ITFSComponent *pComp,
MMC_COOKIE cookie,
LPDATAOBJECT pDataObject)
{
// Only provide "property pages" for WAN entries
// First edit the phone book entry.
// Only for wan interfaces.
DWORD dwIfType = m_spInterfaceInfo->GetInterfaceType();
if (IsWanInterface(dwIfType))
return hrOK;
else
return hrFalse;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnRemoveInterface
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnRemoveInterface(MMC_COOKIE cookie)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
SPITFSNode spNode;
InterfaceNodeData * pNodeData = NULL;
SPIRouterInfo spRouterInfo;
HRESULT hr = hrOK;
SPITFSNodeHandler spHandler;
DWORD dwErr;
BOOL fIsServiceRunning;
CString stServiceDesc;
RefreshInterface(cookie); // Find out whether the interface is connected to
m_spNodeMgr->FindNode(cookie, &spNode);
pNodeData = GET_INTERFACENODEDATA(spNode);
Assert(pNodeData);
BOOL bNotConnected = ((pNodeData->dwConnectionState == ROUTER_IF_STATE_DISCONNECTED)
|| (pNodeData->dwConnectionState == ROUTER_IF_STATE_UNREACHABLE));
m_spInterfaceInfo->GetParentRouterInfo(&spRouterInfo);
// Windows NT Bug : 208471
// Do NOT check for the running router if we are deleting a
// DD interface and we are in LAN-only mode.
// We can also skip this if we are a tunnel.
if ((!IsWanInterface(m_spInterfaceInfo->GetInterfaceType()) ||
(m_spRouterInfo->GetRouterType() != ROUTER_TYPE_LAN)) &&
(m_spInterfaceInfo->GetInterfaceType() != ROUTER_IF_TYPE_TUNNEL1))
{
// Start the service if the service is stopped
CORg( IsRouterServiceRunning(m_spInterfaceInfo->GetMachineName(), NULL));
fIsServiceRunning = (hr == hrOK);
if (!fIsServiceRunning)
{
// Ask the user if they want to start the service
if (AfxMessageBox(IDS_PROMPT_SERVICESTART, MB_YESNO) != IDYES)
CWRg( ERROR_CANCELLED );
// Else start the service
stServiceDesc.LoadString(IDS_RRAS_SERVICE_DESC);
dwErr = TFSStartService(m_spInterfaceInfo->GetMachineName(), c_szRemoteAccess, stServiceDesc);
if (dwErr != NO_ERROR)
{
CWRg( dwErr );
}
}
}
// Addref this node so that it won't get deleted before we're out
// of this function
spHandler.Set(this);
// if connected, disconnect first
if(!bNotConnected && ROUTER_IF_TYPE_FULL_ROUTER == m_spInterfaceInfo->GetInterfaceType())
{
if (AfxMessageBox(IDS_PROMPT_VERIFY_DISCONNECT_INTERFACE, MB_YESNO|MB_DEFBUTTON2) == IDNO)
return HRESULT_FROM_WIN32(ERROR_CANCELLED);
// Disconnect
hr = OnConnectDisconnect(cookie, IDS_MENU_DISCONNECT);
if(FAILED(hr))
return hr;
SPMprServerHandle sphRouter;
MPR_SERVER_HANDLE hRouter = NULL;
dwErr = ConnectRouter(m_spInterfaceInfo->GetMachineName(), &hRouter);
if (dwErr != NO_ERROR)
{
AfxMessageBox(IDS_ERR_DELETE_INTERFACE);
return HRESULT_FROM_WIN32(dwErr);
}
sphRouter.Attach(hRouter); // so that it gets released
WCHAR wszInterface[MAX_INTERFACE_NAME_LEN+1];
StrCpyWFromT(wszInterface, m_spInterfaceInfo->GetId());
HANDLE hInterface;
dwErr = ::MprAdminInterfaceGetHandle(
hRouter,
wszInterface,
&hInterface,
FALSE
);
if (dwErr != NO_ERROR)
{
AfxMessageBox(IDS_ERR_DELETE_INTERFACE);
return HRESULT_FROM_WIN32(dwErr);
}
SPMprAdminBuffer spMprBuffer;
DWORD dwConnectionState = 0;
do
{
dwErr = ::MprAdminInterfaceGetInfo(
hRouter,
hInterface,
0,
(LPBYTE*)&spMprBuffer
);
if (dwErr != NO_ERROR || !spMprBuffer)
{
AfxMessageBox(IDS_ERR_DELETE_INTERFACE);
return HRESULT_FROM_WIN32(dwErr);
}
MPR_INTERFACE_0 *pInfo = (MPR_INTERFACE_0 *) (LPBYTE) spMprBuffer;
dwConnectionState = pInfo->dwConnectionState;
if (dwConnectionState != ROUTER_IF_STATE_DISCONNECTED)
Sleep(0);
} while (dwConnectionState != ROUTER_IF_STATE_DISCONNECTED);
}
else
{
if (AfxMessageBox(IDS_PROMPT_VERIFY_REMOVE_INTERFACE, MB_YESNO|MB_DEFBUTTON2) == IDNO)
return HRESULT_FROM_WIN32(ERROR_CANCELLED);
}
if (spRouterInfo)
{
hr = spRouterInfo->DeleteInterface(m_spInterfaceInfo->GetId(), TRUE);
if (!FHrSucceeded(hr))
{
AfxMessageBox(IDS_ERR_DELETE_INTERFACE);
}
}
Error:
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnUnreachabilityReason
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnUnreachabilityReason(MMC_COOKIE cookie)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString stReason;
SPITFSNode spNode;
InterfaceNodeData * pNodeData;
DWORD dwUnreach;
LPWSTR lpwErr;
SPMprAdminBuffer spMprBuffer;
m_spNodeMgr->FindNode(cookie, &spNode);
Assert(spNode);
pNodeData = GET_INTERFACENODEDATA(spNode);
Assert(pNodeData);
dwUnreach = pNodeData->dwUnReachabilityReason;
if (dwUnreach == MPR_INTERFACE_NOT_LOADED)
{
if (pNodeData->fIsRunning)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_NOT_LOADED);
else
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_NOT_RUNNING);
}
if (dwUnreach & MPR_INTERFACE_DIALOUT_HOURS_RESTRICTION)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_DIALOUT_HOURS_RESTRICTION);
if (dwUnreach & MPR_INTERFACE_NO_MEDIA_SENSE)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_NO_MEDIA_SENSE);
if (dwUnreach & MPR_INTERFACE_ADMIN_DISABLED)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_ADMIN_DISABLED);
if (dwUnreach & MPR_INTERFACE_SERVICE_PAUSED)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_SERVICE_PAUSED);
if (dwUnreach & MPR_INTERFACE_OUT_OF_RESOURCES)
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_NO_PORTS);
else if ( dwUnreach & MPR_INTERFACE_CONNECTION_FAILURE )
{
stReason += GetUnreachReasonCString(IDS_ERR_UNREACH_CONNECT_FAILURE);
//Workaround for bugid: 96347. Change this once
//schannel has an alert for SEC_E_MULTIPLE_ACCOUNTS
if ( pNodeData->dwLastError == SEC_E_CERT_UNKNOWN )
{
pNodeData->dwLastError = SEC_E_MULTIPLE_ACCOUNTS;
}
if (::MprAdminGetErrorString(pNodeData->dwLastError, &lpwErr) == NO_ERROR )
{
spMprBuffer = (BYTE *) lpwErr;
stReason += (LPCTSTR) lpwErr;
}
}
AfxMessageBox(stReason);
return hrOK;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnEnableDisable
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnEnableDisable(MMC_COOKIE cookie, int nCommandID)
{
HRESULT hr = hrOK;
m_spInterfaceInfo->SetInterfaceEnabledState(nCommandID == IDS_MENU_ENABLE);
{
CWaitCursor waitcursor;
hr = m_spInterfaceInfo->Save(NULL, NULL, NULL);
}
// Actually the above call should trigger an event that causes a
// refresh, the explicit RefreshInterface() should not be necessary.
RefreshInterface(cookie);
return hrOK;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnConnectDisconnect
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnConnectDisconnect(MMC_COOKIE cookie, int nCommandID)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
DWORD dwErr;
InterfaceNodeData * pData;
SPITFSNode spNode;
dwErr = ::ConnectInterface(m_spInterfaceInfo->GetMachineName(),
m_spInterfaceInfo->GetId(),
nCommandID == IDS_MENU_CONNECT /* bConnect */,
NULL /*hwndParent*/);
RefreshInterface(cookie);
/*
m_spNodeMgr->FindNode(cookie, &spNode);
pData = GET_INTERFACENODEDATA(spNode);
Assert(pData);
if (dwErr != NO_ERROR && dwErr != PENDING)
{
TCHAR szErr[1024];
FormatSystemError(pData->dwLastError, szErr, 1024, IDS_ERR_ERROR_OCCURRED, 0xFFFFFFFF);
AfxMessageBox(szErr);
}
*/
if (dwErr != NO_ERROR && dwErr != PENDING)
{
TCHAR szErr[1024];
FormatSystemError(dwErr, szErr, 1024, IDS_ERR_ERROR_OCCURRED, 0xFFFFFFFF);
AfxMessageBox(szErr);
}
return hrOK;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnSetCredentials
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnSetCredentials()
{
SPIRouterInfo spRouter;
BOOL fNT4 = FALSE;
DWORD dwErr;
m_spInterfaceInfo->GetParentRouterInfo(&spRouter);
if (spRouter)
{
RouterVersionInfo routerVer;
spRouter->GetRouterVersionInfo(&routerVer);
if (routerVer.dwOsBuildNo <= 1877)
{
fNT4 = TRUE;
}
}
dwErr = PromptForCredentials(m_spInterfaceInfo->GetMachineName(),
m_spInterfaceInfo->GetId(),
fNT4,
FALSE /* fNewInterface */,
NULL /* hwndParent */
);
return HRESULT_FROM_WIN32(dwErr);
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnDemandDialFilters
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnDemandDialFilters(MMC_COOKIE cookie)
{
HRESULT hr = hrOK;
CWaitCursor wait;
SPIInfoBase spInfoBase;
SPIRtrMgrInterfaceInfo spRmIf;
CORg( m_spInterfaceInfo->FindRtrMgrInterface(PID_IP, &spRmIf) );
if (spRmIf == NULL)
{
//$ TODO : need to bring up an error message, about requiring
// that IP be added to this interface
AfxMessageBox(IDS_ERR_DDFILTERS_REQUIRE_IP);
goto Error;
}
CORg( spRmIf->GetInfoBase(NULL, NULL, NULL, &spInfoBase) );
CORg( MprUIFilterConfigInfoBase(NULL,
spInfoBase,
NULL,
PID_IP,
FILTER_DEMAND_DIAL) );
if (hr == hrOK)
{
CORg( spRmIf->Save(m_spInterfaceInfo->GetMachineName(),
NULL, NULL, NULL, spInfoBase, 0) );
}
Error:
if (!FHrSucceeded(hr))
{
DisplayErrorMessage(NULL, hr);
}
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::LoadDialOutHours
-
Author: WeiJiang
---------------------------------------------------------------------------*/
// if the service is not running, return S_FALSE,
// otherwise, using MprAdminInterfaceSetInfo to notify the service of dialin hours changes
HRESULT InterfaceNodeHandler::LoadDialOutHours(CStringList& strList)
{
HANDLE hMachine = INVALID_HANDLE_VALUE;
HANDLE hInterface = INVALID_HANDLE_VALUE;
BOOL bLoaded = FALSE;
HRESULT hr = S_OK;
MPR_INTERFACE_1* pmprif1 = NULL;
DWORD dwErr = 0;
DWORD size;
// Try to connect to the mpradmin service
// Note: this may fail but the service queries down below may
// succeed, so we should setup the states as well as we can here.
// ----------------------------------------------------------------
CORg( IsRouterServiceRunning(m_spInterfaceInfo->GetMachineName(), NULL));
while(hr == S_OK /*running*/ && !bLoaded) // FALSE loop, if runing, load from Service
{
dwErr = ::MprAdminServerConnect((LPWSTR)m_spInterfaceInfo->GetMachineName(), &hMachine);
if(dwErr != NOERROR || hMachine == INVALID_HANDLE_VALUE)
break;
dwErr = ::MprAdminInterfaceGetHandle(hMachine,
(LPWSTR) m_spInterfaceInfo->GetId(),
&hInterface,
FALSE );
if(dwErr != NOERROR || hInterface == INVALID_HANDLE_VALUE)
break;
// See if the interface is connected
dwErr = ::MprAdminInterfaceGetInfo(hMachine,
hInterface,
1,
(LPBYTE*)&pmprif1);
if(dwErr != NOERROR || pmprif1 == NULL)
break;
// get the dialin out information
dwErr = MULTI_SZ2StrList(pmprif1->lpwsDialoutHoursRestriction, strList);
// Windows NT Bug : 317146
// Add on an emptry string to the string list
// This signifies that we have no data (as opposed to the NULL data)
if (pmprif1->lpwsDialoutHoursRestriction)
strList.AddTail(_T(""));
bLoaded = TRUE;
// free the buffer
::MprAdminBufferFree(pmprif1);
pmprif1 = NULL;
break;
};
// disconnect it
if(hMachine != INVALID_HANDLE_VALUE)
{
::MprAdminServerDisconnect(hMachine);
hMachine = INVALID_HANDLE_VALUE;
}
// if not loaded, try MprConfig APIs
while(!bLoaded)
{
dwErr = ::MprConfigServerConnect((LPWSTR)m_spInterfaceInfo->GetMachineName(), &hMachine);
if(dwErr != NOERROR || hMachine == INVALID_HANDLE_VALUE)
break;
dwErr = ::MprConfigInterfaceGetHandle(hMachine,
(LPWSTR) m_spInterfaceInfo->GetId(),
&hInterface);
if(dwErr != NOERROR || hInterface == INVALID_HANDLE_VALUE)
break;
// See if the interface is connected
dwErr = ::MprConfigInterfaceGetInfo(hMachine,
hInterface,
1,
(LPBYTE*)&pmprif1,
&size);
if(dwErr != NOERROR || pmprif1 == NULL)
break;
// get the dialin out information
dwErr = MULTI_SZ2StrList(pmprif1->lpwsDialoutHoursRestriction, strList);
// Windows NT Bug : 317146
// Add on an emptry string to the string list
// This signifies that we have no data (as opposed to the NULL data)
if (pmprif1->lpwsDialoutHoursRestriction)
strList.AddTail(_T(""));
bLoaded = TRUE;
// free the buffer
::MprConfigBufferFree(pmprif1);
pmprif1 = NULL;
break;
}
// disconnect it
if(hMachine != INVALID_HANDLE_VALUE)
{
::MprConfigServerDisconnect(hMachine);
hMachine = INVALID_HANDLE_VALUE;
}
if(!bLoaded)
{
HKEY hkeyMachine = NULL;
HKEY hkeyIf;
RegKey regkeyIf;
// last chance if to connect to registry directly
// Load up the information (from the registry) for the dialin hours
CWRg( ConnectRegistry(m_spInterfaceInfo->GetMachineName(), &hkeyMachine) );
CORg( RegFindInterfaceKey(m_spInterfaceInfo->GetId(), hkeyMachine,
KEY_ALL_ACCESS, &hkeyIf));
regkeyIf.Attach(hkeyIf);
// Now grab the data
dwErr = regkeyIf.QueryValue(c_szDialOutHours, strList);
if (dwErr == NOERROR)
bLoaded = TRUE;
if(hkeyMachine != NULL)
{
DisconnectRegistry(hkeyMachine);
hkeyMachine = NULL;
}
}
Error:
if(dwErr != NOERROR)
hr = HRESULT_FROM_WIN32(dwErr);
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::SaveDialOutHours
-
Author: WeiJiang
---------------------------------------------------------------------------*/
// if the service is not running, return S_FALSE,
// otherwise, using MprAdminInterfaceSetInfo to notify the service of dialin hours changes
HRESULT InterfaceNodeHandler::SaveDialOutHours(CStringList& strList)
{
HANDLE hMachine = INVALID_HANDLE_VALUE;
HANDLE hInterface = INVALID_HANDLE_VALUE;
HRESULT hr = S_OK;
MPR_INTERFACE_1* pmprif1 = NULL;
MPR_INTERFACE_1 mprif1;
DWORD dwErr = 0;
BYTE* pbData = NULL;
DWORD size;
BOOL bSaved = FALSE;
dwErr = StrList2MULTI_SZ(strList, &size, &pbData);
if(dwErr != NOERROR)
{
goto Error;
}
//try MprConfig APIs
while(!bSaved)
{
dwErr = ::MprConfigServerConnect((LPWSTR)m_spInterfaceInfo->GetMachineName(), &hMachine);
if(dwErr != NOERROR || hMachine == INVALID_HANDLE_VALUE)
break;
dwErr = ::MprConfigInterfaceGetHandle(hMachine,
(LPWSTR) m_spInterfaceInfo->GetId(),
&hInterface);
if(dwErr != NOERROR || hInterface == INVALID_HANDLE_VALUE)
break;
// See if the interface is connected
dwErr = ::MprConfigInterfaceGetInfo(hMachine,
hInterface,
1,
(LPBYTE*)&pmprif1,
&size);
if(dwErr != NOERROR || pmprif1 == NULL)
break;
memcpy(&mprif1, pmprif1, sizeof(MPR_INTERFACE_1));
mprif1.lpwsDialoutHoursRestriction = (LPWSTR)pbData;
// See if the interface is connected
dwErr = ::MprConfigInterfaceSetInfo(hMachine,
hInterface,
1,
(LPBYTE)&mprif1);
if(dwErr == NOERROR)
bSaved = TRUE;
// free the buffer
::MprConfigBufferFree(pmprif1);
pmprif1 = NULL;
break;
}
// disconnect it
if(hMachine != INVALID_HANDLE_VALUE)
{
::MprConfigServerDisconnect(hMachine);
hMachine = INVALID_HANDLE_VALUE;
}
if(dwErr != NOERROR)
hr = HRESULT_FROM_WIN32(dwErr);
// Try to connect to the mpradmin service
// Note: this may fail but the service queries down below may
// succeed, so we should setup the states as well as we can here.
// ----------------------------------------------------------------
CORg( IsRouterServiceRunning(m_spInterfaceInfo->GetMachineName(), NULL));
while(hr == S_OK) // FALSE loop, if runing, save to Service
{
DWORD dwErr1 = ::MprAdminServerConnect((LPWSTR)m_spInterfaceInfo->GetMachineName(), &hMachine);
if(dwErr1 != NOERROR || hMachine == INVALID_HANDLE_VALUE)
break;
dwErr1 = ::MprAdminInterfaceGetHandle(hMachine,
(LPWSTR) m_spInterfaceInfo->GetId(),
&hInterface,
FALSE );
if(dwErr1 != NOERROR || hInterface == INVALID_HANDLE_VALUE)
break;
// See if the interface is connected
dwErr1 = ::MprAdminInterfaceGetInfo(hMachine,
hInterface,
1,
(LPBYTE*)&pmprif1);
if(dwErr1 != NOERROR || pmprif1 == NULL)
break;
memcpy(&mprif1, pmprif1, sizeof(MPR_INTERFACE_1));
mprif1.lpwsDialoutHoursRestriction = (LPWSTR)pbData;
dwErr1 = ::MprAdminInterfaceSetInfo(hMachine,
hInterface,
1,
(LPBYTE)&mprif1);
// free the buffer
::MprAdminBufferFree(pmprif1);
pmprif1 = NULL;
break;
};
// disconnect it
if(hMachine != INVALID_HANDLE_VALUE)
{
::MprAdminServerDisconnect(hMachine);
hMachine = INVALID_HANDLE_VALUE;
}
if (!bSaved)
{
HKEY hkeyMachine = NULL;
HKEY hkeyIf;
RegKey regkeyIf;
// last chance if to connect to registry directly
// Load up the information (from the registry) for the dialin hours
CWRg( ConnectRegistry(m_spInterfaceInfo->GetMachineName(), &hkeyMachine) );
CORg( RegFindInterfaceKey(m_spInterfaceInfo->GetId(), hkeyMachine,
KEY_ALL_ACCESS, &hkeyIf));
regkeyIf.Attach(hkeyIf);
// Now grab the data
dwErr = regkeyIf.SetValue(c_szDialOutHours, strList);
if(dwErr == NOERROR)
bSaved = TRUE;
if(hkeyMachine != NULL)
DisconnectRegistry(hkeyMachine);
}
Error:
if(pbData)
delete pbData;
if(dwErr != NOERROR)
hr = HRESULT_FROM_WIN32(dwErr);
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnDialinHours
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnDialinHours(ITFSComponent *pComponent, MMC_COOKIE cookie)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
BYTE rgbDialinHoursMap[21];
CString stDialogTitle;
HWND hWnd;
SPIConsole spConsole;
HKEY hkeyMachine = NULL;
HKEY hkeyIf;
RegKey regkeyIf;
CStringList rgstList;
BYTE * pMap = &(rgbDialinHoursMap[0]);
// Get various MMC information
CORg( pComponent->GetConsole(&spConsole) );
CORg( spConsole->GetMainWindow(&hWnd) );
// If the key doesn't exist then we should set the entire thing to FF
memset(rgbDialinHoursMap, 0xFF, sizeof(rgbDialinHoursMap));
CORg(LoadDialOutHours(rgstList));
// Convert this string list into the binary data
if(rgstList.GetCount())
StrListToHourMap(rgstList, pMap);
stDialogTitle.LoadString(IDS_TITLE_DIALINHOURS);
if (OpenTimeOfDayDlgEx(hWnd, (BYTE **) &pMap, stDialogTitle, SCHED_FLAG_INPUT_LOCAL_TIME) == S_OK)
{
rgstList.RemoveAll();
// Write the information back out to the registry
HourMapToStrList(pMap, rgstList);
CORg(SaveDialOutHours(rgstList));
}
Error:
if (!FHrSucceeded(hr))
DisplayErrorMessage(NULL, hr);
return hr;
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::RefreshInterface
-
Author: KennT
---------------------------------------------------------------------------*/
void InterfaceNodeHandler::RefreshInterface(MMC_COOKIE cookie)
{
SPITFSNode spNode;
SPITFSNode spParent;
SPITFSNodeHandler spHandler;
m_spNodeMgr->FindNode(cookie, &spNode);
// Can't do it for a single node at this time, just refresh the
// whole thing.
spNode->GetParent(&spParent);
spParent->GetHandler(&spHandler);
spHandler->OnCommand(spParent,
IDS_MENU_REFRESH,
CCT_RESULT, NULL, 0);
}
/*!--------------------------------------------------------------------------
InterfaceNodeHandler::OnResultDelete
This notification is received for the delete key from the toolbar
or from the 'delete' key. Forward this to the RemoveInterface
operation.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT InterfaceNodeHandler::OnResultDelete(ITFSComponent *pComponent,
LPDATAOBJECT pDataObject,
MMC_COOKIE cookie,
LPARAM arg,
LPARAM param)
{
return OnRemoveInterface(cookie);
// add new parameter to provide interface data -- bug 166461
// return OnRemoveInterface();
}
/*---------------------------------------------------------------------------
BaseResultHandler implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(BaseResultHandler)
IMPLEMENT_ADDREF_RELEASE(BaseResultHandler)
STDMETHODIMP BaseResultHandler::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 CBaseResultHandler::QueryInterface(riid, ppv);
// If we're going to return an interface, AddRef it first
if (*ppv)
{
((LPUNKNOWN) *ppv)->AddRef();
return hrOK;
}
else
return E_NOINTERFACE;
}
/*---------------------------------------------------------------------------
NodeHandler implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
BaseResultHandler::GetString
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(LPCTSTR) BaseResultHandler::GetString(ITFSComponent * pComponent,
MMC_COOKIE cookie,
int nCol)
{
Assert(m_spNodeMgr);
SPITFSNode spNode;
InterfaceNodeData * pData;
ConfigStream * pConfig;
m_spNodeMgr->FindNode(cookie, &spNode);
Assert(spNode);
pData = GET_INTERFACENODEDATA(spNode);
Assert(pData);
pComponent->GetUserData((LONG_PTR *) &pConfig);
Assert(pConfig);
return pData->m_rgData[pConfig->MapColumnToSubitem(m_ulColumnId, nCol)].m_stData;
}
/*!--------------------------------------------------------------------------
BaseResultHandler::CompareItems
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP_(int) BaseResultHandler::CompareItems(ITFSComponent * pComponent,
MMC_COOKIE cookieA,
MMC_COOKIE cookieB,
int nCol)
{
ConfigStream * pConfig;
pComponent->GetUserData((LONG_PTR *) &pConfig);
Assert(pConfig);
int nSubItem = pConfig->MapColumnToSubitem(m_ulColumnId, nCol);
if (pConfig->GetSortCriteria(m_ulColumnId, nCol) == CON_SORT_BY_DWORD)
{
SPITFSNode spNodeA, spNodeB;
InterfaceNodeData * pNodeDataA, *pNodeDataB;
m_spNodeMgr->FindNode(cookieA, &spNodeA);
m_spNodeMgr->FindNode(cookieB, &spNodeB);
pNodeDataA = GET_INTERFACENODEDATA(spNodeA);
Assert(pNodeDataA);
pNodeDataB = GET_INTERFACENODEDATA(spNodeB);
Assert(pNodeDataB);
return pNodeDataA->m_rgData[nSubItem].m_dwData -
pNodeDataB->m_rgData[nSubItem].m_dwData;
}
else
return StriCmpW(GetString(pComponent, cookieA, nCol),
GetString(pComponent, cookieB, nCol));
}
ImplementEmbeddedUnknown(BaseResultHandler, IRtrAdviseSink)
STDMETHODIMP BaseResultHandler::EIRtrAdviseSink::OnChange(LONG_PTR dwConn,
DWORD dwChangeType, DWORD dwObjectType, LPARAM lUserParam, LPARAM lParam)
{
InitPThis(BaseResultHandler, IRtrAdviseSink);
HRESULT hr = hrOK;
Panic0("Should never reach here, interface nodes have no children");
return hr;
}
HRESULT BaseResultHandler::Init(IInterfaceInfo *pIfInfo, ITFSNode *pParent)
{
return hrOK;
}
STDMETHODIMP BaseResultHandler::DestroyResultHandler(MMC_COOKIE cookie)
{
SPITFSNode spNode;
m_spNodeMgr->FindNode(cookie, &spNode);
InterfaceNodeData::Free(spNode);
BaseRouterHandler::DestroyResultHandler(cookie);
return hrOK;
}
Reference in a new issue View git blame Copy permalink