archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/net/wlbs/nlbmgr/exe2/engine.cpp

8387 lines
231 KiB
Raw Blame History

//***************************************************************************
//
// ENGINE.CPP
//
// Module: NLB Manager (client-side exe)
//
// Purpose: Implements the engine used to operate on groups of NLB hosts.
// This file has no UI aspects.
//
// Copyright (c)2001 Microsoft Corporation, All Rights Reserved
//
// History:
//
// 07/25/01 JosephJ Created
//
//***************************************************************************
#include "precomp.h"
#pragma hdrstop
#include "AboutDialog.h"
#include "private.h"
#include "engine.tmh"
//
// ENGINEHANDLE incodes the type of the object -- the following constant
// is the number of bits used to encode the type.
//
#define TYPE_BIT_COUNT 0x3
BOOL
validate_extcfg(
const NLB_EXTENDED_CLUSTER_CONFIGURATION &Config
);
BOOL
get_used_port_rule_priorities(
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &Config,
IN UINT NumRules,
IN const WLBS_PORT_RULE rgRules[],
IN OUT ULONG rgUsedPriorities[] // At least NumRules
);
const WLBS_PORT_RULE *
find_port_rule(
const WLBS_PORT_RULE *pRules,
UINT NumRules,
LPCWSTR szVIP,
UINT StartPort
);
VOID
remove_dedicated_ip_from_nlbcfg(
NLB_EXTENDED_CLUSTER_CONFIGURATION &ClusterCfg
);
NLBERROR
analyze_nlbcfg(
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &NlbCfg,
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &OtherNlbCfg,
IN LPCWSTR szOtherDescription,
IN BOOL fClusterProps,
IN BOOL fDisablePasswordCheck,
IN OUT CLocalLogger &logger
);
DWORD
WINAPI
UpdateInterfaceWorkItemRoutine(
LPVOID lpParameter // thread data
);
DWORD
WINAPI
AddClusterMembersWorkItemRoutine(
LPVOID lpParameter // thread data
);
void
CHostSpec::Copy(const CHostSpec &hs)
/*
This is the copy operator. Need to make a copy of strings in embedded
vectors.
*/
{
*this = hs;
}
NLBERROR
CClusterSpec::Copy(const CClusterSpec &cs)
/*
This is the copy operator. Need to munge the m_ClusterNlbCfg field.
TODO: fix this hack.
TODO: if we fail we leave CClusterSpec trashed!
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
m_ClusterNlbCfg.Clear();
*this = cs; // non-trivial copy
ZeroMemory(&m_ClusterNlbCfg, sizeof(m_ClusterNlbCfg));
m_ClusterNlbCfg.Clear(); // TODO: please! cleanup NLB_EXTENDED...
//
// Copy over the cluster configuration.
//
{
WBEMSTATUS wStat;
wStat = m_ClusterNlbCfg.Update(&cs.m_ClusterNlbCfg);
if (FAILED(wStat))
{
//
// We've trashed m_ClusterNlbCfg -- set defaults.
//
CfgUtilInitializeParams(&m_ClusterNlbCfg.NlbParams);
if (wStat == WBEM_E_OUT_OF_MEMORY)
{
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
}
else
{
//
// We assume that it's because the cluster spec is invalid.
//
nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
}
}
else
{
nerr = NLBERR_OK;
}
}
return nerr;
}
void
CInterfaceSpec::Copy(const CInterfaceSpec &is)
/*
This is the copy operator. Need to munge the m_NlbCfg field.
TODO: fix this hack.
TODO: add return value (m_NlbCfg.Update now returns an error).
*/
{
*this = is;
ZeroMemory(&m_NlbCfg, sizeof(m_NlbCfg));
m_NlbCfg.Update(&is.m_NlbCfg);
}
NLBERROR
CNlbEngine::Initialize(
IN IUICallbacks & ui,
BOOL fDemo,
BOOL fNoPing
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
TRACE_INFO(L"-> %!FUNC! (bDemo=%lu)", fDemo);
//
// Enable the "SeLoadDriverPrivilege" privilege in the process access token.
// This is needed in the case when the server is local (ie. same machine).
// Do NOT check for the return value since this function will fail when called
// as a non-admin. It is not only ok but also necessary to ignore the failure of
// this function because:
// 1. We already check in the wmi provider that the caller is an administrator on
// the server and if the privilege is enabled. This is why it is ok to ignore
// failures in this function.
// 2. Non-admins can run nlb manager. They only need to be admins on the server.
// This is why it is necessary to ignore failures in this function.
//
CfgUtils_Enable_Load_Unload_Driver_Privilege();
WBEMSTATUS wStat = CfgUtilInitialize(FALSE, fNoPing);
if (!FAILED(wStat))
{
mfn_Lock();
//
// Save away the callback object.
//
m_pCallbacks = &ui;
mfn_Unlock();
if (fDemo)
{
TRACE_CRIT("%!FUNC! RUNNING ENGINE IN DEMO MODE");
NlbHostFake();
}
nerr = NLBERR_OK;
}
TRACE_INFO(L"<- %!FUNC!");
return nerr;
}
void
CNlbEngine::Deinitialize(void)
// TODO: cleanup
{
TRACE_INFO(L"-> %!FUNC!");
ASSERT(m_fPrepareToDeinitialize);
// DummyAction(L"Engine::Deinitialize");
TRACE_INFO(L"<- %!FUNC!");
return;
}
NLBERROR
CNlbEngine::ConnectToHost(
IN PWMI_CONNECTION_INFO pConnInfo,
IN BOOL fOverwriteConnectionInfo,
OUT ENGINEHANDLE &ehHost,
OUT _bstr_t &bstrError
)
/*
Connect the the host specfieid in pConnInfo (includes username and password)
If (fOverwriteConnectionInfo) is true, then it will overwrite
connection-info (connection string, connection IP, credentials)
that pre-exists for this host with the stuff in pConnInfo.
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
LPWSTR szWmiMachineName = NULL;
LPWSTR szWmiMachineGuid = NULL;
WBEMSTATUS wStatus;
ULONG uIpAddress;
BOOL fNlbMgrProviderInstalled = FALSE;
TRACE_INFO(L"-> %!FUNC!(%ws)", pConnInfo->szMachine);
ehHost = NULL;
wStatus = NlbHostPing(pConnInfo->szMachine, 2000, &uIpAddress);
if (FAILED(wStatus))
{
nerr = NLBERR_PING_TIMEOUT; // todo more specific error.
bstrError = GETRESOURCEIDSTRING(IDS_PING_FAILED);
goto end;
}
wStatus = NlbHostGetMachineIdentification(
pConnInfo,
&szWmiMachineName,
&szWmiMachineGuid,
&fNlbMgrProviderInstalled
);
if (FAILED(wStatus))
{
GetErrorCodeText(wStatus, bstrError);
if (wStatus == E_ACCESSDENIED)
{
nerr = NLBERR_ACCESS_DENIED;
}
else
{
// TODO: map proper errors.
nerr = NLBERR_NOT_FOUND;
}
TRACE_CRIT(L"Connecting to %ws returns error %ws",
pConnInfo->szMachine, (LPCWSTR) bstrError);
szWmiMachineName = NULL;
szWmiMachineGuid = NULL;
goto end;
}
//
// We use the MachineName (TODO: replace by MachineGuid) as the
// primary key of Hosts.
//
{
CHostSpec* pHost = NULL;
BOOL fIsNew = FALSE;
ehHost = NULL;
mfn_Lock();
nerr = mfn_LookupHostByNameLk(
szWmiMachineName,
TRUE, // create if needed
REF ehHost,
REF pHost,
REF fIsNew
);
if (nerr != NLBERR_OK)
{
mfn_Unlock();
goto end;
}
if (fIsNew)
{
pHost->m_fReal = FALSE; // set to true once the nics are populated.
pHost->m_MachineGuid = _bstr_t(szWmiMachineGuid);
pHost->m_ConnectionString = _bstr_t(pConnInfo->szMachine);
pHost->m_ConnectionIpAddress = uIpAddress;
pHost->m_UserName = _bstr_t(pConnInfo->szUserName);
pHost->m_Password = _bstr_t(pConnInfo->szPassword);
}
mfn_Unlock();
nerr = mfn_RefreshHost(
pConnInfo,
ehHost,
fOverwriteConnectionInfo
);
}
end:
delete szWmiMachineName;
delete szWmiMachineGuid;
return nerr;
}
void
CNlbEngine::DeleteCluster(
IN ENGINEHANDLE ehCluster,
IN BOOL fRemoveInterfaces)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
vector<ENGINEHANDLE> RemovedInterfaces;
TRACE_INFO(L"-> %!FUNC!(ehC=0x%lx)",ehCluster);
mfn_Lock();
do // while false
{
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehCluster];
CClusterSpec *pCSpec = NULL;
BOOL fEmptyCluster = FALSE;
if (pECluster == NULL)
{
// Invalid ehCluster
TRACE_CRIT("%!FUNC! -- invalid ehCluster 0x%lx", ehCluster);
break;
}
pCSpec = &pECluster->m_cSpec;
fEmptyCluster = (pCSpec->m_ehInterfaceIdList.size()==0);
//
// fail if operations are pending on this cluster. We determine
// this indirectly by checking if we're allowed to start a
// cluster-wide operation, which will only succeed if
// there no ongoing operations on the cluster OR its interfaces.
//
BOOL fCanStart = FALSE;
nerr = mfn_ClusterOrInterfaceOperationsPendingLk(
pECluster,
REF fCanStart
);
if (NLBFAILED(nerr) || !fCanStart)
{
TRACE_CRIT("%!FUNC! Not deleting cluster eh0x%lx because of pending activity.",
ehCluster);
nerr = NLBERR_OTHER_UPDATE_ONGOING;
break;
}
if (!fEmptyCluster)
{
if (!fRemoveInterfaces)
{
TRACE_CRIT("%!FUNC! Not deleting cluster eh0x%lx because it's not empty",
ehCluster);
break;
}
RemovedInterfaces = pCSpec->m_ehInterfaceIdList; // vector copy
//
// We unlink all the interfaces from this cluster.
//
while(!pCSpec->m_ehInterfaceIdList.empty())
{
vector <ENGINEHANDLE>::iterator iItem
= pCSpec->m_ehInterfaceIdList.begin();
ENGINEHANDLE ehIF = *iItem;
CInterfaceSpec *pISpec = NULL;
//
// Unlink the interface from the cluster.
// (this is with the lock held)
//
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec != NULL)
{
if (pISpec->m_ehCluster == ehCluster)
{
pISpec->m_ehCluster = NULL;
//
// Delete the host and its interfaces if
// none of them are managed by nlbmanager (i.e., show
// up as members of a cluster managed by nlbmgr).
//
mfn_DeleteHostIfNotManagedLk(pISpec->m_ehHostId);
}
else
{
TRACE_CRIT(L"ehC(0x%x) points to ehI(0x%x), but ehI points to different cluster ehC(0x%x)",
ehCluster, ehIF, pISpec->m_ehCluster);
ASSERT(!"Cluser/interface handle corruption!");
}
}
pCSpec->m_ehInterfaceIdList.erase(iItem);
}
}
m_mapIdToEngineCluster.erase(ehCluster);
delete pECluster;
pECluster = NULL;
nerr = NLBERR_OK;
} while (FALSE);
mfn_Unlock();
if (nerr == NLBERR_OK)
{
//
// Notify the UI
//
for( int i = 0; i < RemovedInterfaces.size(); ++i )
{
ENGINEHANDLE ehIId = RemovedInterfaces[i];
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehCluster,
ehIId,
IUICallbacks::EVT_INTERFACE_REMOVED_FROM_CLUSTER
);
}
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_REMOVED
);
}
TRACE_INFO(L"<- %!FUNC!");
return;
}
NLBERROR
CNlbEngine::AutoExpandCluster(
IN ENGINEHANDLE ehClusterId
)
{
TRACE_INFO(L"-> %!FUNC!");
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::AddInterfaceToCluster(
IN ENGINEHANDLE ehClusterId,
IN ENGINEHANDLE ehInterfaceId
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
ENGINEHANDLE ehIfId = ehInterfaceId;
TRACE_INFO(L"-> %!FUNC!");
mfn_Lock();
CInterfaceSpec *pISpec = NULL;
CClusterSpec *pCSpec = NULL;
do // while false
{
CEngineCluster *pECluster = NULL;
pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
TRACE_CRIT("%!FUNC! -- could not find cluster associated with id 0x%lx",
(UINT) ehClusterId
);
break;
}
pCSpec = &pECluster->m_cSpec;
pISpec = m_mapIdToInterfaceSpec[ehInterfaceId]; // map
if (pISpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
TRACE_CRIT("%!FUNC! -- could not find interface associated with id 0x%lx",
(UINT) ehInterfaceId
);
break;
}
//
// The interface is valid. Now push in the interface if it is not
// already a part of the this cluster.
//
if (pISpec->m_ehCluster != NULL)
{
if (pISpec->m_ehCluster != ehClusterId)
{
//
// We don't allow the same interface to be part of
// two clusters!
//
nerr = NLBERR_INTERNAL_ERROR;
TRACE_CRIT("%!FUNC! -- Interface eh 0x%lx is a member of an other cluster eh0x%lx.", ehIfId, pISpec->m_ehCluster);
break;
}
}
//
// Note: find is a pre-defined template function.
//
if(find(
pCSpec->m_ehInterfaceIdList.begin(),
pCSpec->m_ehInterfaceIdList.end(),
ehIfId
) != pCSpec->m_ehInterfaceIdList.end())
{
// item already exists.
// for now we'll ignore this.
if (pISpec->m_ehCluster != ehClusterId)
{
TRACE_CRIT("%!FUNC! -- ERROR Interface eh 0x%lx ehCluster doesn't match!", ehIfId);
nerr = NLBERR_INTERNAL_ERROR;
break;
}
}
else
{
pISpec->m_ehCluster = ehClusterId;
pCSpec->m_ehInterfaceIdList.push_back(ehIfId);
}
nerr = NLBERR_OK;
} while (FALSE);
mfn_Unlock();
if (nerr == NLBERR_OK)
{
//
// Inform the UI of the addition of a new interface under the
// specified cluster.
//
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehClusterId,
ehInterfaceId,
IUICallbacks::EVT_INTERFACE_ADDED_TO_CLUSTER
);
}
TRACE_INFO(L"<- %!FUNC! returns 0x%lx", nerr);
return nerr;
}
NLBERROR
CNlbEngine::RemoveInterfaceFromCluster(
IN ENGINEHANDLE ehClusterId,
IN ENGINEHANDLE ehIfId
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
TRACE_INFO(L"-> %!FUNC!");
BOOL fEmptyCluster = FALSE; // TRUE IFF no more interfaces in cluster.
mfn_Lock();
CInterfaceSpec *pISpec = NULL;
CClusterSpec *pCSpec = NULL;
do // while false
{
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
TRACE_CRIT("%!FUNC! -- could not find cluster associated with id 0x%lx",
(UINT) ehClusterId
);
break;
}
pCSpec = &pECluster->m_cSpec;
pISpec = m_mapIdToInterfaceSpec[ehIfId]; // map
if (pISpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
TRACE_CRIT("%!FUNC! -- could not find interface associated with id 0x%lx",
(UINT) ehIfId
);
break;
}
vector <ENGINEHANDLE>::iterator iFoundItem;
//
// The interface is valid. No push in the interface if it is not
// already a part of the this cluster.
//
//
// Note: find is a pre-defined template function.
//
iFoundItem = find(
pCSpec->m_ehInterfaceIdList.begin(),
pCSpec->m_ehInterfaceIdList.end(),
ehIfId
);
if (iFoundItem != pCSpec->m_ehInterfaceIdList.end())
{
// item exists, remove it.
pCSpec->m_ehInterfaceIdList.erase(iFoundItem);
if (pISpec->m_ehCluster != ehClusterId)
{
// shouldn't get here!
ASSERT(FALSE);
TRACE_CRIT("%!FUNC!: ERROR pISpec->m_ehCluster(0x%lx) != ehCluster(0x%lx)", pISpec->m_ehCluster, ehClusterId);
}
else
{
fEmptyCluster = (pCSpec->m_ehInterfaceIdList.size()==0);
pISpec->m_ehCluster = NULL;
if (pCSpec->m_ehDefaultInterface == ehIfId)
{
//
// We're removing the interface whose properties are
// the basis of the cluser-wide view.
//
pCSpec->m_ehDefaultInterface = NULL;
}
nerr = NLBERR_OK;
}
}
else
{
// item doesn't exist.
}
} while (FALSE);
mfn_Unlock();
if (nerr == NLBERR_OK)
{
//
// Inform the UI of the removal of an interface under the
// specified cluster.
//
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehClusterId,
ehIfId,
IUICallbacks::EVT_INTERFACE_REMOVED_FROM_CLUSTER
);
if (fEmptyCluster)
{
//
// The cluster is empty -- delete it.
//
this->DeleteCluster(ehClusterId, FALSE); // FALSE == don't remove IF.
}
}
TRACE_INFO(L"<- %!FUNC!");
return nerr;
}
NLBERROR
CNlbEngine::RefreshAllHosts(
void
)
{
TRACE_INFO(L"-> %!FUNC!");
/*
For each host in host map
Get Adapter List
- Delete all Interfaces that are no longer present
- Add/Update all host infos, one by one.
Do all this in the background.
*/
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::RefreshCluster(
IN ENGINEHANDLE ehCluster
)
{
TRACE_INFO(L"-> %!FUNC!");
/*
For each interface in cluster
- Add/Update interface info, one by one.
*/
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::mfn_RefreshInterface(
IN ENGINEHANDLE ehInterface
)
/*
Add/Update interface info, deleting interface info if it's no longer there.
Take/share code from RefreshHost
Get host connection string.
Get szNicGuid.
Ping host.
GetClusterConfiguration.
Update.
Notify UI of status change.
*/
{
CLocalLogger logger;
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
WBEMSTATUS wStatus = WBEM_E_CRITICAL_ERROR;
ULONG uIpAddress=0;
WMI_CONNECTION_INFO ConnInfo;
NLB_EXTENDED_CLUSTER_CONFIGURATION NlbCfg; // class
LPCWSTR szNic = NULL;
_bstr_t bstrUserName;
_bstr_t bstrPassword;
_bstr_t bstrConnectionString;
_bstr_t bstrNicGuid;
_bstr_t bstrHostName;
BOOL fMisconfigured = FALSE;
LPCWSTR szHostName = NULL;
ENGINEHANDLE ehHost;
BOOL fCheckHost = FALSE;
TRACE_INFO(L"-> %!FUNC! (ehIF=0x%lx)", (UINT) ehInterface);
ZeroMemory(&ConnInfo, sizeof(ConnInfo));
//
// Get connection info from the interface's host.
//
{
mfn_Lock();
CHostSpec *pHSpec = NULL;
CInterfaceSpec *pISpec = NULL;
nerr = this->mfn_GetHostFromInterfaceLk(ehInterface,REF pISpec, REF pHSpec);
if (nerr != NLBERR_OK)
{
TRACE_CRIT("%!FUNC!: ERROR couldn't get info on this if id!");
mfn_Unlock();
goto end;
}
//
// We must make copies here because once we unlock
// we don't know what's going to happen to pHSpec.
//
bstrUserName = pHSpec->m_UserName;
bstrPassword = pHSpec->m_Password;
bstrConnectionString = pHSpec->m_ConnectionString;
bstrNicGuid = pISpec->m_Guid;
bstrHostName = pHSpec->m_MachineName;
ehHost = pISpec->m_ehHostId;
//
// If the host was previously marked unreachable, we'll
// try to check again if it's there (and update it's state).
//
fCheckHost = pHSpec->m_fUnreachable;
mfn_Unlock();
}
ConnInfo.szUserName = (LPCWSTR) bstrUserName;
ConnInfo.szPassword = (LPCWSTR) bstrPassword;
ConnInfo.szMachine = (LPCWSTR) bstrConnectionString;
if (fCheckHost)
{
nerr = mfn_CheckHost(&ConnInfo, ehHost);
if (NLBFAILED(nerr))
{
goto end;
}
}
szNic = (LPCWSTR) bstrNicGuid;
szHostName = (LPCWSTR) bstrHostName;
wStatus = NlbHostPing(ConnInfo.szMachine, 2000, &uIpAddress);
if (FAILED(wStatus))
{
m_pCallbacks->Log(
IUICallbacks::LOG_ERROR,
NULL, // szCluster
szHostName,
IDS_LOG_PING_FAILED,
ConnInfo.szMachine
);
//
// TODO update host
//
fMisconfigured = TRUE;
logger.Log(IDS_LOG_COULD_NOT_PING_HOST);
}
else
{
wStatus = NlbHostGetConfiguration(
&ConnInfo,
szNic,
&NlbCfg
);
if (FAILED(wStatus))
{
TRACE_CRIT(L"%!FUNC! Error reading extended configuration for %ws\n", szNic);
m_pCallbacks->Log(
IUICallbacks::LOG_ERROR,
NULL, // szCluster
szHostName,
IDS_LOG_COULD_NOT_GET_IF_CONFIG,
szNic,
(UINT) wStatus
);
fMisconfigured = TRUE;
logger.Log(IDS_LOG_COULD_NOT_READ_IF_CONFIG);
}
}
//
// Now that we've read the latest cfg info onto NlbCfg, let's update it
// (or mark the IF as misconfigured if there's been an error.)
//
{
CInterfaceSpec *pISpec = NULL;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec != NULL)
{
pISpec->m_fReal = TRUE;
if (!fMisconfigured)
{
wStatus = pISpec->m_NlbCfg.Update(&NlbCfg);
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC! error updating nlbcfg for eh%lx", ehInterface);
fMisconfigured = TRUE;
logger.Log(IDS_LOG_FAILED_UPDATE);
}
//
// Update the host's connection IP address
//
if (uIpAddress != 0)
{
CHostSpec *pHSpec = NULL;
CInterfaceSpec *pTmpISpec = NULL;
nerr = this->mfn_GetHostFromInterfaceLk(
ehInterface,
REF pTmpISpec,
REF pHSpec
);
if (nerr == NLBERR_OK)
{
pHSpec->m_ConnectionIpAddress = uIpAddress;
}
}
}
//
// Set/clear the misconfiguration state.
//
{
LPCWSTR szDetails = NULL;
UINT Size = 0;
if (fMisconfigured)
{
logger.ExtractLog(szDetails, Size);
}
mfn_SetInterfaceMisconfigStateLk(pISpec, fMisconfigured, szDetails);
}
}
mfn_Unlock();
}
if (fMisconfigured)
{
//
// We couldn't read the latest settings for some reason --
// check connectivity to the host and update the host status if
// necessary.
//
nerr = mfn_CheckHost(&ConnInfo, ehHost);
if (NLBOK(nerr))
{
//
// We still want to fail this because we couldn't get
// the updated configuration.
//
nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
}
}
else
{
nerr = NLBERR_OK;
}
end:
TRACE_INFO(L"<- %!FUNC!");
return nerr;
}
NLBERROR
CNlbEngine::RefreshInterface(
IN ENGINEHANDLE ehInterface,
IN BOOL fNewOperation,
IN BOOL fClusterWide
)
/*
Add/Update interface info, deleting interface info if it's no longer there.
Take/share code from RefreshHost
Get host connection string.
Get szNicGuid.
Ping host.
GetClusterConfiguration.
Update.
Notify UI of status change.
*/
{
CLocalLogger logger;
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
BOOL fMisconfigured = FALSE;
BOOL fRemoveInterfaceFromCluster = FALSE;
BOOL fStopOperationOnExit = FALSE;
ENGINEHANDLE ehCluster = NULL;
TRACE_INFO(L"-> %!FUNC! (ehIF=0x%lx)", (UINT) ehInterface);
if (fNewOperation)
{
//
// This function is to be run in the context of a NEW operation.
// Verify that we can do a refresh at this time, and if so, start an
// operation to track the refresh.
//
CInterfaceSpec *pISpec = NULL;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC!: ERROR couldn't get info on this if id!");
goto end_unlock;
}
if (!fClusterWide)
{
ehCluster = pISpec->m_ehCluster;
if (ehCluster != NULL)
{
//
// Make sure that there's no pending cluster-wide operation
// going on for the cluster that this IF is a part of.
//
CEngineCluster *pECluster = NULL;
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster != NULL)
{
if (pECluster->m_cSpec.m_ehPendingOperation != NULL)
{
nerr = NLBERR_BUSY;
TRACE_CRIT("%!FUNC!: ehIF 0x%lx: Can't proceed because of existing op 0x%lx",
ehInterface,
pECluster->m_cSpec.m_ehPendingOperation
);
goto end_unlock;
}
}
}
}
//
// Now try to start an operation...
//
{
ENGINEHANDLE ExistingOp = NULL;
nerr = mfn_StartInterfaceOperationLk(
ehInterface,
NULL, // pvCtxt
GETRESOURCEIDSTRING(IDS_LOG_REFRESH_INTERFACE),
&ExistingOp
);
if (NLBFAILED(nerr))
{
goto end_unlock;
}
//
// We did start the operation -- so we keep track of this, so that
// we stop the operation on exit.
//
fStopOperationOnExit = TRUE;
}
mfn_Unlock();
}
//
// Here's where we actually refresh the interface.
//
nerr = mfn_RefreshInterface(ehInterface);
if (!NLBOK(nerr))
{
mfn_Lock();
goto end_unlock;
}
//
// Now let's analyze the result ...
//
{
CInterfaceSpec *pISpec = NULL;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec != NULL)
{
fMisconfigured = pISpec->m_fMisconfigured;
ehCluster = pISpec->m_ehCluster;
if (!fMisconfigured)
{
if (ehCluster != NULL)
{
if (!pISpec->m_NlbCfg.IsNlbBound())
{
//
// NLB is not bound on this interface --
// remove this interface from the cluster.
fRemoveInterfaceFromCluster = TRUE;
}
else
{
nerr = this->mfn_AnalyzeInterfaceLk(ehInterface, REF logger);
if (NLBFAILED(nerr))
{
fMisconfigured = TRUE;
}
}
}
//
// Set the new misconfiguration state.
//
{
LPCWSTR szDetails = NULL;
UINT Size = 0;
if (fMisconfigured)
{
logger.ExtractLog(szDetails, Size);
}
mfn_SetInterfaceMisconfigStateLk(pISpec, fMisconfigured, szDetails);
}
}
}
mfn_Unlock();
}
if (fRemoveInterfaceFromCluster)
{
this->RemoveInterfaceFromCluster(ehCluster, ehInterface);
}
else
{
//
// Report state
//
if (fMisconfigured)
{
//
// Log ...
//
LPCWSTR szDetails = NULL;
LPCWSTR szCluster = NULL;
LPCWSTR szHostName = NULL;
LPCWSTR szInterface = NULL;
UINT Size = 0;
ENGINEHANDLE ehHost;
_bstr_t bstrDisplayName;
_bstr_t bstrFriendlyName;
_bstr_t bstrHostName;
_bstr_t bstrIpAddress;
nerr = this->GetInterfaceIdentification(
ehInterface,
REF ehHost,
REF ehCluster,
REF bstrFriendlyName,
REF bstrDisplayName,
REF bstrHostName
);
if (NLBOK(nerr))
{
_bstr_t bstrDomainName;
_bstr_t bstrClusterDisplayName;
nerr = this->GetClusterIdentification(
ehCluster,
REF bstrIpAddress,
REF bstrDomainName,
REF bstrClusterDisplayName
);
if (NLBOK(nerr))
{
szCluster = bstrIpAddress;
}
szHostName = bstrHostName;
szInterface = bstrFriendlyName;
}
logger.ExtractLog(szDetails, Size);
IUICallbacks::LogEntryHeader Header;
Header.szDetails = szDetails;
Header.type = IUICallbacks::LOG_ERROR;
Header.szCluster = szCluster;
Header.szHost = szHostName;
Header.szInterface = szInterface;
m_pCallbacks->LogEx(
&Header,
IDS_LOG_INTERFACE_MISCONFIGURATION
);
}
else
{
ControlClusterOnInterface( ehInterface, WLBS_QUERY, NULL, NULL, 0, FALSE);
}
}
nerr = NLBERR_OK;
mfn_Lock();
//
// Fall through ...
//
end_unlock:
if (fStopOperationOnExit)
{
mfn_StopInterfaceOperationLk(ehInterface);
}
mfn_Unlock();
if (fStopOperationOnExit && !fRemoveInterfaceFromCluster)
{
//
// Notify the UI of this update...
// (but only if we've not already removed it from
// the cluster!)
//
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehCluster,
ehInterface,
IUICallbacks::EVT_STATUS_CHANGE
);
}
TRACE_INFO(L"<- %!FUNC!");
return nerr;
}
NLBERROR
CNlbEngine::AnalyzeCluster(
ENGINEHANDLE ehClusterId
)
{
TRACE_INFO(L"-> %!FUNC!");
/*
TODO: consider doing this with a specific host in mind
For each IF I1
AnalyzeHost(host-of(I1))
For each other IF I2
AnalyzeTwoHosts(I1, I2)
AnalyzeTwoHosts(I1, I2):
- check that cluster params match
- check that port rules are compatible
- check that host properties do not collide.
- check dedicated IP subnets match.
AnalyzeHost(H1)
For each IF I1
AnalyzeSingleIf(I1) (including checking dedicated ips)
*/
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::mfn_AnalyzeInterfaceLk(
ENGINEHANDLE ehInterface,
CLocalLogger &logger
)
/*
-- check interface props against cluster properties
-- if cluster props match out,
for each host id NOT marked fMisconfigured,
check host properties.
-- Does NOT mark fMisconfigured if error detected -- caller is expected
to do so.
-- Spews stuff to log regarding any misconfigurations.
*/
{
NLBERROR nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
const CEngineCluster *pECluster = NULL;
const CInterfaceSpec *pISpec = NULL;
BOOL fIgnoreRctPassword = FALSE;
TRACE_INFO(L"-> %!FUNC!");
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec == NULL)
{
nerr = NLBERR_INTERFACE_NOT_FOUND;
goto end;
}
//
// If interface is NOT part of a cluster, we're done.
//
if (pISpec->m_ehCluster == NULL)
{
TRACE_CRIT("ehIF 0x%lx m_ehCluster member is NULL!", ehInterface);
goto end;
}
//
// Check the interface against itself ...
//
{
nerr = AnalyzeNlbConfiguration(REF pISpec->m_NlbCfg, logger);
if (NLBFAILED(nerr))
{
goto end;
}
}
//
// Get the cluster data that this interface is a part of.
//
pECluster = m_mapIdToEngineCluster[pISpec->m_ehCluster]; // map
if (pECluster == NULL)
{
TRACE_CRIT(L"ehIF 0x%lx m_ehCluster member 0x%lx is INVALID!",
ehInterface, pISpec->m_ehCluster);
nerr = NLBERR_INTERNAL_ERROR;
goto end;
}
//
// Check interface against cluster.
//
fIgnoreRctPassword = pECluster->m_cSpec.m_fNewRctPassword;
nerr = analyze_nlbcfg(
REF pISpec->m_NlbCfg,
REF pECluster->m_cSpec.m_ClusterNlbCfg,
(LPCWSTR) GETRESOURCEIDSTRING(IDS_CLUSTER),
// L"Cluster",
TRUE, // TRUE == ClusterProps
fIgnoreRctPassword, // TRUE==Disable RCT password check
REF logger
);
if (NLBFAILED(nerr))
{
//
// If analyzing against cluster props fails, we don't bother
// analyzing against other hosts...
//
TRACE_CRIT(L"analyze_nlbcfg returns error 0x%lx", nerr);
goto end;
}
//
// Now check against all hosts before us in the list of hosts in the
// cluster -- but only those that are not already marked misconfigured.
//
//
{
const vector<ENGINEHANDLE> &InterfaceList =
pECluster->m_cSpec.m_ehInterfaceIdList;
for( int i = 0; i < InterfaceList.size(); ++i )
{
ENGINEHANDLE ehIOther = InterfaceList[i];
const CInterfaceSpec *pISpecOther = NULL;
WCHAR rgOtherDescription[256];
*rgOtherDescription = 0;
if (ehIOther == ehInterface)
{
//
// We've reached the interface being analyzed -- we don't
// compare with any of the remaining interfaces.
//
break;
}
pISpecOther = m_mapIdToInterfaceSpec[ehIOther]; // map
if (pISpecOther == NULL)
{
TRACE_CRIT("Unexpected: NULL pISpec for ehInterface 0x%lx",
ehIOther);
continue;
}
//
// We don't compare of the other interface is marked misconfigured,
// or is not bound with NLB with valid nlb config data.
//
if ( pISpecOther->m_fMisconfigured
|| !pISpecOther->m_NlbCfg.IsValidNlbConfig())
{
TRACE_VERB("%!FUNC!: Skipping misconfigured ISpec with ehInt 0x%lx",
ehIOther);
continue;
}
// Skip the other interface if it's properties are being updated.
//
if (pISpecOther->m_ehPendingOperation != NULL)
{
TRACE_VERB("%!FUNC!: Skipping ISpec with ehInt 0x%lx because of pending OP on it",
ehIOther);
continue;
}
//
// Create the description string of the other adapter.
//
{
WBEMSTATUS wStat;
LPWSTR szAdapter = NULL;
LPCWSTR szHostName = pISpecOther->m_bstrMachineName;
wStat = pISpecOther->m_NlbCfg.GetFriendlyName(&szAdapter);
if (FAILED(wStat))
{
szAdapter = NULL;
}
StringCbPrintf(
rgOtherDescription,
sizeof(rgOtherDescription),
L"%ws(%ws)",
(szHostName==NULL ? L"" : szHostName),
(szAdapter==NULL ? L"" : szAdapter)
);
delete szAdapter;
}
//
// Let's check this host's config with the other host's
//
NLBERROR nerrTmp;
nerrTmp = analyze_nlbcfg(
REF pISpec->m_NlbCfg,
REF pISpecOther->m_NlbCfg,
rgOtherDescription,
FALSE, // FALSE == Check host-specific props
FALSE, // FALSE == Enable remote-control password check
REF logger
);
if (NLBFAILED(nerrTmp))
{
nerr = nerrTmp; // so we don't overwrite failure with success
}
}
}
end:
TRACE_INFO(L"<- %!FUNC! returns 0x%lx", nerr);
return nerr;
}
NLBERROR
analyze_nlbcfg(
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &NlbCfg,
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &OtherNlbCfg,
IN LPCWSTR szOtherDescription, OPTIONAL
IN BOOL fClusterProps,
IN BOOL fDisablePasswordCheck,
IN OUT CLocalLogger &logger
/*
Analyze the NLB configuration NlbCfg against OtherNlbCfg.
If fClusterProps, treat OtherNlbCfg as cluster-wide props, else
treat OtherNlbCfg as the properties of a specific host.
When logging errors to logger, use szOtherDescription to refer to
OtherNlbCfg.
if szOtherDesctiption is NULL, DO NOT log.
Return value:
NLB_OK if the configurations are compatible.
NLBERR_INVALID_CLUSTER_SPECIFICATION if the NlbParams are incompatible.
NLBERR_INVALID_IP_ADDRESS_SPECIFICATION
NLBERR_SUBNET_MISMATCH
NLBERR_NLB_NOT_INSTALLED
or some other NLBERR_XXX error
*/
)
{
NLBERROR nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
BOOL fMisconfigured = FALSE; // Start out assuming no misconfig.
#define LOG(_expr) if (szOtherDescription!=NULL) {_expr;}
if (szOtherDescription != NULL)
{
//
// We'll call ourselves RECURSIVELY just to determine up-front
// if any conflicts were detected.
// This is so we can put a log entry saying that conflicts were
// detected with szOtherDescription.
// Subsequent log entries do not specifiy szOtherDescription.
//
CLocalLogger null_logger;
nerr = analyze_nlbcfg( // RECURSIVE CALL
REF NlbCfg,
REF OtherNlbCfg,
NULL, // NULL == don't log.
fClusterProps,
fDisablePasswordCheck,
REF null_logger
);
if (NLBFAILED(nerr))
{
//
// There was a failure -- so we make a log entry saying so
//
logger.Log(IDS_LOG_CONFIG_CONFLICTS_WITH_OTHER, szOtherDescription);
}
else
{
// looks good...
goto end;
}
}
//
// Check cluster properties
//
{
if (NlbCfg.NlbParams.mcast_support != OtherNlbCfg.NlbParams.mcast_support)
{
LOG(logger.Log(IDS_LOG_CLUSTER_MODE_DIFFERS))
fMisconfigured = TRUE;
}
else if (NlbCfg.NlbParams.mcast_support &&
NlbCfg.NlbParams.fIGMPSupport != OtherNlbCfg.NlbParams.fIGMPSupport)
{
LOG(logger.Log(IDS_LOG_CLUSTER_MULTICAST_MODE_DIFFERS))
fMisconfigured = TRUE;
}
if (wcscmp(NlbCfg.NlbParams.cl_ip_addr, OtherNlbCfg.NlbParams.cl_ip_addr))
{
LOG(logger.Log(IDS_LOG_CIP_DIFFERS))
fMisconfigured = TRUE;
}
if (wcscmp(NlbCfg.NlbParams.cl_net_mask, OtherNlbCfg.NlbParams.cl_net_mask))
{
LOG(logger.Log(IDS_LOG_CIPMASK_DIFFERS))
fMisconfigured = TRUE;
}
if (wcscmp(NlbCfg.NlbParams.domain_name, OtherNlbCfg.NlbParams.domain_name))
{
LOG(logger.Log(IDS_LOG_DOMAIN_NAME_DIFFERS))
fMisconfigured = TRUE;
}
//
// Remote control
//
if (NlbCfg.GetRemoteControlEnabled() !=
OtherNlbCfg.GetRemoteControlEnabled())
{
LOG(logger.Log(IDS_LOG_RCT_DIFFERS))
fMisconfigured = TRUE;
}
else if (NlbCfg.GetRemoteControlEnabled() && !fDisablePasswordCheck)
{
//
// Check the password...
//
DWORD dw = CfgUtilGetHashedRemoteControlPassword(&NlbCfg.NlbParams);
DWORD dw1=CfgUtilGetHashedRemoteControlPassword(&OtherNlbCfg.NlbParams);
if (dw!=dw1)
{
LOG(logger.Log(IDS_LOG_RCT_PWD_DIFFERS, dw, dw1 ))
fMisconfigured = TRUE;
}
}
}
//
// Check port rules.
//
{
WLBS_PORT_RULE *pIRules = NULL;
WLBS_PORT_RULE *pCRules = NULL;
UINT NumIRules=0;
UINT NumCRules=0;
WBEMSTATUS wStat;
wStat = CfgUtilGetPortRules(&NlbCfg.NlbParams, &pIRules, &NumIRules);
if (FAILED(wStat))
{
LOG(logger.Log(IDS_LOG_CANT_EXTRACT_PORTRULES))
fMisconfigured = TRUE;
goto end;
}
wStat = CfgUtilGetPortRules(&OtherNlbCfg.NlbParams, &pCRules, &NumCRules);
if (FAILED(wStat))
{
LOG(logger.Log(IDS_LOG_CANT_EXTRACT_OTHER_PORT_RULES, szOtherDescription))
fMisconfigured = TRUE;
goto end;
}
if (NumIRules != NumCRules)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_COUNT_DIFFERS))
// keep going.
fMisconfigured = TRUE;
}
else
{
//
// Let's assume that the order is the same, because I think it's
// returned sorted.
//
for (UINT u = 0; u< NumIRules; u++)
{
WLBS_PORT_RULE IRule = pIRules[u]; // struct copy
WLBS_PORT_RULE CRule = pCRules[u]; // struct copy
if (lstrcmpi(IRule.virtual_ip_addr, CRule.virtual_ip_addr))
{
LOG(logger.Log(IDS_LOG_PORT_RULE_CIP_DIFFERS,u+1))
fMisconfigured = TRUE;
continue;
}
if (IRule.start_port != CRule.start_port)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_START_DIFFERS, u+1))
fMisconfigured = TRUE;
continue;
}
if (IRule.end_port != CRule.end_port)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_END_DIFFERS, u+1))
fMisconfigured = TRUE;
}
if (IRule.protocol != CRule.protocol)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_PROT_DIFFERS, u+1))
fMisconfigured = TRUE;
}
if (IRule.mode != CRule.mode)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_MODE_DIFFERS, u+1))
fMisconfigured = TRUE;
}
if (IRule.mode == CVY_MULTI)
{
// Check that affinity matches -- none/single/class-C
if (IRule.mode_data.multi.affinity != CRule.mode_data.multi.affinity)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_AFFINITY_DIFFERS, u+1))
fMisconfigured = TRUE;
}
}
if (!fClusterProps && IRule.mode == CVY_SINGLE)
{
if (IRule.mode_data.single.priority
== CRule.mode_data.single.priority)
{
LOG(logger.Log(IDS_LOG_PORT_RULE_PRIORITY_CONFLICT, u+1))
fMisconfigured = TRUE;
}
}
}
}
delete[] pIRules;
delete[] pCRules;
}
//
// Interface checks out against the cluster-wide parameters;
// Now check this interface's parameters against itself -- things
// like the dedicated IP address is bound on the nic itself and is the
// the first address on the NIC, etc.
//
if (!fClusterProps)
{
if (!NlbCfg.IsBlankDedicatedIp())
{
if (!wcscmp(NlbCfg.NlbParams.ded_ip_addr, OtherNlbCfg.NlbParams.ded_ip_addr))
{
//
// Same dedicated ip and it's not blank!
//
LOG(logger.Log(IDS_LOG_DIP_CONFLICT))
fMisconfigured = TRUE;
}
}
// Let's check host priority.
if (NlbCfg.NlbParams.host_priority == OtherNlbCfg.NlbParams.host_priority)
{
LOG(logger.Log(IDS_LOG_HOST_PRIORITY_CONFLICT))
fMisconfigured = TRUE;
}
}
nerr = NLBERR_OK;
end:
if (NLBOK(nerr) && fMisconfigured)
{
nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
}
return nerr;
}
NLBERROR
CNlbEngine::GetInterfaceSpec(
IN ENGINEHANDLE ehInterfaceId,
OUT CInterfaceSpec& refISpec
)
{
// TRACE_INFO(L"-> %!FUNC!");
NLBERROR err = NLBERR_OK;
mfn_Lock();
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehInterfaceId]; // map
if (pISpec == NULL)
{
err = NLBERR_INTERFACE_NOT_FOUND;
}
else
{
refISpec.Copy(*pISpec);
}
mfn_Unlock();
// TRACE_INFO(L"<- %!FUNC!");
return err;
}
VOID
CNlbEngine::mfn_GetLogStrings(
IN WLBS_OPERATION_CODES Operation,
IN LPCWSTR szVip,
IN DWORD * pdwPortNum,
IN DWORD dwOperationStatus,
IN DWORD dwClusterOrPortStatus,
OUT IUICallbacks::LogEntryType & LogLevel,
OUT _bstr_t & OperationStr,
OUT _bstr_t & OperationStatusStr,
OUT _bstr_t & ClusterOrPortStatusStr)
{
if (szVip && pdwPortNum)
{
TRACE_INFO(L"-> %!FUNC! Operation : %d, Vip : %ls, Port : %u, Operation Status : %u, Port Status : %u",
Operation, szVip, *pdwPortNum, dwOperationStatus, dwClusterOrPortStatus);
}
else
{
TRACE_INFO(L"-> %!FUNC! Operation : %d, Operation Status : %u, Cluster Status : %u",
Operation, dwOperationStatus, dwClusterOrPortStatus);
}
struct STATUS_TO_DESCR_MAP
{
DWORD dwStatus;
DWORD dwResourceId;
}
AllNlbStatusToDescrMap[] =
{
// Cluster States
{WLBS_CONVERGING, IDS_STATE_CONVERGING},// Converging
{WLBS_CONVERGED, IDS_STATE_CONVERGED}, // Converged as non-default, we do not specify "default"/"non-default" in the description 'cos there is a
{WLBS_DEFAULT, IDS_STATE_CONVERGED}, // Converged as default, transient case where for a short duration, the default node shows up a non-default
{WLBS_DRAINING, IDS_STATE_CONVERGED_DRAINING}, // Converged, but draining
// Port States
{NLB_PORT_RULE_NOT_FOUND, IDS_PORT_RULE_NOT_FOUND},
{NLB_PORT_RULE_ENABLED, IDS_PORT_RULE_ENABLED},
{NLB_PORT_RULE_DISABLED, IDS_PORT_RULE_DISABLED},
{NLB_PORT_RULE_DRAINING, IDS_PORT_RULE_DRAINING},
// Operation Specific errors
{WLBS_SUSPENDED, IDS_HOST_SUSPENDED}, // start/stop/drain_stop/enable/disable/drain/query-failure-host is suspended
{WLBS_STOPPED, IDS_HOST_STOPPED}, // enable/disable/drain/query-failure-host is already stopped
{WLBS_BAD_PARAMS, IDS_BAD_PARAMS}, // start-failure-host is stopped due to bad parameters
{WLBS_NOT_FOUND, IDS_NOT_FOUND}, // enable/disable/drain-failure-not found
{WLBS_DISCONNECTED, IDS_DISCONNECTED}, // query-failure-media disconnected
// Generic errors
{WLBS_BAD_PASSW, IDS_BAD_PASSWORD}, // *-failure-Bad password
{WLBS_FAILURE, IDS_FAILURE}, // *-failure-critical error
{WLBS_REFUSED, IDS_REFUSED}, // *-failure-request refused by BDA
{WLBS_IO_ERROR, IDS_IO_ERROR}, // *-failure-error trying to connect to nlb driver
// Success values
{WLBS_OK, IDS_EMPTY_STRING}, // Success
{WLBS_ALREADY, IDS_ALREADY}, // host is already in this state
{WLBS_DRAIN_STOP, IDS_DRAIN_STOP}, // was draining
};
struct OPERATION_TO_DESCR_MAP
{
WLBS_OPERATION_CODES Operation;
DWORD dwResourceId;
bool bClusterOperation;
}
OperationToDescrMap[] =
{
{WLBS_START, IDS_COMMAND_START, true},
{WLBS_STOP, IDS_COMMAND_STOP, true},
{WLBS_DRAIN, IDS_COMMAND_DRAINSTOP, true},
{WLBS_SUSPEND, IDS_COMMAND_SUSPEND, true},
{WLBS_RESUME, IDS_COMMAND_RESUME, true},
{WLBS_QUERY, IDS_COMMAND_QUERY, true},
{WLBS_PORT_ENABLE, IDS_COMMAND_ENABLE, false},
{WLBS_PORT_DISABLE, IDS_COMMAND_DISABLE, false},
{WLBS_PORT_DRAIN, IDS_COMMAND_DRAIN, false},
{WLBS_QUERY_PORT_STATE, IDS_COMMAND_QUERY_PORT, false}
};
bool bClusterOperation;
DWORD dwResourceId, dwIdx, dwClusterOrPortResourceId, dwMaxOperations;
WCHAR wcTempStr[1024];
// Initialize log level to Informational
LogLevel = IUICallbacks::LOG_INFORMATIONAL;
// Initialize all return strings to empty string
OperationStr = GETRESOURCEIDSTRING(IDS_EMPTY_STRING);
OperationStatusStr = OperationStr;
ClusterOrPortStatusStr = OperationStr;
// Form the "Operation" string
dwMaxOperations = sizeof(OperationToDescrMap)/sizeof(OperationToDescrMap[0]);
for (dwIdx = 0; dwIdx < dwMaxOperations; dwIdx++)
{
if (OperationToDescrMap[dwIdx].Operation == Operation)
{
dwResourceId = OperationToDescrMap[dwIdx].dwResourceId;
bClusterOperation = OperationToDescrMap[dwIdx].bClusterOperation;
break;
}
}
if (dwIdx == dwMaxOperations)
{
dwResourceId = IDS_UNKNOWN;
bClusterOperation = true; // really a don't care
}
// If a cluster operation, merely assign the string, else (ie. port operation),
// put in the vip & port information as well
if (bClusterOperation)
{
ARRAYSTRCPY(wcTempStr, GETRESOURCEIDSTRING(dwResourceId));
}
else // Port operation
{
if (_wcsicmp(szVip, CVY_DEF_ALL_VIP) == 0)
{
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(dwResourceId), (LPWSTR)GETRESOURCEIDSTRING(IDS_ALL_VIP_DESCR), *pdwPortNum);
}
else
{
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(dwResourceId), szVip, *pdwPortNum);
}
}
OperationStr = wcTempStr;
// Form the "Operation Status" string
// Could take one of the following forms :
// SUCCESS,
// SUCCESS (Note : XXXX),
// FAILURE (Cause : XXXX)
if (dwOperationStatus == WLBS_OK)
{
ARRAYSTRCPY(
wcTempStr,
GETRESOURCEIDSTRING(IDS_SUCCESS_AND_COMMA)
);
}
else if (dwOperationStatus == WLBS_ALREADY)
{
if (bClusterOperation)
{
dwResourceId = IDS_HOST_ALREADY_STATE;
}
else // Port operation
{
dwResourceId = IDS_PORT_ALREADY_STATE;
}
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(IDS_SUCCESS_AND_NOTE), (LPWSTR)GETRESOURCEIDSTRING(dwResourceId)
);
}
else if ((dwOperationStatus == WLBS_DRAIN_STOP)
&& ((Operation == WLBS_START) || (Operation == WLBS_STOP) || (Operation == WLBS_SUSPEND))
)
{
LogLevel = IUICallbacks::LOG_WARNING;
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(IDS_SUCCESS_AND_NOTE), (LPWSTR)GETRESOURCEIDSTRING(IDS_DRAIN_STOP)
);
}
else if ((dwOperationStatus == WLBS_STOPPED)
&& ((Operation == WLBS_DRAIN) || (Operation == WLBS_SUSPEND))
)
{
LogLevel = IUICallbacks::LOG_WARNING;
if (Operation == WLBS_DRAIN)
{
dwResourceId = IDS_ALREADY_STOPPED;
}
else // Suspend
{
dwResourceId = IDS_HOST_STOPPED;
}
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(IDS_SUCCESS_AND_NOTE), (LPWSTR)GETRESOURCEIDSTRING(dwResourceId)
);
}
else // All other operation statuses
{
// We get here only on a failure
LogLevel = IUICallbacks::LOG_ERROR;
dwMaxOperations = sizeof(AllNlbStatusToDescrMap)/sizeof(AllNlbStatusToDescrMap[0]);
// Get the "Cause" string
for (dwIdx = 0; dwIdx < dwMaxOperations; dwIdx++)
{
if (AllNlbStatusToDescrMap[dwIdx].dwStatus == dwOperationStatus)
{
dwResourceId = AllNlbStatusToDescrMap[dwIdx].dwResourceId;
break;
}
}
if (dwIdx == dwMaxOperations)
{
dwResourceId = IDS_UNKNOWN;
}
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(IDS_FAILURE_AND_CAUSE), (LPWSTR)GETRESOURCEIDSTRING(dwResourceId)
);
}
OperationStatusStr = wcTempStr;
// If the operation's status is failure, return
if (LogLevel == IUICallbacks::LOG_ERROR)
{
TRACE_INFO(L"<- %!FUNC!, returning operation status : failure");
return;
}
// Get Cluster or Port Status
if (bClusterOperation)
{
dwClusterOrPortResourceId = IDS_HOST_STATE;
}
else // Port Operation
{
dwClusterOrPortResourceId = IDS_PORT_RULE_STATE;
}
// Get the "ClusterOrPortState" string
dwMaxOperations = sizeof(AllNlbStatusToDescrMap)/sizeof(AllNlbStatusToDescrMap[0]);
for (dwIdx = 0; dwIdx < dwMaxOperations; dwIdx++)
{
if (AllNlbStatusToDescrMap[dwIdx].dwStatus == dwClusterOrPortStatus)
{
dwResourceId = AllNlbStatusToDescrMap[dwIdx].dwResourceId;
break;
}
}
if (dwIdx == dwMaxOperations)
{
dwResourceId = IDS_UNKNOWN;
}
StringCbPrintf(
wcTempStr,
sizeof(wcTempStr),
GETRESOURCEIDSTRING(dwClusterOrPortResourceId), (LPWSTR)GETRESOURCEIDSTRING(dwResourceId)
);
ClusterOrPortStatusStr = wcTempStr;
// Determine if the value returned for Cluster/Port state is valid & if not, set the log level to "error"
if (bClusterOperation)
{
switch(dwClusterOrPortStatus)
{
case WLBS_CONVERGING:
case WLBS_CONVERGED:
case WLBS_DEFAULT:
case WLBS_DRAINING:
case WLBS_STOPPED: // really a failure in the sense of not being able to get the host map, but not flagging it here
case WLBS_SUSPENDED:// 'cos it is a "normal" case
break;
default:
LogLevel = IUICallbacks::LOG_ERROR;
break;
}
}
else // Port operation
{
switch(dwClusterOrPortStatus)
{
case NLB_PORT_RULE_ENABLED:
case NLB_PORT_RULE_DISABLED:
case NLB_PORT_RULE_DRAINING:
break;
default:
LogLevel = IUICallbacks::LOG_ERROR;
break;
}
}
TRACE_INFO(L"<- %!FUNC!");
return;
}
NLBERROR
CNlbEngine::ControlClusterOnInterface(
IN ENGINEHANDLE ehInterfaceId,
IN WLBS_OPERATION_CODES Operation,
IN CString szVipArray[],
IN DWORD pdwPortNumArray[],
IN DWORD dwNumOfPortRules,
IN BOOL fNewOperation
)
{
TRACE_INFO(L"-> %!FUNC!");
LPCWSTR szNicGuid, szHostName, szClusterIp;
NLBERROR err = NLBERR_OK;
CHostSpec *pHSpec = NULL;
CInterfaceSpec *pISpec = NULL;
DWORD dwOperationStatus, dwClusterOrPortStatus, dwHostMap, dwNumOfIterations, dwIdx;
WBEMSTATUS Status;
BOOL bClusterOperation;
IUICallbacks::LogEntryType LogLevel;
_bstr_t OperationStr, OperationStatusStr, ClusterOrPortStatusStr;
BOOL fStopOperationOnExit = FALSE;
if (fNewOperation)
{
//
// This function is to be run in the context of a NEW operation.
// Verify that we can do a control op at this time, and if so, start an
// operation to track the control.
//
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehInterfaceId]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC!: ERROR couldn't get info on this if id!");
goto end_unlock;
}
//
// Now try to start an operation...
//
{
ENGINEHANDLE ExistingOp = NULL;
err = mfn_StartInterfaceOperationLk(
ehInterfaceId,
NULL, // pvCtxt
GETRESOURCEIDSTRING(IDS_LOG_CONTROL_INTERFACE),
&ExistingOp
);
if (NLBFAILED(err))
{
goto end_unlock;
}
//
// We did start the operation -- so we keep track of this, so that
// we stop the operation on exit.
//
fStopOperationOnExit = TRUE;
}
pISpec = NULL;
mfn_Unlock();
}
mfn_Lock();
err = CNlbEngine::mfn_GetHostFromInterfaceLk(ehInterfaceId, REF pISpec, REF pHSpec);
if (err != NLBERR_OK)
{
TRACE_CRIT(L"%!FUNC! could not get pISpec,pHSpec for ehIF 0x%lx", ehInterfaceId);
goto end_unlock;
}
WMI_CONNECTION_INFO ConnInfo;
ConnInfo.szUserName = (LPCWSTR) pHSpec->m_UserName;
ConnInfo.szPassword = (LPCWSTR) pHSpec->m_Password;
ConnInfo.szMachine = (LPCWSTR) pHSpec->m_ConnectionString;
szNicGuid = (LPCWSTR)(pISpec->m_Guid);
szClusterIp= pISpec->m_NlbCfg.NlbParams.cl_ip_addr;
szHostName = (LPCWSTR)(pHSpec->m_MachineName);
if (szNicGuid == NULL)
{
TRACE_CRIT(L"%!FUNC! ERROR -- NULL szNicGuid!");
goto end_unlock;
}
mfn_Unlock();
if (dwNumOfPortRules == 0)
{
bClusterOperation = TRUE;
dwNumOfIterations = 1;
}
else // Port operation
{
bClusterOperation = FALSE;
dwNumOfIterations = dwNumOfPortRules;
}
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
NULL, // ehClusterId,
ehInterfaceId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
for (dwIdx = 0 ; dwIdx < dwNumOfIterations ; dwIdx++)
{
LPCWSTR szVip = (szVipArray) ? (LPCTSTR)(szVipArray[dwIdx]) : NULL;
DWORD *pdwPortNum = (pdwPortNumArray) ? &pdwPortNumArray[dwIdx] : NULL;
Status = NlbHostControlCluster(&ConnInfo,
szNicGuid,
szVip,
pdwPortNum,
Operation,
&dwOperationStatus,
&dwClusterOrPortStatus,
&dwHostMap);
if (FAILED(Status))
{
if (Status == WBEM_E_INVALID_PARAMETER)
{
err = NLBERR_INVALID_CLUSTER_SPECIFICATION;
dwOperationStatus = WLBS_BAD_PARAMS;
}
else // Critical Error
{
err = NLBERR_INTERNAL_ERROR;
dwOperationStatus = WLBS_FAILURE;
}
}
// Get the strings to log into log view
mfn_GetLogStrings(Operation,
szVip,
pdwPortNum,
dwOperationStatus,
dwClusterOrPortStatus,
REF LogLevel,
REF OperationStr,
REF OperationStatusStr,
REF ClusterOrPortStatusStr
);
// If operation is NOT Query, Log result in Log View
// We do NOT log results of a Query 'cos this is done for a "Refresh"
// and we do not want to tell what is happening underneath. Instead,
// the change in color coding will reflect any changes to the cluster state.
if (Operation != WLBS_QUERY)
{
m_pCallbacks->Log(LogLevel,
szClusterIp,
szHostName,
IDS_LOG_CONTROL_CLUSTER,
(LPWSTR)OperationStr,
(LPWSTR)OperationStatusStr,
(LPWSTR)ClusterOrPortStatusStr);
ProcessMsgQueue();
}
}
mfn_Lock();
if (bClusterOperation)
{
pISpec->m_fValidClusterState = TRUE;
pISpec->m_dwClusterState = dwClusterOrPortStatus;
}
end_unlock:
if (fStopOperationOnExit)
{
mfn_StopInterfaceOperationLk(ehInterfaceId);
}
mfn_Unlock();
if (fStopOperationOnExit)
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
NULL, // ehClusterId,
ehInterfaceId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
}
TRACE_INFO(L"<- %!FUNC! return : %u", err);
return err;
}
NLBERROR
CNlbEngine::ControlClusterOnCluster(
IN ENGINEHANDLE ehClusterId,
IN WLBS_OPERATION_CODES Operation,
IN CString szVipArray[],
IN DWORD pdwPortNumArray[],
IN DWORD dwNumOfPortRules
)
/*
Perform Cluster wide control operations
*/
{
TRACE_INFO(L"-> %!FUNC!");
NLBERROR nerr = NLBERR_OK;
BOOL fStopOperationOnExit = FALSE;
vector<ENGINEHANDLE> InterfaceListCopy;
//
// First thing we do is to see if we can start the cluster operation...
//
{
BOOL fCanStart = FALSE;
nerr = this->CanStartClusterOperation(ehClusterId, REF fCanStart);
if (NLBFAILED(nerr))
{
goto end;
}
if (!fCanStart)
{
nerr = NLBERR_BUSY;
goto end;
}
}
{
mfn_Lock();
CClusterSpec *pCSpec = NULL;
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end_unlock;
}
pCSpec = &pECluster->m_cSpec;
//
// Attempt to start the refresh operation -- will fail if there is
// already an operation started on this cluster.
//
{
ENGINEHANDLE ExistingOp= NULL;
CLocalLogger logDescription;
logDescription.Log(
IDS_LOG_CONTROL_CLUSTER_OPERATION_DESCRIPTION,
pCSpec->m_ClusterNlbCfg.NlbParams.cl_ip_addr
);
nerr = mfn_StartClusterOperationLk(
ehClusterId,
NULL, // pvCtxt
logDescription.GetStringSafe(),
&ExistingOp
);
if (NLBFAILED(nerr))
{
goto end_unlock;
}
else
{
fStopOperationOnExit = TRUE;
}
}
InterfaceListCopy = pCSpec->m_ehInterfaceIdList; // vector copy
mfn_Unlock();
}
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehClusterId,
ehClusterId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
mfn_Lock();
{
//
// Perform control operation on each interface in this cluster...
//
for( int i = 0; i < InterfaceListCopy.size(); ++i )
{
ENGINEHANDLE ehIId = InterfaceListCopy[i];
mfn_Unlock();
nerr = this->ControlClusterOnInterface(
ehIId,
Operation,
szVipArray,
pdwPortNumArray,
dwNumOfPortRules,
TRUE
);
mfn_Lock();
}
}
end_unlock:
if (fStopOperationOnExit)
{
//
// We'll stop the operation, assumed to be started in this function.
//
mfn_StopClusterOperationLk(ehClusterId);
}
mfn_Unlock();
if (fStopOperationOnExit)
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehClusterId,
ehClusterId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
}
end:
TRACE_INFO(L"<- %!FUNC! return : %u", nerr);
return nerr;
}
NLBERROR
CNlbEngine::FindInterfaceOnHostByClusterIp(
IN ENGINEHANDLE ehHostId,
IN LPCWSTR szClusterIp, // OPTIONAL
OUT ENGINEHANDLE &ehInterfaceId, // first found
OUT UINT &NumFound
)
/*
Return the handle of the interface on the specified host that is
bound to a cluster with the specified cluster IP address.
*/
{
CHostSpec *pHSpec = NULL;
NLBERROR err = NLBERR_OK;
UINT uClusterIp = 0;
WBEMSTATUS wStat;
ENGINEHANDLE ehFoundIID = NULL;
UINT MyNumFound = 0;
ehInterfaceId = NULL;
NumFound = 0;
mfn_Lock();
if (szClusterIp != NULL)
{
wStat = CfgUtilsValidateNetworkAddress(
szClusterIp,
&uClusterIp,
NULL, // puSubnetMask
NULL // puDefaultSubnetMask
);
if (FAILED(wStat))
{
TRACE_CRIT("%!FUNC! invalid szClusterIp (%ws) specified", szClusterIp);
err = NLBERR_INVALID_IP_ADDRESS_SPECIFICATION;
goto end;
}
}
pHSpec = m_mapIdToHostSpec[ehHostId]; // map
if (pHSpec == NULL)
{
err = NLBERR_HOST_NOT_FOUND;
goto end;
}
//
// Now look through the interfaces, searching for a cluster ip.
//
for( int i = 0; i < pHSpec->m_ehInterfaceIdList.size(); ++i )
{
ENGINEHANDLE ehIID = NULL;
ehIID = pHSpec->m_ehInterfaceIdList[i];
CInterfaceSpec *pISpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIID]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC! unexpected null pISpec for IID 0x%lx", ehIID);
continue;
}
if (szClusterIp == NULL)
{
if (pISpec->m_NlbCfg.IsNlbBound())
{
MyNumFound++;
if (ehFoundIID == NULL)
{
//
// First interface bound to NLB -- we'll save this away.
// and continue.
//
ehFoundIID = ehIID;
}
}
continue;
}
//
// A non-null szClusterIp is specified. We'll see if it matches
// the cluster IP (if any) on this interface.
//
if (pISpec->m_NlbCfg.IsValidNlbConfig())
{
UINT uThisClusterIp = 0;
LPCWSTR szThisClusterIp = pISpec->m_NlbCfg.NlbParams.cl_ip_addr;
wStat = CfgUtilsValidateNetworkAddress(
szThisClusterIp,
&uThisClusterIp,
NULL, // puSubnetMask
NULL // puDefaultSubnetMask
);
if (FAILED(wStat))
{
continue;
}
if (uThisClusterIp == uClusterIp)
{
MyNumFound++;
if (ehFoundIID == NULL)
{
//
// First interface bound to NLB -- we'll save this away.
// and continue.
//
ehFoundIID = ehIID;
}
else
{
//
// Hmm... more than one nlb cluster with the same IP?
// could be a bad config on one or both.
//
TRACE_CRIT("%!FUNC! two clusters on ehHost 0x%lx have cluster ip %ws", ehHostId, szClusterIp);
}
}
}
}
if (MyNumFound != 0)
{
ASSERT(ehFoundIID != NULL);
ehInterfaceId = ehFoundIID;
NumFound = MyNumFound;
err = NLBERR_OK;
}
else
{
err = NLBERR_INTERFACE_NOT_FOUND;
}
end:
mfn_Unlock();
return err;
}
NLBERROR
CNlbEngine::InitializeNewHostConfig(
IN ENGINEHANDLE ehCluster,
OUT NLB_EXTENDED_CLUSTER_CONFIGURATION &NlbCfg
)
/*
Initialize NlbCfg based on the current cluster parameters as well
as good host-specific defaults like host priority, taking into account
other members of the cluster.
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
WBEMSTATUS wStatus = WBEM_E_CRITICAL_ERROR;
WLBS_PORT_RULE *pRules = NULL;
BOOL fAvailablePortRulePrioritiesSet = FALSE;
//
// Get the cluster spec and copy over it to NlbCfg.
//
{
mfn_Lock();
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
mfn_Unlock();
goto end;
}
//
// Copy over the cluster spec's params.
//
wStatus = NlbCfg.Update(&pECluster->m_cSpec.m_ClusterNlbCfg);
mfn_Unlock();
}
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC! Error copying over cluster params ehC=0x%lx",
ehCluster);
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
if(!NlbCfg.IsValidNlbConfig()) {
//
// We expect the configuration to be valid -- i.e., NLB bound, with
// valid parameters.
//
TRACE_CRIT("%!FUNC! -- current configuration is unbound/invalid!");
goto end;
}
//
// Set host-id (priority) to the first available host priority.
//
{
ULONG AvailablePriorities = this->GetAvailableHostPriorities(ehCluster);
ULONG HostId = 1;
for(ULONG u=0; u<32; u++)
{
if (AvailablePriorities & (((ULONG)1)<<u))
{
HostId = u+1; // let's pick the first available one.
break;
}
}
NlbCfg.NlbParams.host_priority = HostId;
}
//
// For each single-host-affinity port rule, set the host priority to
// the host-id if that's available, else the first available host priority
//
{
UINT NumRules=0;
ULONG rgAvailablePriorities[WLBS_MAX_RULES];
ZeroMemory(rgAvailablePriorities, sizeof(rgAvailablePriorities));
wStatus = CfgUtilGetPortRules(
&NlbCfg.NlbParams,
&pRules,
&NumRules
);
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC! error 0x%08lx extracting port rules!", wStatus);
pRules = NULL;
goto end;
}
nerr = this->GetAvailablePortRulePriorities(
ehCluster,
NumRules,
pRules,
rgAvailablePriorities
);
if (NLBOK(nerr))
{
fAvailablePortRulePrioritiesSet = TRUE;
}
else
{
fAvailablePortRulePrioritiesSet = FALSE;
}
//
// Now for each rule, put defaults
//
for (UINT u=0; u<NumRules;u++)
{
WLBS_PORT_RULE *pRule = pRules+u;
UINT Mode = pRule->mode;
if (Mode != CVY_NEVER)
{
if (Mode == CVY_MULTI)
{
pRule->mode_data.multi.equal_load = TRUE; //default
//
// The equal_load value is set in the cluster
// properties dialog.
//
pRule->mode_data.multi.load = 50;
}
else if (Mode == CVY_SINGLE)
{
ULONG PortPriority = 0;
ULONG AvailablePriorities = 0;
//
// Default is set to this host's host ID (priority)
//
PortPriority = NlbCfg.NlbParams.host_priority;
if (fAvailablePortRulePrioritiesSet)
{
AvailablePriorities = rgAvailablePriorities[u];
}
if (AvailablePriorities != 0
&& 0 == ((1<<(PortPriority-1)) & AvailablePriorities) )
{
//
// There are available priorities, but unfortunately
// the default priority is not available -- pick
// the first available priority.
//
for(ULONG v=0; v<32; v++)
{
if (AvailablePriorities & (((ULONG)1)<<v))
{
PortPriority = v+1; // let's pick this one
break;
}
}
}
pRule->mode_data.single.priority = PortPriority;
}
}
}
//
// Finally, set the port rules..
//
wStatus = CfgUtilSetPortRules(
pRules,
NumRules,
&NlbCfg.NlbParams
);
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC! error 0x%08lx setting port rules!", wStatus);
goto end;
}
nerr = NLBERR_OK;
}
end:
delete pRules; // can be NULL
return nerr;
}
NLBERROR
CNlbEngine::UpdateInterface(
IN ENGINEHANDLE ehInterfaceId,
IN NLB_EXTENDED_CLUSTER_CONFIGURATION &refNewConfigIn,
// IN OUT BOOL &fClusterPropertiesUpdated,
OUT CLocalLogger logConflict
)
{
/*
Will MUNGE refNewConfig -- slightly munges refNewConfig.NlbParams,
and will fill in default pIpAddressInfo if it's not set.
*/
NLBERROR err = NLBERR_OK;
BOOL fConnectivityChange = FALSE;
BOOL fStopOperationOnExit= FALSE;
NLB_EXTENDED_CLUSTER_CONFIGURATION
*pPendingConfig = NULL;
LPCWSTR szHostName = NULL;
LPCWSTR szClusterIp = NULL;
LPCWSTR szDisplayName = NULL; // of interface
ENGINEHANDLE ehHost = NULL;
ENGINEHANDLE ehCluster = NULL;
_bstr_t bstrFriendlyName;
_bstr_t bstrDisplayName;
_bstr_t bstrHostName;
//
// Following to decide whether to log that we're not adding the
// dedicated IP because it's already on another interface.
//
BOOL fDedicatedIpOnOtherIf = FALSE;
ENGINEHANDLE ehOtherIf = NULL;
TRACE_INFO(L"-> %!FUNC!");
err = this->GetInterfaceIdentification(
ehInterfaceId,
REF ehHost,
REF ehCluster,
REF bstrFriendlyName,
REF bstrDisplayName,
REF bstrHostName
);
if (NLBFAILED(err))
{
goto end;
}
szDisplayName = bstrDisplayName;
szHostName = bstrHostName;
if (szDisplayName == NULL)
{
szDisplayName = L"";
}
if (szHostName == NULL)
{
szHostName = L"";
}
mfn_Lock();
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehInterfaceId]; // map
if (pISpec == NULL)
{
err = NLBERR_INTERFACE_NOT_FOUND;
goto end_unlock;
}
//
// Make a copy of refNewConfig, because we'll likely be doing
// the update operation in the background.
//
pPendingConfig = new NLB_EXTENDED_CLUSTER_CONFIGURATION;
if (pPendingConfig == NULL)
{
err = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end_unlock;
}
else
{
WBEMSTATUS wStat1;
wStat1 = pPendingConfig->Update(&refNewConfigIn);
if (FAILED(wStat1))
{
delete pPendingConfig;
pPendingConfig = NULL;
err = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end_unlock;
}
//
// Copy over the RCT password -- which does NOT get copied over
// by the Update method above. The new password can be in the form
// of a string or hashed-version.
//
//
if (refNewConfigIn.NewRemoteControlPasswordSet())
{
LPCWSTR szNewPassword = NULL;
szNewPassword = refNewConfigIn.GetNewRemoteControlPasswordRaw();
if (szNewPassword != NULL)
{
//
// Note: szNewPassword will be NULL UNLESS the user has explicitly
// specified a new password.
//
pPendingConfig->SetNewRemoteControlPassword(szNewPassword);
}
else
{
//
// This means the hash password is being updated...
// This typically means that this is a new host and we're
// setting up it's remote control password.
//
DWORD dwHash = 0;
BOOL fRet = refNewConfigIn.GetNewHashedRemoteControlPassword(
REF dwHash
);
if (fRet)
{
pPendingConfig->SetNewHashedRemoteControlPassword(
dwHash
);
}
else
{
TRACE_CRIT("refNewConfigIn fNewPassword set; but could not get either szPassword or new hashed password!");
}
}
}
}
NLB_EXTENDED_CLUSTER_CONFIGURATION &refNewConfig = *pPendingConfig;
szClusterIp = refNewConfig.NlbParams.cl_ip_addr;
//
// Attempt to start the update operation -- will fail if there is
// already an operation started on this interface.
//
{
ENGINEHANDLE ExistingOp= NULL;
CLocalLogger logDescription;
logDescription.Log(
IDS_LOG_UPDATE_INTERFACE_OPERATION_DESCRIPTION,
szDisplayName
);
err = mfn_StartInterfaceOperationLk(
ehInterfaceId,
pPendingConfig,
logDescription.GetStringSafe(),
&ExistingOp
);
if (NLBFAILED(err))
{
if (err == NLBERR_BUSY)
{
//
// This means that there was an existing operation.
// Let's get its description and add it to the log.
//
CEngineOperation *pExistingOp;
pExistingOp = mfn_GetOperationLk(ExistingOp);
if (pExistingOp != NULL)
{
LPCWSTR szDescrip = pExistingOp->bstrDescription;
if (szDescrip == NULL)
{
szDescrip = L"";
}
logConflict.Log(
IDS_LOG_OPERATION_PENDING_ON_INTERFACE,
szDescrip
);
}
}
goto end_unlock;
}
else
{
fStopOperationOnExit = TRUE;
}
}
ehHost = pISpec->m_ehHostId;
//
// Validate new config and get out if there's no real updating to
// be done.
//
{
if (refNewConfig.IsNlbBound())
{
if (refNewConfig.NumIpAddresses==0)
{
refNewConfig.fAddClusterIps = TRUE;
refNewConfig.fAddDedicatedIp = TRUE;
}
else
{
//
// refNewConfig has a non-null IP address list.
//
// We interpret this to be the list of cluster IP addresses
// with possibly the dedicated ip address as the
// first IP address.
//
//
// We'll re-order the ip address list to match the
// existing order of IP addresses on the adapter as
// far as possible.
//
// Then we'll add the dedicated IP address list if we
// need to.
//
BOOL fRet = FALSE;
NlbIpAddressList addrList;
//
// Make a copy of the old adddress list in addrList
//
fRet = addrList.Set(pISpec->m_NlbCfg.NumIpAddresses,
pISpec->m_NlbCfg.pIpAddressInfo, 1);
if (!fRet)
{
TRACE_CRIT(L"Unable to copy old IP address list");
err = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end_unlock;
}
//
// addrList.Apply will taken on the new ip address list,
// but try to preserve the old order.
//
fRet = addrList.Apply(refNewConfig.NumIpAddresses,
refNewConfig.pIpAddressInfo);
if (!fRet)
{
TRACE_CRIT(L"Unable to apply new IP address list");
err = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end_unlock;
}
//
// If there is a dedicated IP address AND it
// does not exist elsewhere on this host, add it to
// the beginning of the list.
//
if (!refNewConfig.IsBlankDedicatedIp())
{
ENGINEHANDLE ehIF = NULL;
err = this->mfn_LookupInterfaceByIpLk(
NULL, // NULL == look through all hosts.
refNewConfig.NlbParams.ded_ip_addr,
REF ehOtherIf
);
if (NLBOK(err) && ehOtherIf != ehInterfaceId)
{
//
// Hmm... another interface already has this
// interface?
//
// We'll log this and NOT add the dedicated IP
// address...
//
fDedicatedIpOnOtherIf = TRUE;
(VOID) addrList.Modify(
refNewConfig.NlbParams.ded_ip_addr,
NULL,
NULL
);
}
else
{
fRet = addrList.Modify(
NULL,
refNewConfig.NlbParams.ded_ip_addr,
refNewConfig.NlbParams.ded_net_mask
);
if (!fRet)
{
TRACE_CRIT(L"Unable to add ded IP to addr list");
err = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end_unlock;
}
}
}
//
// Set refNewConfig's ip address list to the newly
// computed values.
//
refNewConfig.SetNetworkAddressesRaw(NULL,0);
addrList.Extract(
REF refNewConfig.NumIpAddresses,
REF refNewConfig.pIpAddressInfo
);
}
}
err = pISpec->m_NlbCfg.AnalyzeUpdate(
&refNewConfig,
&fConnectivityChange
);
if (err == NLBERR_NO_CHANGE)
{
//
// Nothing has changed -- we skip
//
err = NLBERR_OK;
goto end_unlock;
}
//
// err could indicate failure -- we'll deal with that a little
// bit further down.
//
} // validate/munge refNewConfig
if (!NLBOK(err))
{
mfn_Unlock();
//
// Probably a parameter error -- we'll get the latest
// config and display it...
//
m_pCallbacks->Log(
IUICallbacks::LOG_ERROR,
szClusterIp,
szHostName,
IDS_LOG_CANT_UPDATE_BAD_PARAMS
);
(void) this->RefreshInterface(
ehInterfaceId,
FALSE, // FALSE == don't start a new operation
FALSE // FALSE == this is not cluster-wide
);
mfn_Lock();
goto end_unlock;
}
mfn_Unlock();
if (fDedicatedIpOnOtherIf)
{
LPCWSTR szOtherIf = NULL;
_bstr_t bstrOtherFriendlyName;
_bstr_t bstrOtherDisplayName;
_bstr_t bstrOtherHostName;
ENGINEHANDLE ehOtherHost;
ENGINEHANDLE ehOtherCluster;
NLBERROR tmpErr;
IUICallbacks::LogEntryType logType = IUICallbacks::LOG_WARNING;
tmpErr = this->GetInterfaceIdentification(
ehOtherIf,
REF ehOtherHost,
REF ehOtherCluster,
REF bstrOtherFriendlyName,
REF bstrOtherDisplayName,
REF bstrOtherHostName
);
if (NLBOK(tmpErr))
{
if (ehOtherHost != ehHost)
{
// Odd -- ded ip on another host?
logType = IUICallbacks::LOG_ERROR;
szOtherIf = bstrOtherDisplayName; // includes host name
}
else
{
szOtherIf = bstrOtherFriendlyName;
}
}
if (szOtherIf == NULL)
{
szOtherIf = L"";
}
//
// Let's log the fact that the dedicated Ip address is
// on some other interface.
//
TRACE_INFO(L"WARNING: dedicated IP address for eIF 0x%lx is on eIF 0x%lx",
ehInterfaceId, ehOtherIf);
m_pCallbacks->Log(
IUICallbacks::LOG_INFORMATIONAL,
szClusterIp,
szHostName,
IDS_LOG_DEDICATED_IP_ON_OTHER_INTERFACE,
refNewConfig.NlbParams.ded_ip_addr,
szOtherIf
);
}
if (!fConnectivityChange)
{
//
// If there's not going to be a connectivity change, we
// will not try to update the IP address list.
//
refNewConfig.SetNetworkAddresses(NULL, 0);
if (refNewConfig.IsNlbBound())
{
refNewConfig.fAddClusterIps = TRUE;
refNewConfig.fAddDedicatedIp = TRUE;
}
}
//
// Notify the UI that we're going to start the update
//
{
m_pCallbacks->Log(
IUICallbacks::LOG_INFORMATIONAL,
szClusterIp,
szHostName,
IDS_LOG_BEGIN_HOST_UPDATE
);
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
NULL, // ehClusterId,
ehInterfaceId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
}
#if BUGFIX334243
BOOL fUpdateNow = FALSE;
#else // !BUGFIX334243
BOOL fUpdateNow = TRUE;
#endif // !BUGFIX334243
//
// We are committed to going through with the update now -- either
// sync or async.
//
InterlockedIncrement(&m_WorkItemCount);
fStopOperationOnExit = FALSE;
//
// We MUST call UpdateInterfaceWorItemRoutine now (either sync or async),
// which will stop the operation when done and also decrement
// m_mWorkItemCount.
//
if (!fUpdateNow)
{
BOOL fRet;
//
// We'll attempt to perform the update in the background ...
//
fRet = QueueUserWorkItem(
UpdateInterfaceWorkItemRoutine,
(PVOID) (UINT_PTR) ehInterfaceId,
WT_EXECUTELONGFUNCTION
);
if (fRet)
{
fUpdateNow = FALSE;
}
else
{
fUpdateNow = TRUE; // Update now if QueueUsesrWorkItem fails.
}
}
if (fUpdateNow)
{
//
// Call the work item synchronously
//
UpdateInterfaceWorkItemRoutine((LPVOID) (UINT_PTR) ehInterfaceId);
}
goto end;
end_unlock:
if (fStopOperationOnExit)
{
//
// We'll stop the operation, assumed to be started in this function.
//
mfn_StopInterfaceOperationLk(ehInterfaceId);
fStopOperationOnExit = FALSE;
}
mfn_Unlock();
end:
ASSERT(!fStopOperationOnExit);
TRACE_INFO(L"<- %!FUNC!");
return err;
}
NLBERROR
CNlbEngine::UpdateCluster(
IN ENGINEHANDLE ehClusterId,
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION *pNewConfig OPTIONAL,
IN OUT CLocalLogger &logConflict
)
/*
Attempt to push all the cluster-wide (i.e. non-host-specific)
information on *pNewConfig to each host in the cluster.
Update the cluster's copy of NlbConfig to be *pNewConfig.
Set cluster's pending state on starting and set it
appropriately when done (could be misconfigured).
*/
{
NLBERROR nerr = NLBERR_OK;
_bstr_t bstrClusterIp;
TRACE_INFO(L"-> %!FUNC!");
vector<ENGINEHANDLE> InterfaceListCopy;
BOOL fStopOperationOnExit = FALSE;
//
// First thing we do is to see if we can start the cluster operation...
//
if (pNewConfig != NULL)
{
BOOL fCanStart = FALSE;
nerr = this->CanStartClusterOperation(ehClusterId, REF fCanStart);
if (NLBFAILED(nerr))
{
goto end;
}
if (!fCanStart)
{
nerr = NLBERR_BUSY;
goto end;
}
}
{
mfn_Lock();
CClusterSpec *pCSpec = NULL;
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end_unlock;
}
pCSpec = &pECluster->m_cSpec;
//
// Attempt to start the update operation -- will fail if there is
// already an operation started on this cluster.
//
{
ENGINEHANDLE ExistingOp= NULL;
CLocalLogger logDescription;
logDescription.Log(
IDS_LOG_UPDATE_CLUSTER_OPERATION_DESCRIPTION,
pCSpec->m_ClusterNlbCfg.NlbParams.cl_ip_addr
);
nerr = mfn_StartClusterOperationLk(
ehClusterId,
NULL, // pvCtxt
logDescription.GetStringSafe(),
&ExistingOp
);
if (NLBFAILED(nerr))
{
if (nerr == NLBERR_BUSY)
{
//
// This means that there was an existing operation.
// Let's get its description and add it to the log.
//
CEngineOperation *pExistingOp;
pExistingOp = mfn_GetOperationLk(ExistingOp);
if (pExistingOp != NULL)
{
LPCWSTR szDescrip = pExistingOp->bstrDescription;
if (szDescrip == NULL)
{
szDescrip = L"";
}
logConflict.Log(
IDS_LOG_OPERATION_PENDING_ON_CLUSTER,
szDescrip
);
}
}
goto end_unlock;
}
else
{
fStopOperationOnExit = TRUE;
}
}
if (pNewConfig != NULL)
{
pCSpec->m_ClusterNlbCfg.Update(pNewConfig); // TODO: error ret
//
// Note: Update above has the side effect of setting
// m_ClusterNlbCfg's szNewPassword field to NULL -- this is what
// we want. However, we do mark the fact that the
// password is new -- because the cluster's version of the
// hashed-password is now obsolete -- it needs to be updated
// by reading one of the hosts' versions.
// pCSpec->m_fNewRctPassword track this state.
//
if (pNewConfig->GetNewRemoteControlPasswordRaw() != NULL)
{
pCSpec->m_fNewRctPassword = TRUE;
//
// The above flag will be cleared (and the hashed password
// value updated) at the end of the
// first update operation for one of the interfaces.
//
// It is also cleared when the cluster properties are
// updated as part of a refresh operation.
//
}
}
bstrClusterIp = _bstr_t(pCSpec->m_ClusterNlbCfg.NlbParams.cl_ip_addr);
InterfaceListCopy = pCSpec->m_ehInterfaceIdList; // vector copy
mfn_Unlock();
}
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehClusterId,
ehClusterId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
mfn_Lock();
BOOL fRetryUpdateCluster = FALSE;
do
{
LPCWSTR szClusterIp = bstrClusterIp;
UINT uNumModeChanges = 0; // number of IF's undergoing mode changes.
UINT uNumUpdateErrors = 0; // number of IF's with update errors.
//
// fClusterPropertiesUpdated keeps track of whether the cluster
// properties were updated as a course of refreshing and or updating
// the interface -- we update the cluster props at most once:
// for the first interface that successfully performs the update
// (or if pNewConfig == NULL) for the first interface that
// successfully refreshes its properties AND is still bound.
//
//
BOOL fClusterPropertiesUpdated = FALSE;
//
// Update each interface in this cluster...
//
for( int i = 0; i < InterfaceListCopy.size(); ++i )
{
CInterfaceSpec TmpISpec;
_bstr_t bstrHostName = L"";
ENGINEHANDLE ehIId = InterfaceListCopy[i];
mfn_GetInterfaceHostNameLk(
ehIId,
REF bstrHostName
);
mfn_Unlock();
//
// Get the latest interface information and (if
// pNewConfig != NULL) merge in the cluster information.
//
{
BOOL fSkipHost = TRUE;
if (pNewConfig == NULL)
{
//
// This is a REFRESH CLUSTER operation
//
nerr = this->RefreshInterface(ehIId, TRUE, TRUE);
if (NLBOK(nerr))
{
//
// Let's update the cluster-wide properties with
// this interface if:
//
// 1. We haven't already updated the props in this
// loop.
//
// 2. The above interface is bound to NLB,
// and the IP address matches
// the clusters' ip address.
//
if (!fClusterPropertiesUpdated)
{
fClusterPropertiesUpdated = mfn_UpdateClusterProps(
ehClusterId,
ehIId
);
}
}
}
else
{
//
// This is a CHANGE CLUSTER CONFIGURATION operation
// Let's first get the latest version of this interface'
// properties.
//
nerr = this->mfn_RefreshInterface(ehIId);
}
//
// If this fails, we don't try to update. Instead
// we send a log message and continue.
// Note: RefreshInterface will send an interface-status
// change machine.
//
if (nerr == NLBERR_OK)
{
nerr = this->GetInterfaceSpec(ehIId, REF TmpISpec);
if (nerr == NLBERR_OK)
{
fSkipHost = FALSE;
}
}
if (!fSkipHost && pNewConfig != NULL)
{
if (pNewConfig->fBound)
{
NLB_EXTENDED_CLUSTER_CONFIGURATION *pOldConfig
= &TmpISpec.m_NlbCfg;
//
// Check if there is a mode change involved...
// because if so, the provider will not add
// any cluster IP addresses.
//
// We keep track of all IFs with mode changes, and
// if any, we'll do this whole cluster-wide update
// process a 2nd time, at which time the IP addresses
// will be added.
//
if (pOldConfig->IsValidNlbConfig())
{
NLB_EXTENDED_CLUSTER_CONFIGURATION::TRAFFIC_MODE tmOld, tmNew;
tmOld = pOldConfig->GetTrafficMode();
tmNew = pNewConfig->GetTrafficMode();
if (tmOld != tmNew)
{
// Mode change!
uNumModeChanges++;
TRACE_INFO(L"%!FUNC!: ehIF 0x%lx: Detected mode change!\n", ehIId);
}
}
//
// Merge in the cluster-specific information
//
nerr = ApplyClusterWideConfiguration(
REF *pNewConfig,
REF TmpISpec.m_NlbCfg
);
if (nerr != NLBERR_OK)
{
fSkipHost = TRUE;
}
}
else
{
//
// We're asked to unbind all hosts!
//
TmpISpec.m_NlbCfg.fAddDedicatedIp = FALSE;
TmpISpec.m_NlbCfg.SetNetworkAddresses(NULL, 0);
TmpISpec.m_NlbCfg.SetNlbBound(FALSE);
if (!TmpISpec.m_NlbCfg.IsBlankDedicatedIp())
{
WCHAR rgBuf[64];
LPCWSTR szAddr = rgBuf;
StringCbPrintf(
rgBuf,
sizeof(rgBuf),
L"%ws/%ws",
TmpISpec.m_NlbCfg.NlbParams.ded_ip_addr,
TmpISpec.m_NlbCfg.NlbParams.ded_net_mask
);
TmpISpec.m_NlbCfg.SetNetworkAddresses(&szAddr, 1);
}
}
}
if (fSkipHost && pNewConfig != NULL)
{
TRACE_CRIT(L"%!FUNC!: Couldn't get latest interface spec when trying to update cluster");
m_pCallbacks->Log(
IUICallbacks::LOG_ERROR,
szClusterIp,
(LPCWSTR) bstrHostName,
IDS_LOG_SKIP_INTERFACE_UPDATE_ON_ERROR, // "...%lx"
nerr // TODO -- replace by textual description.
);
mfn_Lock();
uNumUpdateErrors++;
continue;
}
}
//
// Actually update the interface -- likely it will complete
// in the background.
//
if (pNewConfig != NULL)
{
CLocalLogger logConflict;
nerr = this->UpdateInterface(
ehIId,
REF TmpISpec.m_NlbCfg,
// REF fClusterPropertiesUpdated,
REF logConflict
);
}
mfn_Lock();
}
//
// If there are mode changes for one-or-more nodes, we'll need
// to wait for ALL updates to complete, and then try again.
//
if (uNumUpdateErrors!=0)
{
nerr = NLBERR_OPERATION_FAILED;
}
else
{
if (fRetryUpdateCluster && uNumModeChanges!=0)
{
//
// We're gone through a 2nd time and STILL there are
// mode changes! We bail.
//
TRACE_CRIT(L"%!FUNC! ehC 0x%lx: %lu Mode changes on 2nd phase. Bailing", ehClusterId, uNumModeChanges);
nerr = NLBERR_OPERATION_FAILED;
}
else
{
nerr = NLBERR_OK;
}
}
fRetryUpdateCluster = FALSE;
if (NLBOK(nerr) && uNumModeChanges!=0)
{
BOOL fSameMode = FALSE;
//
// There were one or more mode changes!
// Let's wait for *all* updates to complete successfully.
// Then we'll check to make sure that the modes on all
// hosts match the cluster IP address' modes. If they do
// (and there were no update errors), we'll re-run the
// update process, this time hopefully adding
// the IP addresses that would have been stripped had there been
// mode changes.
//
mfn_Unlock();
nerr = mfn_WaitForInterfaceOperationCompletions(ehClusterId);
mfn_Lock();
if (NLBOK(nerr))
{
nerr = mfn_VerifySameModeLk(ehClusterId, REF fSameMode);
}
if (NLBOK(nerr) && fSameMode)
{
TRACE_CRIT(L"%!FUNC! chC 0x%lx: SECOND PHASE on CHANGE MODE",
ehClusterId);
fRetryUpdateCluster = TRUE;
}
}
if (uNumModeChanges && NLBFAILED(nerr))
{
mfn_Unlock();
//
// There was a problem, log it, as well as the list of
// cluster IP addresses/subnets.
// TODO: add details.
//
m_pCallbacks->Log(
IUICallbacks::LOG_INFORMATIONAL,
szClusterIp,
NULL,
IDS_LOG_ERRORS_DETECTED_DURING_MODE_CHANGE
);
mfn_Lock();
}
} while (NLBOK(nerr) && fRetryUpdateCluster);
//
// We're done -- set the cluster's fPending field to false, and if
// necessary (if no interfaces) delete the cluster.
//
{
BOOL fEmptyCluster = FALSE;
CClusterSpec *pCSpec = NULL;
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end_unlock;
}
pCSpec = &pECluster->m_cSpec;
fEmptyCluster = (pCSpec->m_ehInterfaceIdList.size()==0);
ASSERT(fStopOperationOnExit);
mfn_StopClusterOperationLk(ehClusterId);
fStopOperationOnExit = FALSE;
mfn_Unlock();
if (fEmptyCluster)
{
//
// The cluster is empty -- delete it.
//
this->DeleteCluster(ehClusterId, FALSE); // FALSE == don't remove IF
}
else
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehClusterId,
ehClusterId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
}
mfn_Lock();
}
// fall through ...
end_unlock:
if (fStopOperationOnExit)
{
//
// We'll stop the operation, assumed to be started in this function.
//
mfn_StopClusterOperationLk(ehClusterId);
}
mfn_Unlock();
if (fStopOperationOnExit)
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehClusterId,
ehClusterId,
IUICallbacks::EVT_STATUS_CHANGE
);
ProcessMsgQueue();
fStopOperationOnExit = FALSE;
}
end:
ASSERT(!fStopOperationOnExit);
TRACE_INFO(L"<- %!FUNC!");
return nerr;
}
NLBERROR
CNlbEngine::GetClusterSpec(
IN ENGINEHANDLE ehClusterId,
OUT CClusterSpec& refClusterSpec
)
{
// TRACE_INFO(L"-> %!FUNC!");
NLBERROR err = NLBERR_OK;
mfn_Lock();
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehClusterId]; // map
if (pECluster == NULL)
{
err = NLBERR_INTERFACE_NOT_FOUND;
}
else
{
//
// This is really an assert condition -- the cluster spec should
// NEVER have a non-blank dedicated IP address.
//
if (!pECluster->m_cSpec.m_ClusterNlbCfg.IsBlankDedicatedIp())
{
err = NLBERR_INTERNAL_ERROR;
TRACE_CRIT(L"%!FUNC! unexpected: cluster eh 0x%lx has non-blank ded-ip!", ehClusterId);
}
else
{
refClusterSpec.Copy(pECluster->m_cSpec);
}
}
mfn_Unlock();
// TRACE_INFO(L"<- %!FUNC!");
return err;
}
NLBERROR
CNlbEngine::GetHostSpec(
IN ENGINEHANDLE ehHostId,
OUT CHostSpec& refHostSpec
)
{
NLBERROR err = NLBERR_OK;
// TRACE_INFO(L"-> %!FUNC!(0x%lx)", (UINT)ehHostId);
mfn_Lock();
CHostSpec *pHSpec = m_mapIdToHostSpec[ehHostId]; // map
if (pHSpec == NULL)
{
err = NLBERR_INTERFACE_NOT_FOUND;
}
else
{
refHostSpec.Copy(*pHSpec);
}
if (err != NLBERR_OK)
{
TRACE_INFO(
L"<- %!FUNC!(0x%lx) Host not found",
ehHostId
);
}
mfn_Unlock();
return err;
}
NLBERROR
CNlbEngine::GetHostConnectionInformation(
IN ENGINEHANDLE ehHost,
OUT ENGINEHANDLE &ehConnectionIF,
OUT _bstr_t &bstrConnectionString,
OUT UINT &uConnectionIp
)
/*
For the specified host ehHost,
Look up it's connection IP, and search all its interfaces
for the specific connection IP.
Return the found interface handle, connection string and connection IP.
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
CHostSpec *pHSpec = NULL;
mfn_Lock();
pHSpec = m_mapIdToHostSpec[ehHost]; // map
if (pHSpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end_unlock;
}
//
// Lookup the interface that has the connection IP
//
uConnectionIp = pHSpec->m_ConnectionIpAddress;
if (uConnectionIp != 0)
{
WCHAR rgIp[128];
LPBYTE pb = (LPBYTE) &uConnectionIp;
StringCbPrintf(
rgIp,
sizeof(rgIp),
L"%lu.%lu.%lu.%lu",
pb[0], pb[1], pb[2], pb[3]
);
nerr = mfn_LookupInterfaceByIpLk(ehHost, rgIp, REF ehConnectionIF);
}
if (NLBOK(nerr))
{
bstrConnectionString = pHSpec->m_ConnectionString;
}
else
{
ehConnectionIF = NULL;
uConnectionIp = 0;
}
end_unlock:
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::EnumerateClusters(
OUT vector <ENGINEHANDLE> & ClusterIdList
)
{
TRACE_INFO(L"-> %!FUNC!");
mfn_Lock();
map< ENGINEHANDLE, CEngineCluster* >::iterator iCluster;
ClusterIdList.clear();
for (iCluster = m_mapIdToEngineCluster.begin();
iCluster != m_mapIdToEngineCluster.end();
iCluster++)
{
ENGINEHANDLE ehClusterId = (*iCluster).first;
if (m_mapIdToEngineCluster[ehClusterId])
ClusterIdList.push_back(ehClusterId);
}
mfn_Unlock();
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::EnumerateHosts(
OUT vector <ENGINEHANDLE> & HostIdList
)
{
TRACE_INFO(L"-> %!FUNC!");
// TODO
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
NLBERROR
CNlbEngine::GetAllHostConnectionStrings(
OUT vector <_bstr_t> & ConnectionStringList
)
//
// Actually only returns the strings for hosts that have at least one
// interface that is part of a cluster that is displayed by NLB Manager.
// (see .net server bug 499068)
//
{
TRACE_INFO(L"-> %!FUNC!");
mfn_Lock();
map< ENGINEHANDLE, CHostSpec* >::iterator iter;
for( iter = m_mapIdToHostSpec.begin();
iter != m_mapIdToHostSpec.end();
++iter)
{
CHostSpec *pHSpec = (CHostSpec *) ((*iter).second);
if (pHSpec != NULL)
{
if (mfn_HostHasManagedClustersLk(pHSpec))
{
ConnectionStringList.push_back(pHSpec->m_ConnectionString);
}
}
}
mfn_Unlock();
TRACE_INFO(L"<- %!FUNC!");
return NLBERR_OK;
}
BOOL
CNlbEngine::GetObjectType(
IN ENGINEHANDLE ehObj,
OUT IUICallbacks::ObjectType &objType
)
{
BOOL fRet = FALSE;
UINT uType;
objType = IUICallbacks::OBJ_INVALID;
if (ehObj == NULL)
{
goto end;
}
//
// Extract object type -- the first TYPE_BIT_COUNT bits of ehObj.
//
uType = ((UINT) ehObj) & (0xffffffff>>(32-TYPE_BIT_COUNT));
mfn_Lock();
switch(uType)
{
case IUICallbacks::OBJ_INTERFACE:
if (m_mapIdToInterfaceSpec[ehObj] != NULL)
{
objType = IUICallbacks::OBJ_INTERFACE;
fRet = TRUE;
}
break;
case IUICallbacks::OBJ_CLUSTER:
if (m_mapIdToEngineCluster[ehObj] != NULL)
{
objType = IUICallbacks::OBJ_CLUSTER;
fRet = TRUE;
}
break;
case IUICallbacks::OBJ_HOST:
if (m_mapIdToHostSpec[ehObj] != NULL)
{
objType = IUICallbacks::OBJ_HOST;
fRet = TRUE;
}
break;
case IUICallbacks::OBJ_OPERATION:
if (m_mapIdToOperation[ehObj] != NULL)
{
objType = IUICallbacks::OBJ_OPERATION;
fRet = TRUE;
}
break;
default:
break;
}
mfn_Unlock();
end:
return fRet;
}
//
// Return a bitmap of available host IDs for the specified cluster.
//
ULONG
CNlbEngine::GetAvailableHostPriorities(
ENGINEHANDLE ehCluster // OPTIONAL
)
{
ULONG UsedPriorities = 0;
mfn_Lock();
do // while false
{
if (ehCluster == NULL) break;
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL) break;
//
// For each interface,
// build up a bitmap of used priorities. Return the inverse of that
// bitmap.
//
for( int i = 0; i < pECluster->m_cSpec.m_ehInterfaceIdList.size(); ++i )
{
ENGINEHANDLE ehIId = pECluster->m_cSpec.m_ehInterfaceIdList[i];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC! no interface in ehC 0x%x for ehI 0x%x",
ehCluster, ehIId);
continue;
}
if (pISpec->m_NlbCfg.IsValidNlbConfig())
{
UINT HostPriority = pISpec->m_NlbCfg.NlbParams.host_priority;
UsedPriorities |= (1<<(HostPriority-1));
}
}
} while (FALSE);
mfn_Unlock();
return ~UsedPriorities;
}
//
// Fill in an array of bitmaps of available priorities for each specified
// port rule. The port rule must be valid.
// If a port rule is not single-host-priority, the bitmap for that
// port rule is undefined.
//
NLBERROR
CNlbEngine::GetAvailablePortRulePriorities(
IN ENGINEHANDLE ehCluster, OPTIONAL
IN UINT NumRules,
IN WLBS_PORT_RULE rgRules[],
IN OUT ULONG rgAvailablePriorities[] // At least NumRules
)
{
//
// If ehCluster==NULL, set all to 0xffffffff
//
// For each interface, locate the specified port rules (based on vip and
// start port) and build up a bitmap of used priorities.
// fill in rgRules with the inverse of the bitmaps.
//
// Todo Account for priorities of pending operations.
//
mfn_Lock();
//
// We initially use rgAvailablePriorities to store USED priorities.
// Intialize to 0.
//
for (UINT u=0; u<NumRules; u++)
{
rgAvailablePriorities[u] = 0;
}
do // while false
{
ULONG *rgUsedPriorities = rgAvailablePriorities;
if (ehCluster == NULL) break;
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL) break;
//
// For each interface, locate the specified port rule and
// build up a bitmap of used priorities. Return the inverse of that
// bitmap.
//
for( int i = 0; i < pECluster->m_cSpec.m_ehInterfaceIdList.size(); ++i )
{
ENGINEHANDLE ehIId = pECluster->m_cSpec.m_ehInterfaceIdList[i];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC! no interface in ehC 0x%x for ehI 0x%x",
ehCluster, ehIId);
continue;
}
if (pISpec->m_NlbCfg.IsValidNlbConfig())
{
//
// get_used_port_rule_priorities will add its priority
// to the bitmap of each single-host port rule.
//
(void) get_used_port_rule_priorities(
REF pISpec->m_NlbCfg,
NumRules,
rgRules,
rgUsedPriorities
);
}
}
} while (FALSE);
//
// We initially used rgAvailablePriorities to store USED priorities.
// So invert each.
//
for (UINT u=0; u<NumRules; u++)
{
rgAvailablePriorities[u] = ~rgAvailablePriorities[u];
}
mfn_Unlock();
return NLBERR_OK;
}
NLBERROR
CNlbEngine::mfn_GetHostFromInterfaceLk(
IN ENGINEHANDLE ehIId,
OUT CInterfaceSpec* &pISpec,
OUT CHostSpec* &pHSpec
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
pHSpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
}
else
{
ENGINEHANDLE ehHost = pISpec->m_ehHostId;
pHSpec = m_mapIdToHostSpec[ehHost]; // map
nerr = NLBERR_OK;
}
return nerr;
}
void
CNlbEngine::mfn_GetInterfaceHostNameLk(
ENGINEHANDLE ehIId,
_bstr_t &bstrHostName
)
/*
This function returns the host name of the specified interface.
It sets bstrHostName to "" (not NULL) on error.
*/
{
NLBERROR nerr;
_bstr_t *pName = NULL;
CHostSpec *pHSpec = NULL;
CInterfaceSpec *pISpec = NULL;
nerr = CNlbEngine::mfn_GetHostFromInterfaceLk(ehIId,REF pISpec, REF pHSpec);
if (nerr == NLBERR_OK)
{
pName = &pHSpec->m_MachineName;
}
if (pName == NULL)
{
bstrHostName = _bstr_t(L"");
}
else
{
bstrHostName = *pName;
}
}
ENGINEHANDLE
CNlbEngine::mfn_NewHandleLk(IUICallbacks::ObjectType type)
//
// Returns a unique number from 1 to 2^31-1 (1 to ~ 2 billion).
// If it is called more than 2 billion times it will start returning zero
// from then onwards.
//
{
ULONG uVal =0;
if (m_fPrepareToDeinitialize)
{
goto end;
}
if ((UINT)type >= (1<<TYPE_BIT_COUNT))
{
TRACE_CRIT(L"%!FUNC!: Invalid obj type");
goto end;
}
if (!m_fHandleOverflow)
{
uVal = (ULONG) InterlockedIncrement(&m_NewHandleValue);
//
// uVal could be less than 2^(32-TypeBitCount)) to save
// so that it doesn't over flow when we shift it by TypeBitCounts.
//
// Extreme cases: if TypeBitCount==32, uVal should be less
// then 1<<0, or 1 -- so it can only have one value 0.
//
// If TypeBitCount==0, uVal should be less than 1<<32, i.e., any
// valid uint value.
//
if (uVal >= (1<<(32-TYPE_BIT_COUNT)))
{
//
// Overflow!!!
//
TRACE_CRIT(L"%!FUNC!: Handle overflow!");
m_fHandleOverflow = TRUE;
uVal = 0;
goto end;
}
//
// Construct the handle by compositing the type and the counter value.
//
uVal = ((uVal<<TYPE_BIT_COUNT) | (UINT) type);
}
end:
return (ENGINEHANDLE) uVal;
}
NLBERROR
CNlbEngine::ApplyClusterWideConfiguration(
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &ClusterConfig,
IN OUT NLB_EXTENDED_CLUSTER_CONFIGURATION &ConfigToUpdate
)
/*
Apply only the cluster-wide parameters in ClusterConfig to
ConfigToUpdate.
When updateing port rules, try to preserve the host-specific info
(load weight, host priority).
NOTE: It WILL replace the ConfigToUpdate's list of IP addresses with
the list of IP addresses in ClusterConfig. This will REMOVE the
dedicated IP address from the list of IP addresses. The dedicated IP
address will be added before the interface is actually updated -- in
CNlbEngine::UpdateInterface.
WLBS_REG_PARAMS cluster-wide params...
BOOL fRctEnabled
BOOL fMcastSupport
BOOL fIGMPSupport
TCHAR cl_ip_addr[CVY_MAX_CL_IP_ADDR + 1]
TCHAR cl_net_mask[CVY_MAX_CL_NET_MASK + 1]
TCHAR domain_name[CVY_MAX_DOMAIN_NAME + 1]
bool fChangePassword
TCHAR szPassword[CVY_MAX_RCT_CODE + 1]
DWORD dwNumRules
NETCFG_WLBS_PORT_RULE port_rules[CVY_MAX_RULES]
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
WLBS_PORT_RULE *pOldRules = NULL;
WLBS_PORT_RULE *pNewRules = NULL;
if (!ClusterConfig.fBound || !validate_extcfg(ClusterConfig))
{
TRACE_CRIT("%!FUNC! -- cluster configuration is invalid!");
goto end;
}
if(!ConfigToUpdate.IsValidNlbConfig())
{
//
// We expect the configuration to be valid -- i.e., NLB bound, with
// valid parameters.
//
TRACE_CRIT("%!FUNC! -- current configuration is unbound/invalid!");
goto end;
}
ConfigToUpdate.NlbParams.rct_enabled = ClusterConfig.NlbParams.rct_enabled;
ConfigToUpdate.NlbParams.mcast_support = ClusterConfig.NlbParams.mcast_support;
ConfigToUpdate.NlbParams.fIGMPSupport = ClusterConfig.NlbParams.fIGMPSupport;
CopyMemory(
ConfigToUpdate.NlbParams.cl_ip_addr,
ClusterConfig.NlbParams.cl_ip_addr,
sizeof(ConfigToUpdate.NlbParams.cl_ip_addr)
);
CopyMemory(
ConfigToUpdate.NlbParams.cl_net_mask,
ClusterConfig.NlbParams.cl_net_mask,
sizeof(ConfigToUpdate.NlbParams.cl_net_mask)
);
CopyMemory(
ConfigToUpdate.NlbParams.domain_name,
ClusterConfig.NlbParams.domain_name,
sizeof(ConfigToUpdate.NlbParams.domain_name)
);
//
// TODO -- we need to preserve Ip addresses and their order in
// hosts, as far as possible. For now we decide the order.
//
{
BOOL fRet = FALSE;
NlbIpAddressList addrList;
fRet = addrList.Set(ClusterConfig.NumIpAddresses,
ClusterConfig.pIpAddressInfo, 0);
if (!fRet)
{
TRACE_CRIT(L"Could not copy over ip addresses!");
goto end;
}
ConfigToUpdate.SetNetworkAddressesRaw(NULL,0);
addrList.Extract(
REF ConfigToUpdate.NumIpAddresses,
REF ConfigToUpdate.pIpAddressInfo
);
}
// password -- copy and set some flag only if changed.
{
LPCWSTR szNewPassword = NULL;
szNewPassword = ClusterConfig.GetNewRemoteControlPasswordRaw();
//
// Note: szNewPassword will be NULL UNLESS the user has explicitly
// specified a new password.
//
ConfigToUpdate.SetNewRemoteControlPassword(szNewPassword);
}
//
// Fold in port rules.
//
{
UINT NumOldRules=0;
UINT NumNewRules=0;
WBEMSTATUS wStat;
wStat = CfgUtilGetPortRules(
&ConfigToUpdate.NlbParams,
&pOldRules,
&NumOldRules
);
if (FAILED(wStat))
{
TRACE_CRIT("%!FUNC! error 0x%08lx extracting old port rules!", wStat);
pOldRules=NULL;
goto end;
}
wStat = CfgUtilGetPortRules(
&ClusterConfig.NlbParams,
&pNewRules,
&NumNewRules
);
if (FAILED(wStat))
{
TRACE_CRIT("%!FUNC! error 0x%08lx extracting new port rules!", wStat);
pNewRules = NULL;
goto end;
}
//
// Now for each new port rule, if it makes sense, pick up
// host-specific info from old port rules.
//
for (UINT u=0; u<NumNewRules;u++)
{
WLBS_PORT_RULE *pNewRule = pNewRules+u;
const WLBS_PORT_RULE *pOldRule = NULL; // mapStartPortToOldRule[pNewRule->start_port];
UINT NewMode = pNewRule->mode;
pOldRule = find_port_rule(
pOldRules,
NumOldRules,
pNewRule->virtual_ip_addr,
pNewRule->start_port
);
if (NewMode != CVY_NEVER)
{
//
// We need to fill in host-specific stuff
//
if (pOldRule!=NULL && pOldRule->mode == NewMode)
{
//
// We can pick up the old rule's info.
//
if (NewMode == CVY_MULTI)
{
//
// We ignore the cluster's equal_load and
// load fields.
//
pNewRule->mode_data.multi.equal_load =
pOldRule->mode_data.multi.equal_load;
pNewRule->mode_data.multi.load =
pOldRule->mode_data.multi.load;
}
else if (NewMode == CVY_SINGLE)
{
//
// TODO: priorities can potentially clash here.
//
pNewRule->mode_data.single.priority =
pOldRule->mode_data.single.priority;
}
}
else
{
//
// We need to pick defaults.
//
if (NewMode == CVY_MULTI)
{
pNewRule->mode_data.multi.equal_load = TRUE; //default
pNewRule->mode_data.multi.load = 50;
}
else if (NewMode == CVY_SINGLE)
{
//
// TODO: need to pick a new priority here!
// for now we pick the host's priority -- but
// we need to really pick one that
// doesn't clash!
//
pNewRule->mode_data.single.priority =
ConfigToUpdate.NlbParams.host_priority;
}
}
}
}
//
// Finally, set the new port rules..
//
wStat = CfgUtilSetPortRules(
pNewRules,
NumNewRules,
&ConfigToUpdate.NlbParams
);
if (FAILED(wStat))
{
TRACE_CRIT("%!FUNC! error 0x%08lx setting new port rules!", wStat);
goto end;
}
nerr = NLBERR_OK;
}
end:
delete pOldRules; // can be NULL
delete pNewRules; // can be NULL
return nerr;
}
NLBERROR
CNlbEngine::mfn_RefreshHost(
IN PWMI_CONNECTION_INFO pConnInfo,
IN ENGINEHANDLE ehHost,
IN BOOL fOverwriteConnectionInfo
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
LPWSTR *pszNics = NULL;
UINT NumNics = 0;
UINT NumNlbBound = 0;
WBEMSTATUS wStatus = WBEM_E_CRITICAL_ERROR;
CHostSpec *pHost = NULL;
vector<ENGINEHANDLE> InterfaceListCopy;
wStatus = NlbHostGetCompatibleNics(
pConnInfo,
&pszNics,
&NumNics,
&NumNlbBound
);
if (FAILED(wStatus))
{
pszNics = NULL;
// TODO -- check for authentication failure -- ask for new creds.
}
//
// Update the connection string, IP, and status of the host.
//
{
mfn_Lock();
pHost = m_mapIdToHostSpec[ehHost]; // map
if (pHost != NULL)
{
pHost->m_fReal = TRUE;
if (fOverwriteConnectionInfo)
{
pHost->m_ConnectionString = _bstr_t(pConnInfo->szMachine);
pHost->m_UserName = _bstr_t(pConnInfo->szUserName);
pHost->m_Password = _bstr_t(pConnInfo->szPassword);
}
if (FAILED(wStatus))
{
pHost->m_fUnreachable = TRUE;
}
else
{
pHost->m_fUnreachable = FALSE;
}
}
pHost = NULL;
mfn_Unlock();
}
//
// Update that status of all interfaces in the host.
//
mfn_NotifyHostInterfacesChange(ehHost);
if (FAILED(wStatus))
{
// TODO -- proper return error.
goto end;
}
//
// We first go through and add all the interfaces-
//
mfn_Lock();
pHost = m_mapIdToHostSpec[ehHost]; // map
if (pHost == NULL)
{
mfn_Unlock();
goto end;
}
for (UINT u=0; u<NumNics; u++)
{
LPCWSTR szNic = pszNics[u];
ENGINEHANDLE ehInterface = NULL;
CInterfaceSpec *pISpec = NULL;
BOOL fIsNew = FALSE;
nerr = mfn_LookupInterfaceByGuidLk(
szNic,
TRUE, // TRUE==ok to create
REF ehInterface,
REF pISpec,
REF fIsNew
);
if (nerr == NLBERR_OK)
{
if (fIsNew)
{
//
// We've just created a brand new interface object.
// Add it to the host's list of interfaces, and
// add a reference to this host in the interface object.
//
pISpec->m_ehHostId = ehHost;
pISpec->m_fReal = FALSE; // we'll update this later.
pHost->m_ehInterfaceIdList.push_back(ehInterface);
}
//
// Keep a copy of the machine name in the interface.
// Here we'll update if it's changed -- could happen if
// host's machine name has changed while NLB manager is still
// running.
//
if (pISpec->m_bstrMachineName != pHost->m_MachineName) // bstr
{
pISpec->m_bstrMachineName = pHost->m_MachineName; // bstr
}
}
}
InterfaceListCopy = pHost->m_ehInterfaceIdList; // vector copy
pHost = NULL;
mfn_Unlock();
//
// Having added any new interfaces, we now we go through
// ALL interfaces in the host, refreshing them -- potentially getting
// rid of ones which are no longer in the host.
//
for(u = 0; u < InterfaceListCopy.size(); ++u )
{
ENGINEHANDLE ehIId = InterfaceListCopy[u];
(void) this->RefreshInterface(
ehIId,
TRUE, // TRUE == start a new operation
FALSE // FALSE == this is not cluster-wide
);
}
nerr = NLBERR_OK;
end:
delete pszNics;
return nerr;
}
NLBERROR
CNlbEngine::mfn_LookupInterfaceByGuidLk(
IN LPCWSTR szInterfaceGuid,
IN BOOL fCreate,
OUT ENGINEHANDLE &ehInterface,
OUT CInterfaceSpec* &pISpec,
OUT BOOL &fIsNew
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
fIsNew = FALSE;
ehInterface = NULL;
pISpec=NULL;
map< ENGINEHANDLE, CInterfaceSpec* >::iterator iter;
for( iter = m_mapIdToInterfaceSpec.begin();
iter != m_mapIdToInterfaceSpec.end();
++iter)
{
CInterfaceSpec* pTmp = (*iter).second;
ENGINEHANDLE ehTmp = (*iter).first;
if (pTmp == NULL || ehTmp == NULL)
{
TRACE_CRIT("%!FUNC! map: unexpected pair(eh=0x%lx, pISpec=%p)",
(UINT) ehTmp, pTmp);
continue;
}
else
{
TRACE_VERB("%!FUNC! map: pair(eh=0x%lx, pISpec=%p), szGuid=%ws",
(UINT) ehTmp, pTmp, (LPCWSTR) pTmp->m_Guid);
}
if (!_wcsicmp((LPCWSTR)pTmp->m_Guid, szInterfaceGuid))
{
// found it!
ehInterface = ehTmp;
pISpec = pTmp;
break;
}
}
if (pISpec!=NULL)
{
if (ehInterface==NULL)
{
TRACE_CRIT("%!FUNC! unexpected null handle for pISpec %ws", szInterfaceGuid);
}
else
{
nerr = NLBERR_OK;
}
goto end;
}
if (!fCreate)
{
nerr = NLBERR_NOT_FOUND;
goto end;
}
//
// Create a new interface
//
{
pISpec = new CInterfaceSpec;
if (pISpec == NULL)
{
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
fIsNew = TRUE;
pISpec->m_fReal = FALSE;
pISpec->m_Guid = _bstr_t(szInterfaceGuid);
//
// Get us a handle to this interface
//
ehInterface = CNlbEngine::mfn_NewHandleLk(IUICallbacks::OBJ_INTERFACE);
if (ehInterface == NULL)
{
TRACE_CRIT("%!FUNC! could not reserve a new interface handle");
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
delete pISpec;
pISpec=NULL;
goto end;
}
TRACE_VERB("%!FUNC!: map new pair(eh=0x%lx, pISpec=%p), szGuid=%ws",
(UINT) ehInterface, pISpec, (LPCWSTR) pISpec->m_Guid);
m_mapIdToInterfaceSpec[ehInterface] = pISpec;
nerr = NLBERR_OK;
}
end:
return nerr;
}
NLBERROR
CNlbEngine::mfn_LookupInterfaceByIpLk(
IN ENGINEHANDLE ehHost, // OPTIONAL -- if NULL all hosts are looked
IN LPCWSTR szIpAddress,
OUT ENGINEHANDLE &ehInterface
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
ehInterface = NULL;
map< ENGINEHANDLE, CInterfaceSpec* >::iterator iter;
for( iter = m_mapIdToInterfaceSpec.begin();
iter != m_mapIdToInterfaceSpec.end();
++iter)
{
const CInterfaceSpec* pTmp = (*iter).second;
ENGINEHANDLE ehTmp = (*iter).first;
if (pTmp == NULL || ehTmp == NULL)
{
continue;
}
if (ehHost==NULL || ehHost==pTmp->m_ehHostId)
{
UINT NumIps = pTmp->m_NlbCfg.NumIpAddresses;
const NLB_IP_ADDRESS_INFO *pInfo = pTmp->m_NlbCfg.pIpAddressInfo;
for (UINT u = 0; u<NumIps; u++)
{
if (!wcscmp(pInfo[u].IpAddress, szIpAddress))
{
// found it!
TRACE_VERB(L"%!FUNC! found szIp %ws on ehIF 0x%lx",
szIpAddress, ehTmp);
ehInterface = ehTmp;
break;
}
}
}
}
if (ehInterface == NULL)
{
nerr = NLBERR_NOT_FOUND;
}
else
{
nerr = NLBERR_OK;
}
return nerr;
}
NLBERROR
CNlbEngine::mfn_LookupHostByNameLk(
IN LPCWSTR szHostName,
IN BOOL fCreate,
OUT ENGINEHANDLE &ehHost,
OUT CHostSpec* &pHostSpec,
OUT BOOL &fIsNew
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
fIsNew = FALSE;
ehHost = NULL;
map< ENGINEHANDLE, CHostSpec* >::iterator iter;
pHostSpec = NULL;
for( iter = m_mapIdToHostSpec.begin();
iter != m_mapIdToHostSpec.end();
++iter)
{
CHostSpec* pTmp= (*iter).second;
ENGINEHANDLE ehTmp = (*iter).first;
if (pTmp == NULL || ehTmp == NULL)
{
TRACE_CRIT("%!FUNC! map: unexpected pair(eh=0x%lx, pHSpec=%p)",
(UINT) ehTmp, pTmp);
continue;
}
else
{
TRACE_VERB("%!FUNC! map: pair(eh=0x%lx, pHSpec=%p), szHost=%ws",
(UINT) ehTmp, pTmp, (LPCWSTR) pTmp->m_MachineName);
}
if (!_wcsicmp(pTmp->m_MachineName, szHostName))
{
// found it!
ehHost = ehTmp;
pHostSpec = pTmp;
break;
}
}
if (pHostSpec!=NULL)
{
if (ehHost==NULL)
{
TRACE_CRIT("%!FUNC! unexpected null handle for pHostSpec %ws", szHostName);
}
else
{
nerr = NLBERR_OK;
}
goto end;
}
if (!fCreate)
{
nerr = NLBERR_NOT_FOUND;
goto end;
}
//
// Create a new host
//
{
pHostSpec = new CHostSpec;
if (pHostSpec == NULL)
{
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
fIsNew = TRUE;
pHostSpec->m_fReal = FALSE;
pHostSpec->m_MachineName = _bstr_t(szHostName);
//
// Get us a handle to this host
//
ehHost = CNlbEngine::mfn_NewHandleLk(IUICallbacks::OBJ_HOST);
if (ehHost == NULL)
{
TRACE_CRIT("%!FUNC! could not reserve a new host handle");
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
delete pHostSpec;
pHostSpec=NULL;
goto end;
}
m_mapIdToHostSpec[ehHost] = pHostSpec;
TRACE_VERB("%!FUNC!: map new pair(eh=0x%lx, pHost=%p), szName=%ws",
(UINT) ehHost, pHostSpec, (LPCWSTR) pHostSpec->m_MachineName);
nerr = NLBERR_OK;
}
end:
return nerr;
}
VOID
CNlbEngine::mfn_NotifyHostInterfacesChange(ENGINEHANDLE ehHost)
{
vector<ENGINEHANDLE> InterfaceListCopy;
//
// Get copy of interface list (because we can't callback into the UI
// with locks held).
//
{
mfn_Lock();
CHostSpec *pHSpec = NULL;
pHSpec = m_mapIdToHostSpec[ehHost]; // map
if (pHSpec == NULL)
{
TRACE_CRIT("%!FUNC! invalid host handle 0x%lx", (UINT)ehHost);
}
else
{
InterfaceListCopy = pHSpec->m_ehInterfaceIdList; // vector copy
}
mfn_Unlock();
}
for(int i = 0; i < InterfaceListCopy.size(); ++i )
{
ENGINEHANDLE ehIId = InterfaceListCopy[i];
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
NULL, // ehClusterId,
ehIId,
IUICallbacks::EVT_STATUS_CHANGE
);
}
}
NLBERROR
CNlbEngine::LookupClusterByIP(
IN LPCWSTR szIP,
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION *pInitialConfig OPTIONAL,
OUT ENGINEHANDLE &ehCluster,
OUT BOOL &fIsNew
)
//
// if pInitialConfig below is NULL we'll lookup and not try to create.
// if not NULL and we don't find an existing cluster, well create
// a new one and initialize it with the specified configuration.
//
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
mfn_Lock();
fIsNew = FALSE;
ehCluster = NULL;
map< ENGINEHANDLE, CEngineCluster* >::iterator iter;
for( iter = m_mapIdToEngineCluster.begin();
iter != m_mapIdToEngineCluster.end();
++iter)
{
CEngineCluster* pTmp = (*iter).second;
ENGINEHANDLE ehTmp = (*iter).first;
LPCWSTR szTmpIp = NULL;
if (pTmp == NULL || ehTmp == NULL)
{
TRACE_CRIT("%!FUNC! map: unexpected pair(eh=0x%lx, pEC=%p)",
(UINT) ehTmp, pTmp);
continue;
}
else
{
szTmpIp = pTmp->m_cSpec.m_ClusterNlbCfg.NlbParams.cl_ip_addr;
TRACE_VERB("%!FUNC! map: pair(eh=0x%lx, pEC=%p), szIP=%ws",
(UINT) ehTmp, pTmp, szTmpIp);
}
if (!_wcsicmp(szTmpIp, szIP))
{
// found it!
ehCluster = ehTmp;
break;
}
}
if (ehCluster!=NULL)
{
nerr = NLBERR_OK;
goto end;
}
if (pInitialConfig == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end;
}
//
// Create a new cluster
//
{
CEngineCluster* pECluster = new CEngineCluster;
if (pECluster == NULL)
{
TRACE_CRIT("%!FUNC! could not allocate cluster object");
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
fIsNew = TRUE;
WBEMSTATUS wStatus;
wStatus = pECluster->m_cSpec.m_ClusterNlbCfg.Update(pInitialConfig);
//
// Note: Update above has the side effect of setting
// m_ClusterNlbCfg's szNewPassword field to NULL -- this is what
// we want.
//
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC! could not copy cluster spec. Err=0x%lx!",
(UINT) wStatus);
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
//
// Remove the dedicated IP address, if any from the cluster version of
// NLB Config -- both from the NlbParams and from the IP address list.
//
remove_dedicated_ip_from_nlbcfg(REF pECluster->m_cSpec.m_ClusterNlbCfg);
//
// Get us a handle to this cluster
//
ehCluster = CNlbEngine::mfn_NewHandleLk(IUICallbacks::OBJ_CLUSTER);
if (ehCluster == NULL)
{
TRACE_CRIT("%!FUNC! could not reserve a new cluster handle");
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
delete pECluster;
goto end;
}
m_mapIdToEngineCluster[ehCluster] = pECluster;
TRACE_VERB("%!FUNC!: map new pair(eh=0x%lx, pEC=%p)",
(UINT) ehCluster, pECluster);
mfn_Unlock();
//
// Call the ui to notify it about the new cluster creation.
//
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_ADDED
);
ProcessMsgQueue();
mfn_Lock();
nerr = NLBERR_OK;
}
end:
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::LookupInterfaceByIp(
IN ENGINEHANDLE ehHost, // OPTIONAL -- if NULL all hosts are looked
IN LPCWSTR szIpAddress,
OUT ENGINEHANDLE &ehIf
)
{
NLBERROR nerr;
mfn_Lock();
nerr = mfn_LookupInterfaceByIpLk(ehHost, szIpAddress, REF ehIf);
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::LookupConnectionInfo(
IN LPCWSTR szConnectionString,
OUT _bstr_t &bstrUsername,
OUT _bstr_t &bstrPassword
)
//
// Look through existing hosts, looking for any which have a matching
// connection string. If found, fill out bstrUsername and bstrPassword
// for that host.
//
{
NLBERROR nerr = NLBERR_NOT_FOUND;
TRACE_VERB(L"-> Lookup: szConnString=%ws", szConnectionString);
bstrUsername = (LPCWSTR) NULL;
bstrPassword = (LPCWSTR) NULL;
mfn_Lock();
map< ENGINEHANDLE, CHostSpec* >::iterator iter;
for( iter = m_mapIdToHostSpec.begin();
iter != m_mapIdToHostSpec.end();
++iter)
{
CHostSpec* pTmp = (*iter).second;
LPCWSTR szHostConnString = NULL;
ENGINEHANDLE ehTmp = (*iter).first;
if (pTmp == NULL || ehTmp == NULL)
{
continue;
}
szHostConnString = (LPCWSTR) pTmp->m_ConnectionString;
if (szHostConnString == NULL)
{
szHostConnString = L"";
}
if (!_wcsicmp(szHostConnString, szConnectionString))
{
// found it! Fill out username and password.
bstrUsername = pTmp->m_UserName;
bstrPassword = pTmp->m_Password;
LPCWSTR szU = (LPCWSTR) bstrUsername;
LPCWSTR szP = (LPCWSTR) bstrPassword;
if (szU == NULL) szU = L"";
if (szP == NULL) szP = L"";
nerr = NLBERR_OK;
TRACE_VERB(L"Found un=%ws pwd=%ws", szU, szP);
break;
}
}
mfn_Unlock();
TRACE_VERB("<- returns 0x%x", nerr);
return nerr;
}
NLBERROR
CNlbEngine::GetInterfaceInformation(
IN ENGINEHANDLE ehInterface,
OUT CHostSpec& hSpec,
OUT CInterfaceSpec& iSpec,
OUT _bstr_t& bstrDisplayName,
OUT INT& iIcon,
OUT _bstr_t& bstrStatus
)
/*
Looks up a bunch of information about the specified interface.
bstrDisplayName -- this is a combination of the host name and interface name
bstrDisplay -- text version of the interface's operational status.
iIcon -- icon version of the interface's operational status.
(one of the Document::IconNames enums)
*/
{
// First get host and interface spec.
//
NLBERROR nerr;
LPCWSTR szHostName = L"";
LPCWSTR szStatus = L"";
bstrDisplayName = (LPCWSTR) NULL;
bstrStatus = (LPCWSTR) NULL;
iIcon = 0;
nerr = this->GetInterfaceSpec(
ehInterface,
REF iSpec
);
if (NLBFAILED(nerr))
{
TRACE_CRIT("%!FUNC! : could not get interface spec! nerr=0x%lx", nerr);
goto end;
}
nerr = this->GetHostSpec(
iSpec.m_ehHostId,
REF hSpec
);
if (NLBOK(nerr))
{
szHostName = (LPCWSTR) hSpec.m_MachineName;
if (szHostName == NULL)
{
szHostName = L"";
}
}
else
{
TRACE_CRIT("%!FUNC! : could not get host spec! nerr=0x%lx", nerr);
goto end;
}
//
// Determine the icon and bstrStatus
//
if (hSpec.m_fUnreachable)
{
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_UNREACHABLE); //"Unreachable";
iIcon = Document::ICON_HOST_UNREACHABLE;
}
else if (iSpec.m_fPending)
{
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_PENDING); //"Pending";
iIcon = Document::ICON_CLUSTER_PENDING;
}
else if (iSpec.m_fMisconfigured)
{
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_MISCONFIGURED); // "Misconfigured"
iIcon = Document::ICON_HOST_MISCONFIGURED;
}
else if (!hSpec.m_fReal)
{
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_UNKNOWN); // "Unknown";
iIcon = Document::ICON_HOST_UNKNOWN;
}
else
{
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_UNKNOWN); // "Unknown";
iIcon = Document::ICON_HOST_OK;
//
// Choose icon based on operational state if we have it
//
if (!iSpec.m_NlbCfg.IsNlbBound())
{
szStatus = GETRESOURCEIDSTRING(IDS_STATE_NLB_NOT_BOUND); // L"NLB not bound";
}
else if (iSpec.m_fValidClusterState)
{
switch(iSpec.m_dwClusterState)
{
case WLBS_CONVERGING:
iIcon = Document::ICON_HOST_CONVERGING;
szStatus = GETRESOURCEIDSTRING(IDS_STATE_CONVERGING);
// szStatus = L"Converging";
break;
case WLBS_CONVERGED:
case WLBS_DEFAULT:
iIcon = Document::ICON_HOST_STARTED;
szStatus = GETRESOURCEIDSTRING(IDS_STATE_CONVERGED);
// szStatus = L"Converged";
break;
case WLBS_STOPPED:
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_STOPPED);
iIcon = Document::ICON_HOST_STOPPED;
// szStatus = L"Stopped";
break;
case WLBS_SUSPENDED:
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_SUSPENDED);
iIcon = Document::ICON_HOST_SUSPENDED;
// szStatus = L"Suspended";
break;
case WLBS_DRAINING:
szStatus = GETRESOURCEIDSTRING(IDS_HOST_DRAINING);
// szStatus = L"Draining";
iIcon = Document::ICON_HOST_DRAINING;
break;
case WLBS_DISCONNECTED:
szStatus = GETRESOURCEIDSTRING(IDS_HOST_DISCONNECTED);
// szStatus = L"Disconnected";
iIcon = Document::ICON_HOST_DISCONNECTED;
break;
default:
//
// Don't know what this is -- default to "OK" icon.
//
szStatus = GETRESOURCEIDSTRING(IDS_HOST_STATE_UNKNOWN);
// szStatus = L"Unknown";
iIcon = Document::ICON_HOST_OK;
break;
}
}
}
bstrStatus = _bstr_t(szStatus);
//
// Fill out the DisplayName
//
{
WBEMSTATUS wStat;
LPWSTR szAdapter = L"";
WCHAR rgText[256];
wStat = iSpec.m_NlbCfg.GetFriendlyName(&szAdapter);
if (FAILED(wStat))
{
szAdapter = NULL;
}
StringCbPrintf(
rgText,
sizeof(rgText),
L"%ws(%ws)",
szHostName,
(szAdapter==NULL ? L"" : szAdapter)
);
delete szAdapter;
bstrDisplayName = _bstr_t(rgText);
}
end:
return nerr;
}
NLBERROR
CNlbEngine::GetInterfaceIdentification(
IN ENGINEHANDLE ehInterface,
OUT ENGINEHANDLE& ehHost,
OUT ENGINEHANDLE& ehCluster,
OUT _bstr_t& bstrFriendlyName,
OUT _bstr_t& bstrDisplayName,
OUT _bstr_t& bstrHostName
)
{
// First get host and interface spec.
//
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
CInterfaceSpec *pISpec = NULL;
LPCWSTR szHostName = L"";
mfn_Lock();
bstrFriendlyName= (LPCWSTR) NULL;
bstrDisplayName = (LPCWSTR) NULL;
ehHost = NULL;
ehCluster = NULL;
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC! : could not get interface spec for ehI 0x%lx!",
ehInterface);
nerr = NLBERR_INTERFACE_NOT_FOUND;
goto end;
}
if (pISpec->m_ehHostId == NULL)
{
TRACE_CRIT("%!FUNC! : ehI 0x%lx has NULL ehHost spec!", ehInterface);
goto end;
}
else
{
CHostSpec *pHSpec = NULL;
pHSpec = m_mapIdToHostSpec[pISpec->m_ehHostId]; // map
if (pHSpec == NULL)
{
TRACE_CRIT("%!FUNC! : ehI 0x%lx has invalid ehHost 0x%lx!",
ehInterface, pISpec->m_ehHostId);
goto end;
}
bstrHostName = pHSpec->m_MachineName;
szHostName = (LPCWSTR) pHSpec->m_MachineName;
if (szHostName == NULL)
{
szHostName = L"";
}
}
nerr = NLBERR_OK;
ehHost = pISpec->m_ehHostId;
ehCluster = pISpec->m_ehCluster;
//
// Fill out the bstrFriendlyName and bstrDisplayName
//
{
WBEMSTATUS wStat;
LPWSTR szAdapter = L"";
WCHAR rgText[256];
wStat = pISpec->m_NlbCfg.GetFriendlyName(&szAdapter);
if (FAILED(wStat))
{
szAdapter = NULL;
}
StringCbPrintf(
rgText,
sizeof(rgText),
L"%ws(%ws)",
szHostName,
(szAdapter==NULL ? L"" : szAdapter)
);
bstrFriendlyName = _bstr_t(szAdapter);
delete szAdapter;
bstrDisplayName = _bstr_t(rgText);
}
end:
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::GetClusterIdentification(
IN ENGINEHANDLE ehCluster,
OUT _bstr_t& bstrIpAddress,
OUT _bstr_t& bstrDomainName,
OUT _bstr_t& bstrDisplayName
)
{
NLBERROR nerr = NLBERR_NOT_FOUND;
WCHAR rgTmp[256];
bstrIpAddress = (LPCWSTR) NULL;
bstrDomainName = (LPCWSTR) NULL;
bstrDisplayName = (LPCWSTR) NULL;
mfn_Lock();
CEngineCluster *pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster != NULL)
{
WLBS_REG_PARAMS *pParams =&pECluster->m_cSpec.m_ClusterNlbCfg.NlbParams;
StringCbPrintf(
rgTmp,
sizeof(rgTmp),
L"%ws(%ws)",
pParams->domain_name,
pParams->cl_ip_addr
);
bstrIpAddress = _bstr_t(pParams->cl_ip_addr);
bstrDomainName = _bstr_t(pParams->domain_name);
bstrDisplayName = _bstr_t(rgTmp);
nerr = NLBERR_OK;
}
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::ValidateNewClusterIp(
IN ENGINEHANDLE ehCluster, // OPTIONAL
IN LPCWSTR szIp,
OUT BOOL &fExistsOnRawIterface,
IN OUT CLocalLogger &logConflict
)
{
NLBERROR nerr = NLBERR_INVALID_IP_ADDRESS_SPECIFICATION;
BOOL fRet = FALSE;
ENGINEHANDLE ehTmp = NULL;
BOOL fIsNew = FALSE;
fExistsOnRawIterface = FALSE;
//
// Check that CIP is not used elsewhere
//
nerr = this->LookupClusterByIP(
szIp,
NULL, // pInitialConfig
REF ehTmp,
REF fIsNew
);
if (NLBOK(nerr) && ehCluster != ehTmp)
{
//
// CIP matches some other cluster!
//
_bstr_t bstrIpAddress;
_bstr_t bstrDomainName;
_bstr_t bstrClusterDisplayName;
LPCWSTR szCluster = NULL;
nerr = this->GetClusterIdentification(
ehTmp,
REF bstrIpAddress,
REF bstrDomainName,
REF bstrClusterDisplayName
);
if (NLBOK(nerr))
{
szCluster = bstrClusterDisplayName;
}
if (szCluster == NULL)
{
szCluster = L"";
}
logConflict.Log(IDS_CLUSTER_XXX, szCluster);
goto end;
}
ehTmp = NULL;
nerr = this->LookupInterfaceByIp(
NULL, // NULL == search for all hosts
szIp,
REF ehTmp
);
if (NLBOK(nerr))
{
ENGINEHANDLE ehExistingCluster;
ENGINEHANDLE ehExistingHost;
_bstr_t bstrDisplayName;
_bstr_t bstrFriendlyName;
_bstr_t bstrHostName;
LPCWSTR szInterface = NULL;
nerr = this->GetInterfaceIdentification(
ehTmp,
ehExistingHost,
ehExistingCluster,
bstrFriendlyName,
bstrDisplayName,
bstrHostName
);
if (NLBOK(nerr))
{
if (ehCluster == NULL || ehCluster != ehExistingCluster)
{
//
// CONFLICT
//
if (ehExistingCluster == NULL)
{
//
// Conflicting interface NOT part of an existing cluster.
//
fExistsOnRawIterface = TRUE;
}
szInterface = bstrDisplayName;
if (szInterface == NULL)
{
szInterface = L"";
}
logConflict.Log(IDS_INTERFACE_XXX, szInterface);
goto end;
}
}
}
fRet = TRUE;
end:
if (fRet)
{
nerr = NLBERR_OK;
}
else
{
nerr = NLBERR_INVALID_IP_ADDRESS_SPECIFICATION;
}
return nerr;
}
NLBERROR
CNlbEngine::ValidateNewDedicatedIp(
IN ENGINEHANDLE ehIF,
IN LPCWSTR szDip,
IN OUT CLocalLogger &logConflict
)
{
NLBERROR nerr = NLBERR_INVALID_IP_ADDRESS_SPECIFICATION;
BOOL fRet = FALSE;
ENGINEHANDLE ehTmp = NULL;
BOOL fIsNew = FALSE;
if (ehIF == NULL)
{
ASSERT(FALSE);
goto end;
}
//
// Check that DIP is not used elsewhere
//
nerr = this->LookupClusterByIP(
szDip,
NULL, // pInitialConfig
REF ehTmp,
REF fIsNew
);
if (NLBOK(nerr))
{
//
// DIP matches some cluster!
//
_bstr_t bstrIpAddress;
_bstr_t bstrDomainName;
_bstr_t bstrClusterDisplayName;
LPCWSTR szCluster = NULL;
nerr = this->GetClusterIdentification(
ehTmp,
REF bstrIpAddress,
REF bstrDomainName,
REF bstrClusterDisplayName
);
if (NLBOK(nerr))
{
szCluster = bstrClusterDisplayName;
}
if (szCluster == NULL)
{
szCluster = L"";
}
logConflict.Log(IDS_CLUSTER_XXX, szCluster);
goto end;
}
ehTmp = NULL;
nerr = this->LookupInterfaceByIp(
NULL, // NULL == search for all hosts
szDip,
REF ehTmp
);
if (NLBOK(nerr))
{
if (ehTmp != ehIF)
{
ENGINEHANDLE ehHost1;
ENGINEHANDLE ehCluster1;
_bstr_t bstrDisplayName1;
_bstr_t bstrFriendlyName;
_bstr_t bstrHostName;
LPCWSTR szInterface = NULL;
nerr = this->GetInterfaceIdentification(
ehTmp,
ehHost1,
ehCluster1,
bstrFriendlyName,
bstrDisplayName1,
bstrHostName
);
szInterface = bstrDisplayName1;
if (szInterface == NULL)
{
szInterface = L"";
}
logConflict.Log(IDS_INTERFACE_XXX, szInterface);
goto end;
}
}
fRet = TRUE;
end:
if (fRet)
{
nerr = NLBERR_OK;
}
else
{
nerr = NLBERR_INVALID_IP_ADDRESS_SPECIFICATION;
}
return nerr;
}
VOID
CNlbEngine::mfn_ReallyUpdateInterface(
IN ENGINEHANDLE ehInterface,
IN NLB_EXTENDED_CLUSTER_CONFIGURATION &refNewConfig
//IN OUT BOOL &fClusterPropertiesUpdated
)
{
#define NLBMGR_MAX_OPERATION_DURATION 120 // 2 minutes
BOOL fCancelled = FALSE;
CHostSpec *pHSpec = NULL;
CInterfaceSpec *pISpec = NULL;
WBEMSTATUS CompletionStatus, wStatus;
_bstr_t bstrNicGuid;
_bstr_t bstrHostName;
_bstr_t bstrUserName;
_bstr_t bstrConnectionString;
_bstr_t bstrPassword;
NLBERROR nerr;
CLocalLogger logClientIdentification;
WCHAR rgMachineName[512];
DWORD cbMachineName = (DWORD) ASIZE(rgMachineName);
BOOL fRet;
DWORD StartTime = GetTickCount();
fRet = GetComputerNameEx(
ComputerNameDnsFullyQualified,
rgMachineName,
&cbMachineName
);
if (!fRet)
{
*rgMachineName = 0;
}
logClientIdentification.Log(IDS_CLIENT_IDENTIFICATION, rgMachineName);
mfn_Lock();
nerr = CNlbEngine::mfn_GetHostFromInterfaceLk(ehInterface,REF pISpec, REF pHSpec);
if (nerr != NLBERR_OK)
{
TRACE_CRIT("%!FUNC! could not get pISpec,pHSpec for ehIF 0x%lx",
ehInterface);
goto end_unlock;
}
//
// We need to keep local bstrs because once we release the lock
// pHSpec may go away (or re-assign it's bstrs) -- .net svr bug 513056.
//
bstrUserName = pHSpec->m_UserName;
bstrConnectionString= pHSpec->m_ConnectionString;
bstrPassword = pHSpec->m_Password;
bstrNicGuid = pISpec->m_Guid;
bstrHostName = pHSpec->m_MachineName;
WMI_CONNECTION_INFO ConnInfo;
ConnInfo.szUserName = (LPCWSTR) bstrUserName;
ConnInfo.szPassword = (LPCWSTR) bstrPassword;
ConnInfo.szMachine = (LPCWSTR) bstrConnectionString;
LPCWSTR szNicGuid = (LPCWSTR) bstrNicGuid;
LPCWSTR szHostName = (LPCWSTR) bstrHostName;
if (szNicGuid == NULL)
{
TRACE_CRIT("%!FUNC! ERROR -- NULL szNicGuid!");
goto end_unlock;
}
mfn_Unlock();
UINT Generation; // TODO track the generation
LPWSTR pLog = NULL;
LPCWSTR szClusterIp = refNewConfig.NlbParams.cl_ip_addr;
ProcessMsgQueue(); // TODO: eliminate when doing this in the background
wStatus = NlbHostDoUpdate(
&ConnInfo,
szNicGuid,
logClientIdentification.GetStringSafe(),
// L"NLB Manager on <this machine>", // TODO: localize
&refNewConfig,
&Generation,
&pLog
);
if (wStatus == WBEM_S_PENDING)
{
m_pCallbacks->Log(
IUICallbacks::LOG_INFORMATIONAL,
szClusterIp,
szHostName,
IDS_LOG_WAITING_FOR_PENDING_OPERATION, // %d
Generation
);
}
while (wStatus == WBEM_S_PENDING)
{
//
// Check if we've exceeded the absolute time for cancellation.
//
{
DWORD CurrentTime = GetTickCount();
UINT DurationInSeconds=0;
if (CurrentTime < StartTime)
{
//
// Timer overflow -- fixup: we do this the "cheap" way
// of re-setting start time, so that we'll end up with at most
// twice the max delay in the event of a timer overflow.
//
StartTime = CurrentTime;
}
DurationInSeconds= (UINT) (CurrentTime - StartTime)/1000;
if ( DurationInSeconds > NLBMGR_MAX_OPERATION_DURATION)
{
TRACE_CRIT("%!FUNC! Operation canceled because max time exceeded");
fCancelled = TRUE;
break;
}
}
//
// Check if this pending operation is cancelled...
//
{
CInterfaceSpec *pTmpISpec = NULL;
ENGINEHANDLE ehOperation = NULL;
mfn_Lock();
pTmpISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pTmpISpec == NULL)
{
ASSERT(FALSE);
wStatus = WBEM_E_CRITICAL_ERROR;
mfn_Unlock();
break;
}
ehOperation = pTmpISpec->m_ehPendingOperation;
if (ehOperation != NULL)
{
CEngineOperation *pOperation;
pOperation = m_mapIdToOperation[ehOperation];
if (pOperation != NULL)
{
if (pOperation->fCanceled)
{
TRACE_CRIT("%!FUNC! ehOp 0x%lx CANCELLED!",
ehOperation);
fCancelled = TRUE;
}
}
}
mfn_Unlock();
if (fCancelled)
{
break;
}
}
if (pLog != NULL)
{
mfn_UpdateInterfaceStatusDetails(ehInterface, pLog);
delete pLog;
pLog = NULL;
}
for (UINT u=0;u<50;u++)
{
ProcessMsgQueue(); // TODO: eliminate when doing this in the background
Sleep(100);
}
ULONG uIpAddress = 0;
wStatus = NlbHostPing(ConnInfo.szMachine, 2000, &uIpAddress);
if (FAILED(wStatus))
{
TRACE_CRIT("%!FUNC!: ping %ws failed!", ConnInfo.szMachine);
wStatus = WBEM_S_PENDING;
continue;
}
wStatus = NlbHostGetUpdateStatus(
&ConnInfo,
szNicGuid,
Generation,
&CompletionStatus,
&pLog
);
if (!FAILED(wStatus))
{
wStatus = CompletionStatus;
}
}
if (fCancelled == TRUE)
{
wStatus = WBEM_S_OPERATION_CANCELLED;
}
else
{
BOOL fNewRctPassword = FALSE;
//
// Get latest information from the host
//
(void) this->RefreshInterface(
ehInterface,
FALSE, // FALSE == don't start a new operation
FALSE // FALSE == this is not cluster-wide
);
//
// If we're doing a RCT password-change, AND the updated operation
// completed successfully AND the cluster's fNewRctPassword flag is
// set, we'll update the cluster's rct hash value and clear the
// fNewRctPassword flag.
//
fNewRctPassword = (refNewConfig.GetNewRemoteControlPasswordRaw()!=NULL);
if (fNewRctPassword && !FAILED(wStatus))
{
CEngineCluster *pECluster = NULL;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec != NULL)
{
ENGINEHANDLE ehCluster = pISpec->m_ehCluster;
if (ehCluster != NULL)
{
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
}
}
if (pECluster != NULL)
{
if (pECluster->m_cSpec.m_fNewRctPassword)
{
//
// Update cluster's rct hash and clear m_fNewRctPassword
//
DWORD dwNewHash;
dwNewHash = CfgUtilGetHashedRemoteControlPassword(
&pISpec->m_NlbCfg.NlbParams
);
TRACE_VERB(L"Updating cluster remote control password to %lu",
dwNewHash
);
CfgUtilSetHashedRemoteControlPassword(
&pECluster->m_cSpec.m_ClusterNlbCfg.NlbParams,
dwNewHash
);
pECluster->m_cSpec.m_fNewRctPassword = FALSE;
}
}
mfn_Unlock();
}
}
//
// Log the final results.
//
{
IUICallbacks::LogEntryHeader Header;
Header.szDetails = pLog;
Header.szCluster = szClusterIp;
Header.szHost = szHostName;
if (FAILED(wStatus))
{
Header.type = IUICallbacks::LOG_ERROR;
if (Generation != 0)
{
m_pCallbacks->LogEx(
&Header,
IDS_LOG_FINAL_STATUS_FAILED,
Generation,
wStatus
);
}
else
{
m_pCallbacks->LogEx(
&Header,
IDS_LOG_FINAL_STATUS_FAILED_NOGEN,
wStatus
);
}
}
else
{
Header.type = IUICallbacks::LOG_INFORMATIONAL;
m_pCallbacks->LogEx(
&Header,
IDS_LOG_FINAL_STATUS_SUCCEEDED,
Generation
);
}
}
if (pLog != NULL)
{
delete pLog;
pLog = NULL;
}
ProcessMsgQueue(); // TODO: eliminate when doing this in the background
mfn_Lock();
end_unlock:
mfn_Unlock();
return;
}
VOID
CNlbEngine::mfn_SetInterfaceMisconfigStateLk(
IN CInterfaceSpec *pIF,
IN BOOL fMisconfig,
IN LPCWSTR szMisconfigDetails
)
/*
Set/clear the interface misconfigured status.
If fMisconfig, save away the szMisconfigDetails, else clear the
internal misconfig details field.
*/
{
pIF->m_fMisconfigured = fMisconfig;
if (fMisconfig)
{
pIF->m_bstrStatusDetails = _bstr_t(szMisconfigDetails);
}
else
{
pIF->m_bstrStatusDetails = LPCWSTR(NULL);
}
}
BOOL
CNlbEngine::mfn_HostHasManagedClustersLk(CHostSpec *pHSpec)
//
// Return true if there exists at least one IF which is part of
// a cluster displayed by NLB Manager.
//
{
BOOL fRet = FALSE;
vector<ENGINEHANDLE> &InterfaceList = pHSpec->m_ehInterfaceIdList;
for(UINT u = 0; u < InterfaceList.size(); ++u )
{
ENGINEHANDLE ehI = InterfaceList[u];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehI]; // map
if (pISpec != NULL)
{
if (pISpec->m_ehCluster != NULL)
{
fRet = TRUE;
break;
}
}
}
return fRet;
}
void
CNlbEngine::mfn_UpdateInterfaceStatusDetails(
ENGINEHANDLE ehIF,
LPCWSTR szDetails
)
//
// Update the textual status details field of the interface.
// These details give the detailed information on the current status
// of the interface. For example: if misconfigured, misconfig details,
// or if there is an update operation ongoing, details about that operation.
//
{
CInterfaceSpec *pISpec = NULL;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec != NULL)
{
pISpec->m_bstrStatusDetails = szDetails;
}
mfn_Unlock();
}
BOOL
validate_extcfg(
const NLB_EXTENDED_CLUSTER_CONFIGURATION &Config
)
/*
Do some internal checks to make sure that the data is valid.
Does not change internal state.
*/
{
BOOL fRet = FALSE;
if (Config.fBound)
{
WBEMSTATUS Status;
//
// NLB is bound -- let's validate NLB paramaters.
//
WLBS_REG_PARAMS TmpParams = Config.NlbParams; // struct copy.
BOOL fConnectivityChange = FALSE;
Status = CfgUtilsAnalyzeNlbUpdate(
NULL, // OPTIONAL pCurrentParams
&TmpParams,
&fConnectivityChange
);
if (FAILED(Status))
{
goto end;
}
}
fRet = TRUE;
end:
return fRet;
}
VOID
remove_dedicated_ip_from_nlbcfg(
NLB_EXTENDED_CLUSTER_CONFIGURATION &ClusterCfg
)
{
LPCWSTR szDedIp = ClusterCfg.NlbParams.ded_ip_addr;
UINT NumIps = ClusterCfg.NumIpAddresses;
NLB_IP_ADDRESS_INFO
*pIpInfo = ClusterCfg.pIpAddressInfo;
if (*szDedIp == 0) goto end;
//
// Go through address list, looking for this Ip address. If we find it,
// we remove it.
//
for (UINT u=0; u<NumIps; u++)
{
if (!wcscmp(szDedIp, pIpInfo[u].IpAddress))
{
//
// Found it! Move everything ahead up by one.
//
for (UINT v=u+1; v<NumIps; v++)
{
pIpInfo[v-1]=pIpInfo[v]; // Struct copy.
}
ClusterCfg.NumIpAddresses--;
//
// Zero-out last entry just for grins...
//
pIpInfo[NumIps-1].IpAddress[0]=0;
pIpInfo[NumIps-1].SubnetMask[0]=0;
break;
}
}
ARRAYSTRCPY(ClusterCfg.NlbParams.ded_ip_addr, CVY_DEF_DED_IP_ADDR);
ARRAYSTRCPY(ClusterCfg.NlbParams.ded_net_mask, CVY_DEF_DED_NET_MASK);
end:
return;
}
BOOL
get_used_port_rule_priorities(
IN const NLB_EXTENDED_CLUSTER_CONFIGURATION &Config,
IN UINT NumRules,
IN const WLBS_PORT_RULE rgRules[],
IN OUT ULONG rgUsedPriorities[] // At least NumRules
)
/*
Add to the array of bitmaps the priority that
that represents the used priorities for
each specified port rule. If the port rule is not single-host
the bitmap for that port rule is left unmodified
*/
{
const WLBS_REG_PARAMS *pParams = &Config.NlbParams;
WLBS_PORT_RULE *pCfgRules = NULL;
WBEMSTATUS wStatus;
UINT NumCfgRules = 0;
BOOL fRet = FALSE;
//
// Get the list of port rules in Config.
//
wStatus = CfgUtilGetPortRules(
pParams,
&pCfgRules,
&NumCfgRules
);
if (FAILED(wStatus))
{
pCfgRules = NULL;
goto end;
}
//
// For each port rule in rgRules, if single-host mode,
// locate the corresponding port rule in Config, and if found,
// (and the latter port rule is single-host) make a bitmap out of
// the single-host priority.
//
for (UINT u=0; u<NumRules; u++)
{
const WLBS_PORT_RULE *pCfgRule = NULL;
const WLBS_PORT_RULE *pRule = rgRules+u;
if (pRule->mode == CVY_SINGLE)
{
UINT uPriority = 0;
pCfgRule = find_port_rule(
pCfgRules,
NumCfgRules,
rgRules[u].virtual_ip_addr,
rgRules[u].start_port
);
if (pCfgRule != NULL && pCfgRule->mode == CVY_SINGLE)
{
uPriority = pCfgRule->mode_data.single.priority;
}
if (uPriority!=0)
{
rgUsedPriorities[u] |= 1<<(uPriority-1);
}
}
}
end:
delete[] pCfgRules;
return fRet;
}
const WLBS_PORT_RULE *
find_port_rule(
const WLBS_PORT_RULE *pRules,
UINT NumRules,
LPCWSTR szVIP,
UINT StartPort
)
/*
Locate the port rule with the specified vip and start-port.
Return pointer to the found rule or NULL if not found.
*/
{
const WLBS_PORT_RULE *pFoundRule = NULL;
LPCWSTR szAllVip = GETRESOURCEIDSTRING(IDS_REPORT_VIP_ALL);
for (UINT u=0;u<NumRules; u++)
{
const WLBS_PORT_RULE *pRule = pRules+u;
LPCWSTR szRuleVip = pRule->virtual_ip_addr;
//
// Unfortunately, "All" and "255.255.255.255" are synonomous :-(
//
if (!lstrcmpi(szVIP, L"255.255.255.255"))
{
szVIP = szAllVip;
}
if (!lstrcmpi(szRuleVip, L"255.255.255.255"))
{
szRuleVip = szAllVip;
}
if ( !lstrcmpi(szVIP, szRuleVip)
&& StartPort == pRule->start_port)
{
pFoundRule = pRule;
break;
}
}
return pFoundRule;
}
CEngineOperation *
CNlbEngine::mfn_NewOperationLk(ENGINEHANDLE ehObj, PVOID pvCtxt, LPCWSTR szDescription)
{
ENGINEHANDLE ehOperation;
CEngineOperation *pOperation = NULL;
if (m_fPrepareToDeinitialize)
{
goto end;
}
ehOperation = CNlbEngine::mfn_NewHandleLk(IUICallbacks::OBJ_OPERATION);
if (ehOperation == NULL)
{
TRACE_CRIT("%!FUNC! could not reserve a new operation handle");
goto end;
}
pOperation = new CEngineOperation(ehOperation, ehObj, pvCtxt);
if (pOperation == NULL)
{
TRACE_CRIT("%!FUNC!: allocation failure");
goto end;
}
pOperation->bstrDescription = _bstr_t(szDescription);
TRACE_VERB(L"%!FUNC!: map new pair(eh=0x%lx, pISpec=%p), szDescr=%ws",
(UINT) ehOperation, pOperation,
szDescription==NULL? L"<null>" : szDescription);
m_mapIdToOperation[ehOperation] = pOperation;
end:
return pOperation;
}
VOID
CNlbEngine::mfn_DeleteOperationLk(ENGINEHANDLE ehOperation)
{
CEngineOperation *pOperation;
pOperation = m_mapIdToOperation[ehOperation];
if (pOperation == NULL)
{
ASSERT(!"corrupted operation");
TRACE_CRIT("%!FUNC! corrupted operation eh 0x%lx!", ehOperation);
}
else
{
m_mapIdToOperation.erase(ehOperation);
TRACE_VERB("%!FUNC! deleting operation eh 0x%lx pOp 0x%p",
ehOperation, pOperation);
pOperation->ehOperation = NULL;
delete pOperation;
}
}
CEngineOperation *
CNlbEngine::mfn_GetOperationLk(ENGINEHANDLE ehOp)
{
CEngineOperation *pOperation;
pOperation = m_mapIdToOperation[ehOp];
if (pOperation == NULL || pOperation->ehOperation != ehOp)
{
TRACE_CRIT("%!FUNC! invalid or corrupt ehOp 0x%lx (pOp=0x%p)",
ehOp, pOperation);
pOperation = NULL;
}
return pOperation;
}
NLBERROR
CNlbEngine::mfn_StartInterfaceOperationLk(
IN ENGINEHANDLE ehIF,
IN PVOID pvCtxt,
IN LPCWSTR szDescription,
OUT ENGINEHANDLE *pExistingOperation
)
{
NLBERROR nerr = NLBERR_OK;
CInterfaceSpec *pISpec = NULL;
CEngineOperation *pOperation = NULL;
*pExistingOperation = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end;
}
if (pISpec->m_ehPendingOperation != NULL)
{
TRACE_CRIT("%!FUNC!: Not starting operation on ehIF 0x%lx because operation 0x%lx already pending",
ehIF, pISpec->m_ehPendingOperation);
*pExistingOperation = pISpec->m_ehPendingOperation;
nerr = NLBERR_BUSY;
goto end;
}
pOperation = mfn_NewOperationLk(
ehIF,
pvCtxt,
szDescription
);
if (pOperation == NULL)
{
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
TRACE_VERB("%!FUNC!: Starting operation eh 0x%lx on ehIF 0x%lx",
pOperation->ehOperation, ehIF);
pISpec->m_ehPendingOperation = pOperation->ehOperation;
pISpec->m_fPending = TRUE;
nerr = NLBERR_OK;
// fall through ...
end:
return nerr;
}
VOID
CNlbEngine::mfn_StopInterfaceOperationLk(
IN ENGINEHANDLE ehIF
)
{
CInterfaceSpec *pISpec = NULL;
ENGINEHANDLE ehOperation = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
TRACE_CRIT("%!FUNC!: Invalid ehIF 0x%lx", ehIF);
goto end;
}
ehOperation = pISpec->m_ehPendingOperation;
if (ehOperation != NULL)
{
TRACE_VERB("%!FUNC!: Stopping operation eh 0x%lx on pIspec 0x%p",
ehOperation, pISpec);
pISpec->m_ehPendingOperation = NULL;
pISpec->m_fPending = FALSE;
mfn_DeleteOperationLk(ehOperation);
}
else
{
TRACE_VERB("%!FUNC!: No operation to stop on pISpec 0x%p", pISpec);
}
end:
return;
}
NLBERROR
CNlbEngine::mfn_StartClusterOperationLk(
IN ENGINEHANDLE ehCluster,
IN PVOID pvCtxt,
IN LPCWSTR szDescription,
OUT ENGINEHANDLE *pExistingOperation
)
{
NLBERROR nerr = NLBERR_OK;
CEngineCluster *pECluster = NULL;
CClusterSpec *pCSpec = NULL;
CEngineOperation *pOperation = NULL;
*pExistingOperation = NULL;
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end;
}
pCSpec = &pECluster->m_cSpec;
if (pCSpec->m_ehPendingOperation != NULL)
{
TRACE_CRIT("%!FUNC!: Not starting operation on ehCluster 0x%lx because operation 0x%lx already pending",
ehCluster, pCSpec->m_ehPendingOperation);
*pExistingOperation = pCSpec->m_ehPendingOperation;
nerr = NLBERR_BUSY;
goto end;
}
pOperation = mfn_NewOperationLk(
ehCluster,
pvCtxt,
szDescription
);
if (pOperation == NULL)
{
nerr = NLBERR_RESOURCE_ALLOCATION_FAILURE;
goto end;
}
TRACE_VERB("%!FUNC!: Starting operation eh 0x%lx on ehC 0x%lx",
pOperation->ehOperation, ehCluster);
pCSpec->m_ehPendingOperation = pOperation->ehOperation;
pCSpec->m_fPending = TRUE;
nerr = NLBERR_OK;
// fall through ...
end:
return nerr;
}
VOID
CNlbEngine::mfn_StopClusterOperationLk(
ENGINEHANDLE ehCluster
)
{
CEngineCluster *pECluster = NULL;
CClusterSpec *pCSpec = NULL;
ENGINEHANDLE ehOperation = NULL;
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
TRACE_CRIT("%!FUNC!: Invalid ehC 0x%lx", ehCluster);
goto end;
}
pCSpec = &pECluster->m_cSpec;
ehOperation = pCSpec->m_ehPendingOperation;
if (ehOperation != NULL)
{
TRACE_VERB("%!FUNC!: Stopping operation eh 0x%lx on pCSpec 0x%p",
ehOperation, pCSpec);
pCSpec->m_ehPendingOperation = NULL;
pCSpec->m_fPending = FALSE;
mfn_DeleteOperationLk(ehOperation);
}
else
{
TRACE_VERB("%!FUNC!: No operation to stop on pCSpec 0x%p", pCSpec);
}
end:
return;
}
UINT
CNlbEngine::ListPendingOperations(
CLocalLogger &logOperations
)
//
// List pending operations -- but ONLY list those operations that
// contain non-null, non-blank descriptions.
//
{
UINT uCount = 0;
mfn_Lock();
map< ENGINEHANDLE, CEngineOperation* >::iterator iter;
for( iter = m_mapIdToOperation.begin();
iter != m_mapIdToOperation.end();
++iter)
{
CEngineOperation *pOperation = ((*iter).second);
if (pOperation != NULL)
{
LPCWSTR szDescr = pOperation->bstrDescription;
//
// Only add operations with non-null, non-blank descriptions.
// We don't list "hidden" operations -- specifically
// the transient operation created in the background work item
// to make sure that the app doesn't go away while in the work item.
//
if (szDescr != NULL && *szDescr!=0)
{
logOperations.Log(
IDS_LOG_PENDING_OPERATION,
szDescr
);
uCount++;
}
}
}
mfn_Unlock();
return uCount;
}
VOID
CNlbEngine::UpdateInterfaceWorkItem(ENGINEHANDLE ehIF)
{
ENGINEHANDLE ehOperation = NULL;
ENGINEHANDLE ehClusterId = NULL;
CEngineOperation *pExistingOp = NULL;
CInterfaceSpec *pISpec = NULL;
ENGINEHANDLE ehHostToTryRemove = NULL;
NLB_EXTENDED_CLUSTER_CONFIGURATION
*pNewCfg = NULL;
_bstr_t bstrHostName;
_bstr_t bstrClusterIp;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
ASSERT(FALSE);
TRACE_CRIT("%!FUNC! Invalid ehIF 0x%lx", ehIF);
goto end_unlock;
}
ehOperation = pISpec->m_ehPendingOperation;
if (ehOperation == NULL)
{
ASSERT(FALSE);
TRACE_CRIT("%!FUNC! ehIF 0x%lx: No pending operation", ehIF);
goto end_unlock;
}
pExistingOp = mfn_GetOperationLk(ehOperation);
if (pExistingOp == NULL)
{
ASSERT(FALSE);
TRACE_CRIT("%!FUNC! ehIF 0x%lx: Invalid ehOp 0x%lx", ehIF, ehOperation);
goto end_unlock;
}
pNewCfg = (NLB_EXTENDED_CLUSTER_CONFIGURATION *) pExistingOp->pvContext;
if (pNewCfg == NULL)
{
ASSERT(FALSE);
TRACE_CRIT("%!FUNC! ehIF 0x%lx: ehOp 0x%lx: NULL pvContext",
ehIF, ehOperation);
goto end_unlock;
}
bstrClusterIp = pNewCfg->NlbParams.cl_ip_addr;
ehClusterId = pISpec->m_ehCluster;
mfn_GetInterfaceHostNameLk(
ehIF,
REF bstrHostName
);
mfn_Unlock();
//
// Actually do the update...
//
// BOOL fClusterPropertiesUpdated = TRUE; // so we won't update...
mfn_ReallyUpdateInterface(
ehIF,
*pNewCfg
// REF fClusterPropertiesUpdated
);
m_pCallbacks->Log(
IUICallbacks::LOG_INFORMATIONAL,
(LPCWSTR) bstrClusterIp,
(LPCWSTR) bstrHostName,
IDS_LOG_END_HOST_UPDATE
);
mfn_Lock();
//
// We'll stop the operation, assumed to be started in this function.
//
mfn_StopInterfaceOperationLk(ehIF);
//
// The operation could have added or removed the IF to a cluster,
// so we need to re-obtain the cluster ID (could be NULL).
//
{
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec != NULL)
{
ehClusterId = pISpec->m_ehCluster;
//
// If NLB is unbound we need to check if the host can be
// completely removed from nlbmgr (if no interfaces on
// the host are managed by this instance of nlbmgr).
//
if (!pISpec->m_NlbCfg.IsNlbBound())
{
ehHostToTryRemove = pISpec->m_ehHostId;
}
}
}
mfn_Unlock();
//
// Notify the UI about the status change (operation complete)
//
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehClusterId,
ehIF,
IUICallbacks::EVT_STATUS_CHANGE
);
mfn_Lock();
//fall through
end_unlock:
//
// pNewCfg (if non null) was allocated before this function was
// called, and saved as the pOperation->pvContext. It's our responsibility
// to delete it here.
//
delete pNewCfg;
if (ehHostToTryRemove != NULL)
{
mfn_DeleteHostIfNotManagedLk(ehHostToTryRemove);
}
mfn_Unlock();
//
// This must be the LAST function call, because the engine may get
// wiped out after this.
//
InterlockedDecrement(&m_WorkItemCount);
}
NLBERROR
CNlbEngine::CanStartInterfaceOperation(
IN ENGINEHANDLE ehIF,
IN BOOL &fCanStart
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
CInterfaceSpec *pISpec = NULL;
fCanStart = FALSE;
mfn_Lock();
pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
nerr = NLBERR_NOT_FOUND;
goto end_unlock;
}
//
// If there is an operation ongoing, we can't start
//
if (pISpec->m_ehPendingOperation != NULL)
{
fCanStart = FALSE;
nerr = NLBERR_OK;
goto end_unlock;
}
//
// If the interface is part of a cluster, and there is a pending operation
// on that cluster, we can't start
//
if (pISpec->m_ehCluster != NULL)
{
CEngineCluster *pECluster = m_mapIdToEngineCluster[pISpec->m_ehCluster]; // map
if (pECluster == NULL)
{
//
// Invalid cluster!
//
TRACE_CRIT("%!FUNC! ehIF:0x%lx; Invalid ehCluster 0x%lx",
ehIF, pISpec->m_ehCluster);
goto end_unlock;
}
if (pECluster->m_cSpec.m_ehPendingOperation != NULL)
{
//
// A cluster-wide operation is pending -- so can't start.
//
fCanStart = FALSE;
nerr = NLBERR_OK;
goto end_unlock;
}
}
//
// Looks like we CAN start at this time (although the moment we
// exit the lock the situation may change).
//
fCanStart = TRUE;
nerr = NLBERR_OK;
end_unlock:
mfn_Unlock();
return nerr;
}
NLBERROR
CNlbEngine::mfn_ClusterOrInterfaceOperationsPendingLk(
IN CEngineCluster *pECluster,
OUT BOOL &fCanStart
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
fCanStart = FALSE;
//
// If there is an operation ongoing, we can't start
//
if (pECluster->m_cSpec.m_ehPendingOperation != NULL)
{
fCanStart = FALSE;
nerr = NLBERR_OK;
goto end;
}
//
// Lets look at all of our interfaces, checking if there are pending
// operations on each of the interfaces.
//
{
BOOL fOperationPending = FALSE;
vector<ENGINEHANDLE> &InterfaceList =
pECluster->m_cSpec.m_ehInterfaceIdList; // vector reference
for( int i = 0; i < InterfaceList.size(); ++i )
{
ENGINEHANDLE ehIF = InterfaceList[i];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
//
// Hmm... invalid interface handle? We'll ignore this one.
//
continue;
}
if (pISpec->m_ehPendingOperation != NULL)
{
fOperationPending = TRUE;
break;
}
}
if (fOperationPending)
{
fCanStart = FALSE;
nerr = NLBERR_OK;
goto end;
}
}
//
// Looks like we CAN start at this time (although the moment we
// exit the lock the situation may change).
//
fCanStart = TRUE;
nerr = NLBERR_OK;
end:
return nerr;
}
NLBERROR
CNlbEngine::CanStartClusterOperation(
IN ENGINEHANDLE ehCluster,
IN BOOL &fCanStart
)
{
CEngineCluster *pECluster = NULL;
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
fCanStart = FALSE;
mfn_Lock();
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
nerr = NLBERR_NOT_FOUND;
}
else
{
nerr = mfn_ClusterOrInterfaceOperationsPendingLk(pECluster, REF fCanStart);
}
mfn_Unlock();
return nerr;
}
DWORD
WINAPI
UpdateInterfaceWorkItemRoutine(
LPVOID lpParameter // thread data
)
{
gEngine.UpdateInterfaceWorkItem((ENGINEHANDLE) (UINT_PTR) lpParameter);
return 0;
}
DWORD
WINAPI
AddClusterMembersWorkItemRoutine(
LPVOID lpParameter // thread data
)
{
gEngine.AddOtherClusterMembersWorkItem(
(ENGINEHANDLE) (UINT_PTR) lpParameter
);
return 0;
}
BOOL
CNlbEngine::mfn_UpdateClusterProps(
ENGINEHANDLE ehCluster,
ENGINEHANDLE ehInterface
)
/*
Update the specified cluster properties to be the specified interface
properties PROVIDED:
1. The IF is a member of the cluster
2. The configuration shows that it is bound to the same cluster IP.
Return true iff the cluter props were actually updated.
*/
{
BOOL fClusterUpdated = FALSE;
CEngineCluster *pECluster = NULL;
CInterfaceSpec *pISpec = NULL;
mfn_Lock();
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pECluster == NULL || pISpec == NULL)
{
goto end_unlock;
}
if (pISpec->m_ehCluster != ehCluster)
{
goto end_unlock;
}
if ( pISpec->m_NlbCfg.IsValidNlbConfig()
&& !_wcsicmp(
pECluster->m_cSpec.m_ClusterNlbCfg.NlbParams.cl_ip_addr,
pISpec->m_NlbCfg.NlbParams.cl_ip_addr
) )
{
pECluster->m_cSpec.m_ehDefaultInterface = ehInterface;
pECluster->m_cSpec.m_ClusterNlbCfg.Update(&pISpec->m_NlbCfg);
TRACE_INFO(L"Updating ehCluster 0x%lx spec -- using ehIF 0x%lx",
ehCluster, ehInterface);
//
// Remove the dedicated IP address from cluster's version of
// the NlbParams and the IP address list.
//
remove_dedicated_ip_from_nlbcfg(REF pECluster->m_cSpec.m_ClusterNlbCfg);
//
// Since we've just read all the config (including remote control hash
// value) we can now clear the pECluster->m_cSpec.m_fNewRctPassword
// flag.
//
TRACE_VERB(L"Clearing pECluster->m_cSpec.m_fNewRctPassword");
pECluster->m_cSpec.m_fNewRctPassword = FALSE;
fClusterUpdated = TRUE;
}
end_unlock:
mfn_Unlock();
if (fClusterUpdated)
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_STATUS_CHANGE
);
}
return fClusterUpdated;
}
void
CNlbEngine::CancelAllPendingOperations(
BOOL fBlock
)
{
//
// if (fBlock), we wait until BOTH m_WorkItemCount and
// the number of operations goes to zero.
//
// An Operations are created BEFORE the workitemcount is incremented,
// so we don't have to deal with the transient possibility that
// both are zero (and we get out) but soon after the count goes to non
// zero
//
map< ENGINEHANDLE, CEngineOperation* >::iterator iter;
if (!fBlock)
{
mfn_Lock();
for( iter = m_mapIdToOperation.begin();
iter != m_mapIdToOperation.end();
++iter)
{
CEngineOperation *pOperation = ((*iter).second);
if (pOperation != NULL)
{
pOperation->fCanceled = TRUE;
}
}
mfn_Unlock();
}
else
{
//
// If we're asked to block, we assume that this is while
// we're prepairing to deinitialize, at which point we are
// guaranteed that no new operations can be added.
// It is possible that new work items can be added,
// however a work item is created in the context of
// an operation, so once the operation count goes
// to zero, no new work items will be created.
//
ASSERT(m_fPrepareToDeinitialize);
BOOL fPending = FALSE;
do
{
fPending = FALSE;
mfn_Lock();
for( iter = m_mapIdToOperation.begin();
iter != m_mapIdToOperation.end();
++iter)
{
CEngineOperation *pOperation = ((*iter).second);
if (pOperation != NULL)
{
pOperation->fCanceled = TRUE;
fPending = TRUE;
}
}
//
// The additional check below must come AFTER the previous
// loop. If we had this check before the loop, it could be that
// there are no work item's before we check the loop, but the
// instant we check the loop for operations, the work item count
// goes positive but when we actually check the loop here are zero
// operations. Actually that's not possible because we have
// mfn_Lock held, so never mind.
//
//
fPending |= (m_WorkItemCount > 0);
mfn_Unlock();
if (fPending)
{
ProcessMsgQueue();
Sleep(50);
}
} while (fPending);
}
return;
}
NLBERROR
CNlbEngine::mfn_WaitForInterfaceOperationCompletions(
IN ENGINEHANDLE ehCluster
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
CEngineCluster *pECluster = NULL;
CClusterSpec *pCSpec = NULL;
ENGINEHANDLE ehOperation = NULL;
BOOL fOperationsPending = FALSE;
mfn_Lock();
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
TRACE_CRIT("%!FUNC!: Invalid ehC 0x%lx", ehCluster);
goto end_unlock;
}
pCSpec = &pECluster->m_cSpec;
ehOperation = pCSpec->m_ehPendingOperation;
if (ehOperation == NULL)
{
//
// We expect that this function is only called when there is a
// pending cluster-wide operation.
//
TRACE_CRIT("%!FUNC! ehC 0x%lx Failing because no cluster operation pending", ehCluster);
goto end_unlock;
}
//
// Now in a loop, enumerate the interfaces in the cluster,
// cheking for pending operations.
//
TRACE_INFO(L"%!FUNC! Begin wait for cluster ehC 0x%lx operations to complete", ehCluster);
do
{
fOperationsPending = FALSE;
vector<ENGINEHANDLE> &InterfaceList =
pECluster->m_cSpec.m_ehInterfaceIdList; // vector reference
for( int i = 0; i < InterfaceList.size(); ++i )
{
ENGINEHANDLE ehIF = InterfaceList[i];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
//
// Hmm... invalid interface handle? We'll ignore this one.
//
continue;
}
if (pISpec->m_ehPendingOperation != NULL)
{
fOperationsPending = TRUE;
break;
}
}
if (fOperationsPending)
{
mfn_Unlock();
for (UINT u=0;u<50;u++)
{
ProcessMsgQueue();
Sleep(100);
}
mfn_Lock();
}
}
while (fOperationsPending);
TRACE_INFO(L"%!FUNC! End wait for cluster ehC 0x%lx operations to complete.", ehCluster);
nerr = NLBERR_OK;
end_unlock:
mfn_Unlock();
return nerr;
}
//
// Verifies that all interfaces and the cluster have the same cluster mode.
//
// Will fail if any interface is marked misconfigured or is
// not bound to NLB.
//
// On returning success, fSameMode is set to TRUE iff all IFs and the
// cluster have the same mode.
//
NLBERROR
CNlbEngine::mfn_VerifySameModeLk(
IN ENGINEHANDLE ehCluster,
OUT BOOL &fSameMode
)
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
CEngineCluster *pECluster = NULL;
CClusterSpec *pCSpec = NULL;
fSameMode = FALSE;
mfn_Lock();
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
if (pECluster == NULL)
{
TRACE_CRIT("%!FUNC!: Invalid ehC 0x%lx", ehCluster);
goto end_unlock;
}
pCSpec = &pECluster->m_cSpec;
//
// Let's check for mode changes...
//
{
BOOL fConfigError = FALSE;
NLB_EXTENDED_CLUSTER_CONFIGURATION::TRAFFIC_MODE tmC;
tmC = pCSpec->m_ClusterNlbCfg.GetTrafficMode();
vector<ENGINEHANDLE> &InterfaceList =
pECluster->m_cSpec.m_ehInterfaceIdList; // vector reference
fSameMode = TRUE;
for( int i = 0; i < InterfaceList.size(); ++i )
{
ENGINEHANDLE ehIF = InterfaceList[i];
CInterfaceSpec *pISpec = m_mapIdToInterfaceSpec[ehIF]; // map
if (pISpec == NULL)
{
//
// Hmm... invalid interface handle? We'll ignore this one.
//
continue;
}
//
// Note: we can't check for pISpec->m_fMisconfigured because
// the cluster may be marked misconfig because it doesn't
// match the cluster parameters, which can happen on
// mode changes (the ip addresses could be missing in the
// interface).
//
if (!pISpec->m_NlbCfg.IsValidNlbConfig())
{
fConfigError = TRUE;
break;
}
{
NLB_EXTENDED_CLUSTER_CONFIGURATION::TRAFFIC_MODE tmI;
tmI = pISpec->m_NlbCfg.GetTrafficMode();
if (tmI != tmC)
{
//
// Mode change!
//
fSameMode = FALSE;
break;
}
}
}
if (fConfigError)
{
nerr = NLBERR_INVALID_CLUSTER_SPECIFICATION;
fSameMode = FALSE;
}
else
{
nerr = NLBERR_OK;
}
}
end_unlock:
mfn_Unlock();
return nerr;
}
VOID
CNlbEngine::AddOtherClusterMembers(
IN ENGINEHANDLE ehInterface,
IN BOOL fSync
)
{
BOOL fStopOperationOnExit = FALSE;
ENGINEHANDLE ehCluster = NULL;
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
//
// Get cluster ID, and attempt to start a cluster-wide operation
// on it
//
{
mfn_Lock();
CInterfaceSpec *pISpec = NULL;
CClusterSpec *pCSpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec != NULL)
{
ehCluster = pISpec->m_ehCluster;
if (ehCluster != NULL)
{
CEngineCluster *pECluster = NULL;
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
pCSpec = &pECluster->m_cSpec;
}
}
if (pCSpec == NULL)
{
TRACE_CRIT(L"%!FUNC! Could not get interface or cluster associated with ehIF 0x%08lx", ehInterface);
goto end_unlock;
}
//
// Attempt to start the update operation -- will fail if there is
// already an operation started on this cluster.
//
{
ENGINEHANDLE ExistingOp= NULL;
CLocalLogger logDescription;
logDescription.Log(
IDS_LOG_ADD_CLUSTER_MEMBERS_OPERATION_DESCRIPTION,
pCSpec->m_ClusterNlbCfg.NlbParams.cl_ip_addr
);
nerr = mfn_StartClusterOperationLk(
ehCluster,
NULL, // pvCtxt
logDescription.GetStringSafe(),
&ExistingOp
);
if (NLBFAILED(nerr))
{
//
// TODO: Log the fact that we couldn't do the update because
// of existing activity.
//
goto end_unlock;
}
else
{
//
// At this point we're cleared to do a cluster-wide operation.
//
fStopOperationOnExit = TRUE;
InterlockedIncrement(&m_WorkItemCount);
}
}
mfn_Unlock();
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_STATUS_CHANGE
);
}
if (fSync)
{
this->AddOtherClusterMembersWorkItem(
ehInterface
);
fStopOperationOnExit = FALSE; // it'll be stopped by the above func.
}
else
{
BOOL fRet;
//
// We'll perform the operation in the background...
//
fRet = QueueUserWorkItem(
AddClusterMembersWorkItemRoutine,
(PVOID) (UINT_PTR) ehInterface,
WT_EXECUTELONGFUNCTION
);
if (fRet)
{
fStopOperationOnExit = FALSE; // it'll be stopped in the background
}
else
{
TRACE_CRIT(L"%!FUNC! Could not queue work item");
//
// We don't bother to log this evidently low-resource situation.
//
}
}
mfn_Lock();
end_unlock:
if (fStopOperationOnExit)
{
mfn_StopClusterOperationLk(ehCluster);
}
mfn_Unlock();
if (fStopOperationOnExit)
{
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_STATUS_CHANGE
);
InterlockedDecrement(&m_WorkItemCount);
}
return;
}
VOID
CNlbEngine::AddOtherClusterMembersWorkItem(
IN ENGINEHANDLE ehInterface
)
{
ENGINEHANDLE ehCluster = NULL;
ENGINEHANDLE ehHost = NULL;
_bstr_t bstrUserName;
_bstr_t bstrPassword;
_bstr_t bstrConnectionString;
_bstr_t bstrNicGuid;
_bstr_t bstrClusterIp;
DWORD NumMembers = 0;
NLB_CLUSTER_MEMBER_INFO *pMembers = NULL;
{
mfn_Lock();
CInterfaceSpec *pISpec = NULL;
CClusterSpec *pCSpec = NULL;
CHostSpec *pHSpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehInterface]; // map
if (pISpec != NULL)
{
ehCluster = pISpec->m_ehCluster;
if (ehCluster != NULL)
{
CEngineCluster *pECluster = NULL;
pECluster = m_mapIdToEngineCluster[ehCluster]; // map
pCSpec = &pECluster->m_cSpec;
if (pCSpec->m_ClusterNlbCfg.IsValidNlbConfig())
{
bstrClusterIp = pCSpec->m_ClusterNlbCfg.NlbParams.cl_ip_addr;
}
}
}
if (pCSpec == NULL)
{
TRACE_CRIT(L"%!FUNC! Could not get interface or cluster associated with ehIF 0x%08lx", ehInterface);
goto end_unlock;
}
ehHost = pISpec->m_ehHostId;
//
// Get the host ID
//
if (ehHost != NULL)
{
pHSpec = m_mapIdToHostSpec[ehHost]; // map
}
if (pHSpec == NULL)
{
TRACE_CRIT("%!FUNC! Could not get ptr to host spec. Bailing.");
goto end_unlock;
}
//
// Save copies of these in local bstrs before we unlock...
//
bstrUserName = pHSpec->m_UserName;
bstrPassword = pHSpec->m_Password;
bstrConnectionString = pHSpec->m_ConnectionString;
bstrNicGuid = pISpec->m_Guid;
if ((LPCWSTR)bstrNicGuid == (LPCWSTR)NULL)
{
// probably a low-memory situation...
goto end_unlock;
}
mfn_Unlock();
}
//
// Attempt to get the list of other cluster members from the
// interface
//
{
WMI_CONNECTION_INFO ConnInfo;
WBEMSTATUS wStat;
LPCWSTR szNicGuid = bstrNicGuid;
ZeroMemory(&ConnInfo, sizeof(ConnInfo));
ConnInfo.szMachine = (LPCWSTR) bstrConnectionString;
ConnInfo.szUserName = (LPCWSTR) bstrUserName;
ConnInfo.szPassword = (LPCWSTR) bstrPassword;
wStat = NlbHostGetClusterMembers(
&ConnInfo,
szNicGuid,
&NumMembers,
&pMembers // free using delete[]
);
if (FAILED(wStat))
{
NumMembers = 0;
pMembers = NULL;
//
// TODO: Log error
//
mfn_Lock();
goto end_unlock;
}
}
//
// For each member, attempt to connect to that host and add the specific
// cluster.
//
{
WBEMSTATUS wStat;
LPCWSTR szNicGuid = bstrNicGuid;
#if 0
CLocalLogger logger;
for (UINT u=0; u<NumMembers; u++)
{
NLB_CLUSTER_MEMBER_INFO *pMember = pMembers+u;
logger.Log(
IDS_DBG_LOG_ADD_CLUSTER_MEMBER,
pMember->HostId,
pMember->DedicatedIpAddress,
pMember->HostName
);
}
::MessageBox(
NULL,
logger.GetStringSafe(), // contents
L"DEBUGINFO: GOING TO ADD THESE HOSTS...",
MB_ICONINFORMATION | MB_OK
);
#endif // 0
for (UINT u=0; u<NumMembers; u++)
{
NLB_CLUSTER_MEMBER_INFO *pMember = pMembers+u;
WMI_CONNECTION_INFO ConnInfo;
ZeroMemory(&ConnInfo, sizeof(ConnInfo));
ConnInfo.szUserName = (LPCWSTR) bstrUserName;
ConnInfo.szPassword = (LPCWSTR) bstrPassword;
if (*pMember->HostName != 0)
{
ConnInfo.szMachine = pMember->HostName;
} else if (*pMember->DedicatedIpAddress != 0
&& (_wcsicmp(pMember->DedicatedIpAddress,
L"0.0.0.0")))
{
// non-blank dedicated IP -- let's try that...
ConnInfo.szMachine = pMember->DedicatedIpAddress;
}
if (ConnInfo.szMachine == NULL)
{
// Can't connect to this IP
// TODO: inform user in some way
continue;
}
//
// Now actually attempt to add the host
//
this->LoadHost(&ConnInfo, (LPCWSTR) bstrClusterIp);
}
}
mfn_Lock();
end_unlock:
if (ehCluster != NULL)
{
mfn_StopClusterOperationLk(ehCluster);
}
mfn_Unlock();
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_CLUSTER,
ehCluster,
ehCluster,
IUICallbacks::EVT_STATUS_CHANGE
);
delete [] pMembers; // may be NULL
InterlockedDecrement(&m_WorkItemCount); // Don't touch this after this,
// because it may no longer be valid
return;
}
NLBERROR
CNlbEngine::LoadHost(
IN PWMI_CONNECTION_INFO pConnInfo,
IN LPCWSTR szClusterIp OPTIONAL
)
{
ENGINEHANDLE ehHostId;
_bstr_t bstrConnectError;
CHostSpec hSpec;
NLBERROR err = NLBERR_INTERNAL_ERROR;
TRACE_INFO(L"-> %!FUNC! Host name : %ls", (LPCWSTR)(pConnInfo->szMachine));
if (m_fPrepareToDeinitialize)
{
err = NLBERR_CANCELLED;
goto end;
}
m_pCallbacks->Log(IUICallbacks::LOG_INFORMATIONAL, NULL, NULL,
IDS_LOADFILE_LOOKING_FOR_CLUSTERS, pConnInfo->szMachine);
ProcessMsgQueue();
err = this->ConnectToHost(
pConnInfo,
FALSE, // FALSE == don't overwrite connection info if
// already present
REF ehHostId,
REF bstrConnectError
);
if (err != NLBERR_OK)
{
m_pCallbacks->Log(IUICallbacks::LOG_ERROR, NULL, NULL, IDS_CONNECT_TO_HOST_FAILED, (LPCWSTR)bstrConnectError, (LPCWSTR)(pConnInfo->szMachine));
TRACE_CRIT(L"<- %!FUNC! ConnectToHost returned error (string : %ls, retval : 0x%x)",(LPCWSTR)bstrConnectError, err);
goto end;
}
if ((err = this->GetHostSpec(ehHostId, REF hSpec)) != NLBERR_OK)
{
m_pCallbacks->Log(IUICallbacks::LOG_ERROR, NULL, NULL, IDS_CRITICAL_ERROR_HOST, (LPCWSTR)(pConnInfo->szMachine));
TRACE_CRIT(L"<- %!FUNC! GetHostSpec returned error : 0x%x", err);
goto end;
}
//
// Extract list of interfaces
//
for( int i = 0; i < hSpec.m_ehInterfaceIdList.size(); ++i )
{
ENGINEHANDLE ehIID = hSpec.m_ehInterfaceIdList[i];
CInterfaceSpec iSpec;
ProcessMsgQueue();
if ((err = this->GetInterfaceSpec(ehIID, REF iSpec)) != NLBERR_OK)
{
m_pCallbacks->Log(IUICallbacks::LOG_ERROR, NULL, NULL, IDS_CRITICAL_ERROR_HOST, (LPCWSTR)(pConnInfo->szMachine));
TRACE_CRIT(L"%!FUNC! GetInterfaceSpec returned error : 0x%x", err);
continue;
}
//
// Check if interface has NLB bound to it
// AND it is NOT part of a cluster that nlb manager is already managing
// AND (if szClusterIp NON-NULL, it matches the specified cluster IP
//
//
if (iSpec.m_NlbCfg.IsNlbBound() && (iSpec.m_ehCluster == NULL))
{
LPCWSTR szThisClusterIp;
ENGINEHANDLE ehCluster;
BOOL fIsNew;
szThisClusterIp = iSpec.m_NlbCfg.NlbParams.cl_ip_addr;
if ( szClusterIp != NULL
&& _wcsicmp(szClusterIp, szThisClusterIp))
{
// different cluster ip
TRACE_INFO(L"%!FUNC! Skipping cluster with CIP %ws because it doesn't match passed-in CIP %ws",
szThisClusterIp, szClusterIp);
continue;
}
if ((err = this->LookupClusterByIP(szThisClusterIp, &(iSpec.m_NlbCfg), REF ehCluster, REF fIsNew)) != NLBERR_OK)
{
m_pCallbacks->Log(IUICallbacks::LOG_ERROR, NULL, NULL, IDS_CRITICAL_ERROR_HOST, (LPCWSTR)(pConnInfo->szMachine));
TRACE_CRIT(L"%!FUNC! LookupClusterByIP returned error : 0x%x for cluster ip : %ls", err, szThisClusterIp);
continue;
}
if (this->AddInterfaceToCluster(ehCluster, ehIID) != NLBERR_OK)
{
m_pCallbacks->Log(IUICallbacks::LOG_ERROR, NULL, NULL, IDS_CRITICAL_ERROR_HOST, (LPCWSTR)(pConnInfo->szMachine));
TRACE_CRIT(L"%!FUNC! AddInterfaceToCluster returned error : 0x%x", err);
continue;
}
/* Analyze this interface for misconfiguration */
this->AnalyzeInterface_And_LogResult(ehIID);
}
}
end:
ProcessMsgQueue();
TRACE_INFO(L"<- %!FUNC!");
return err;
}
/*
The following function analyzes the specified NLB interface for misconfiguration and logs
the result. I created this function (as opposed to adding it inline) because this code
needs to run in two cases:
1. CNLBEngine::LoadHost
2. LeftView::OnWorldConnect
--KarthicN, July 31, 2002
*/
VOID
CNlbEngine::AnalyzeInterface_And_LogResult(ENGINEHANDLE ehIID)
{
CLocalLogger logger;
NLBERROR err;
mfn_Lock();
err = this->mfn_AnalyzeInterfaceLk(ehIID, REF logger);
if (NLBFAILED(err))
{
ENGINEHANDLE ehCluster;
LPCWSTR szDetails = NULL;
UINT Size = 0;
logger.ExtractLog(szDetails, Size);
mfn_SetInterfaceMisconfigStateLk(m_mapIdToInterfaceSpec[ehIID], TRUE, szDetails);
mfn_Unlock();
//
// Log ...
//
LPCWSTR szCluster = NULL;
LPCWSTR szHostName = NULL;
LPCWSTR szInterface = NULL;
ENGINEHANDLE ehHost;
_bstr_t bstrDisplayName;
_bstr_t bstrFriendlyName;
_bstr_t bstrHostName;
_bstr_t bstrIpAddress;
err = this->GetInterfaceIdentification(
ehIID,
REF ehHost,
REF ehCluster,
REF bstrFriendlyName,
REF bstrDisplayName,
REF bstrHostName
);
if (NLBOK(err))
{
_bstr_t bstrDomainName;
_bstr_t bstrClusterDisplayName;
err = this->GetClusterIdentification(
ehCluster,
REF bstrIpAddress,
REF bstrDomainName,
REF bstrClusterDisplayName
);
if (NLBOK(err))
{
szCluster = bstrIpAddress;
}
szHostName = bstrHostName;
szInterface = bstrFriendlyName;
}
IUICallbacks::LogEntryHeader Header;
Header.szDetails = szDetails;
Header.type = IUICallbacks::LOG_ERROR;
Header.szCluster = szCluster;
Header.szHost = szHostName;
Header.szInterface = szInterface;
m_pCallbacks->LogEx(
&Header,
IDS_LOG_INTERFACE_MISCONFIGURATION
);
// Change Icon to "Banged out"
m_pCallbacks->HandleEngineEvent(
IUICallbacks::OBJ_INTERFACE,
ehCluster,
ehIID,
IUICallbacks::EVT_STATUS_CHANGE
);
}
else
{
mfn_Unlock();
}
return;
}
VOID
CNlbEngine::mfn_DeleteHostIfNotManagedLk(
ENGINEHANDLE ehHost
)
/*
Checks all the interfaces of host ehHost. If none of them are
members of any cluster, and no pending operations are existing on
them, we will delete the host and all its interfaces.
Called with lock held!
*/
{
CHostSpec *pHSpec = NULL;
BOOL fBusy = FALSE;
UINT u;
pHSpec = m_mapIdToHostSpec[ehHost]; // map
if (pHSpec == NULL) goto end;
// DummyAction(L"DeleteHostIfNotManaged");
//
// Go through the list of interfaces, seeing if ANY interface
// is part of a cluster or there are updates pending on it..
//
for(u = 0; u < pHSpec->m_ehInterfaceIdList.size(); ++u )
{
ENGINEHANDLE ehIId = pHSpec->m_ehInterfaceIdList[u];
CInterfaceSpec *pISpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL) continue;
ASSERT(pISpec->m_ehHostId == ehHost);
if (pISpec->m_ehCluster != NULL)
{
// Found an interface still part of a cluster, bail.
fBusy = TRUE;
break;
}
//
//
//
if (pISpec->m_ehPendingOperation != NULL)
{
//
// We really don't expect this, but it COULD happen.
//
TRACE_CRIT("Ignoring eh(0x%x) because it has pending operation 0x%x even though it's not a part of a cluster.",
ehIId,
pISpec->m_ehPendingOperation
);
fBusy = TRUE;
break;
}
}
if (fBusy) goto end;
TRACE_INFO(L"Deleting all interfaces under host eh(0x%x)", ehHost);
for(u = 0; u < pHSpec->m_ehInterfaceIdList.size(); ++u )
{
ENGINEHANDLE ehIId = pHSpec->m_ehInterfaceIdList[u];
CInterfaceSpec *pISpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL) continue;
ASSERT(pISpec->m_ehHostId == ehHost);
ASSERT(pISpec->m_ehCluster == NULL); // we checked above
ASSERT(pISpec->m_ehPendingOperation == NULL); // we checked above
//
// Kill this interface!
//
TRACE_INFO(L"Deleting Interface eh=0x%x pISpec=0x%p",
ehIId, pISpec);
m_mapIdToInterfaceSpec.erase(ehIId);
delete pISpec;
}
//
// Erase the list of intefaces for this host...
//
pHSpec->m_ehInterfaceIdList.clear();
#if 1
//
// Now delete the host
//
TRACE_INFO(L"Deleting Host eh=0x%x pHSpec=0x%p",
ehHost, pHSpec);
m_mapIdToHostSpec.erase(ehHost);
delete pHSpec;
#endif // 0
end:
return;
}
VOID
CNlbEngine::PurgeUnmanagedHosts(void)
{
vector <ENGINEHANDLE> PurgeHostList;
TRACE_INFO(L"-> %!FUNC!");
mfn_Lock();
map< ENGINEHANDLE, CHostSpec* >::iterator iter;
for( iter = m_mapIdToHostSpec.begin();
iter != m_mapIdToHostSpec.end();
++iter)
{
CHostSpec *pHSpec = (CHostSpec *) ((*iter).second);
ENGINEHANDLE ehHost = (ENGINEHANDLE) ((*iter).first);
if (pHSpec != NULL)
{
if (!mfn_HostHasManagedClustersLk(pHSpec))
{
//
// No managed clusters on this host -- a candidate
// for deleting.
//
PurgeHostList.push_back(ehHost);
}
}
}
//
// Now try to delete the hosts...
// We do this out of the enumeration above because we want to
// avoid modifying the map while we're iterating through it.
//
for(int i = 0; i < PurgeHostList.size(); ++i )
{
ENGINEHANDLE ehHost = PurgeHostList[i];
if (ehHost != NULL)
{
mfn_DeleteHostIfNotManagedLk(ehHost);
}
}
mfn_Unlock();
TRACE_INFO(L"<- %!FUNC!");
}
NLBERROR
CNlbEngine::mfn_CheckHost(
IN PWMI_CONNECTION_INFO pConnInfo,
IN ENGINEHANDLE ehHost // OPTIONAL
)
/*
TODO -- this function shares code with ConnectToHost -- get rid of
the duplicated code somehow.
*/
{
NLBERROR nerr = NLBERR_INTERNAL_ERROR;
LPWSTR szWmiMachineName = NULL;
LPWSTR szWmiMachineGuid = NULL;
WBEMSTATUS wStatus;
ULONG uIpAddress;
BOOL fNlbMgrProviderInstalled = FALSE;
_bstr_t bstrError;
TRACE_INFO(L"-> %!FUNC!(%ws)", pConnInfo->szMachine);
wStatus = NlbHostPing(pConnInfo->szMachine, 2000, &uIpAddress);
if (FAILED(wStatus))
{
nerr = NLBERR_PING_TIMEOUT; // todo more specific error.
bstrError = GETRESOURCEIDSTRING(IDS_PING_FAILED);
}
else
{
wStatus = NlbHostGetMachineIdentification(
pConnInfo,
&szWmiMachineName,
&szWmiMachineGuid,
&fNlbMgrProviderInstalled
);
if (FAILED(wStatus))
{
GetErrorCodeText(wStatus, bstrError);
if (wStatus == E_ACCESSDENIED)
{
nerr = NLBERR_ACCESS_DENIED;
}
else
{
// TODO: map proper errors.
nerr = NLBERR_NOT_FOUND;
}
TRACE_CRIT(L"Connecting to %ws returns error %ws",
pConnInfo->szMachine, (LPCWSTR) bstrError);
szWmiMachineName = NULL;
szWmiMachineGuid = NULL;
}
else
{
nerr = NLBERR_OK;
}
}
delete szWmiMachineName;
delete szWmiMachineGuid;
if (ehHost!=NULL)
{
CHostSpec *pHSpec = NULL;
mfn_Lock();
pHSpec = m_mapIdToHostSpec[ehHost]; // map
if (pHSpec != NULL)
{
if (NLBOK(nerr) || nerr == NLBERR_ACCESS_DENIED)
{
pHSpec->m_fUnreachable = FALSE;
}
else
{
pHSpec->m_fUnreachable = TRUE;
}
}
else
{
}
mfn_Unlock();
//
// Update the status of the specified host...
//
mfn_NotifyHostInterfacesChange(ehHost);
//
// Log error
//
if (NLBFAILED(nerr))
{
m_pCallbacks->Log(
IUICallbacks::LOG_ERROR,
NULL,
(LPCWSTR)(pConnInfo->szMachine),
IDS_CONNECT_TO_HOST_FAILED,
(LPCWSTR)bstrError,
(LPCWSTR)(pConnInfo->szMachine)
);
TRACE_CRIT(L"<- %!FUNC! returning error (string : %ls, retval : 0x%x)",
(LPCWSTR)bstrError, nerr);
}
}
return nerr;
}
VOID
CNlbEngine::mfn_UnlinkHostFromClusters(
IN ENGINEHANDLE ehHost
)
{
CHostSpec *pHSpec = NULL;
BOOL fBusy = FALSE;
UINT u;
vector <ENGINEHANDLE> UnlinkInterfaceList;
mfn_Lock();
pHSpec = m_mapIdToHostSpec[ehHost]; // map
if (pHSpec == NULL) goto end;
//
// Go through the list of interfaces, adding any interfaces
// that are part of a cluster to a temporary list.
//
for(u = 0; u < pHSpec->m_ehInterfaceIdList.size(); ++u )
{
ENGINEHANDLE ehIId = pHSpec->m_ehInterfaceIdList[u];
CInterfaceSpec *pISpec = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL) continue;
ASSERT(pISpec->m_ehHostId == ehHost);
if (pISpec->m_ehCluster != NULL)
{
//
// Add this to the list of interfaces we're going to unlink
// from its cluster.
//
UnlinkInterfaceList.push_back(ehIId);
}
}
pHSpec = NULL;
TRACE_INFO(L"Unlinking all interfaces under host eh(0x%x)", ehHost);
for(u = 0; u < UnlinkInterfaceList.size(); ++u )
{
ENGINEHANDLE ehIId = UnlinkInterfaceList[u];
CInterfaceSpec *pISpec = NULL;
ENGINEHANDLE ehCluster = NULL;
pISpec = m_mapIdToInterfaceSpec[ehIId]; // map
if (pISpec == NULL) continue;
ASSERT(pISpec->m_ehHostId == ehHost);
ehCluster = pISpec->m_ehCluster;
if (ehCluster != NULL)
{
mfn_Unlock();
(VOID) CNlbEngine::RemoveInterfaceFromCluster(ehCluster, ehIId);
mfn_Lock();
}
}
end:
mfn_Unlock();
return;
}
VOID
CNlbEngine::UnmanageHost(ENGINEHANDLE ehHost)
{
mfn_UnlinkHostFromClusters(ehHost);
mfn_Lock();
mfn_DeleteHostIfNotManagedLk(ehHost);
mfn_Unlock();
}