3134 lines
77 KiB
C++
3134 lines
77 KiB
C++
//+----------------------------------------------------------------------------
|
|
//
|
|
// File: control.cpp
|
|
//
|
|
// Module:
|
|
//
|
|
// Description: Implement class CWlbsControl
|
|
//
|
|
// Copyright (C) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// Author: Created 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
#include "precomp.h"
|
|
|
|
#include <debug.h>
|
|
#include "cluster.h"
|
|
#include "control.h"
|
|
#include "param.h"
|
|
#include "control.tmh" // for event tracing
|
|
|
|
|
|
//
|
|
// Global variable for the dll instance
|
|
//
|
|
HINSTANCE g_hInstCtrl;
|
|
|
|
//
|
|
// Helper functions
|
|
//
|
|
DWORD MapStateFromDriverToApi(DWORD dwDriverState);
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: IsLocalHost
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: CWlbsCluster* pCluster -
|
|
// DWORD dwHostID -
|
|
//
|
|
// Returns: inline bool -
|
|
//
|
|
// History: fengsun Created Header 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
inline bool IsLocalHost(CWlbsCluster* pCluster, DWORD dwHostID)
|
|
{
|
|
if (pCluster == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return dwHostID == WLBS_LOCAL_HOST; // || pCluster->GetHostID() == dwHostID;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: QueryPortFromSocket
|
|
//
|
|
// Synopsis:
|
|
// This routine retrieves the port number to which a socket is bound.
|
|
//
|
|
// Arguments:
|
|
// Socket - the socket to be queried
|
|
//
|
|
// Return Value:
|
|
// USHORT - the port number retrieved
|
|
//
|
|
// History: Created Header 2/10/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
static USHORT QueryPortFromSocket(SOCKET Socket)
|
|
{
|
|
SOCKADDR_IN Address;
|
|
int AddressLength;
|
|
AddressLength = sizeof(Address);
|
|
getsockname(Socket, (PSOCKADDR)&Address, &AddressLength);
|
|
return Address.sin_port;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::CWlbsControl
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CWlbsControl::CWlbsControl()
|
|
{
|
|
m_local_ctrl = FALSE;
|
|
m_remote_ctrl = FALSE;
|
|
m_hdl = INVALID_HANDLE_VALUE;
|
|
m_registry_lock = INVALID_HANDLE_VALUE;
|
|
m_def_dst_addr = 0;
|
|
m_def_timeout = IOCTL_REMOTE_RECV_DELAY;
|
|
m_def_port = CVY_DEF_RCT_PORT;
|
|
m_def_passw = CVY_DEF_RCT_PASSWORD;
|
|
|
|
m_dwNumCluster = 0;
|
|
|
|
for (int i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
m_cluster_params [i] . cluster = 0;
|
|
m_cluster_params [i] . passw = CVY_DEF_RCT_PASSWORD;
|
|
m_cluster_params [i] . timeout = IOCTL_REMOTE_RECV_DELAY;
|
|
m_cluster_params [i] . port = CVY_DEF_RCT_PORT;
|
|
m_cluster_params [i] . dest = 0;
|
|
}
|
|
|
|
ZeroMemory(m_pClusterArray, sizeof(m_pClusterArray));
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::~CWlbsControl
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CWlbsControl::~CWlbsControl()
|
|
{
|
|
for (DWORD i=0; i< m_dwNumCluster; i++)
|
|
{
|
|
delete m_pClusterArray[i];
|
|
}
|
|
|
|
if (m_hdl)
|
|
{
|
|
CloseHandle(m_hdl);
|
|
}
|
|
|
|
if (m_remote_ctrl)
|
|
{
|
|
WSACleanup(); // WSAStartup is called in Initialize()
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::Initialize
|
|
//
|
|
// Description: Initialization
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: bool - true if succeeded
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::Initialize()
|
|
{
|
|
WORD ver;
|
|
int ret;
|
|
|
|
if (IsInitialized())
|
|
{
|
|
ReInitialize();
|
|
return GetInitResult();
|
|
}
|
|
|
|
_tsetlocale (LC_ALL, _TEXT(".OCP"));
|
|
|
|
|
|
/* open Winsock */
|
|
|
|
WSADATA data;
|
|
|
|
if (WSAStartup (WINSOCK_VERSION, & data) == 0)
|
|
{
|
|
/* figure out client IP address */
|
|
CHAR buf [CVY_STR_SIZE];
|
|
|
|
ret = gethostname (buf, CVY_STR_SIZE);
|
|
|
|
if (ret != SOCKET_ERROR)
|
|
{
|
|
struct hostent * host;
|
|
host = gethostbyname (buf);
|
|
|
|
m_dwSrcAddress = 0;
|
|
|
|
if ( host && ((struct in_addr *) (host -> h_addr)) -> s_addr != 0)
|
|
{
|
|
m_remote_ctrl = TRUE;
|
|
m_dwSrcAddress = ((struct in_addr *) (host -> h_addr)) -> s_addr;
|
|
}
|
|
}
|
|
|
|
if (!m_remote_ctrl)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed. gethostname return %d", ret);
|
|
WSACleanup();
|
|
}
|
|
}
|
|
|
|
|
|
/* if succeeded querying local parameters - connect to device */
|
|
|
|
if (m_hdl != INVALID_HANDLE_VALUE)
|
|
CloseHandle (m_hdl);
|
|
|
|
m_hdl = CreateFile (_TEXT("\\\\.\\WLBS"), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
|
|
|
|
if (m_hdl == INVALID_HANDLE_VALUE)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed to open wlbs device %d", GetLastError());
|
|
return GetInitResult();
|
|
}
|
|
else
|
|
{
|
|
m_local_ctrl = TRUE;
|
|
}
|
|
|
|
//
|
|
// enumerate clusters
|
|
//
|
|
|
|
HKEY hKeyWlbs;
|
|
DWORD dwError;
|
|
|
|
dwError = RegOpenKeyEx (HKEY_LOCAL_MACHINE,
|
|
L"SYSTEM\\CurrentControlSet\\Services\\WLBS\\Parameters\\Interface",
|
|
0L, KEY_READ, & hKeyWlbs);
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
return GetInitResult();
|
|
}
|
|
|
|
m_dwNumCluster = 0;
|
|
|
|
for (int index=0;;index++)
|
|
{
|
|
WCHAR szAdapterGuid[128];
|
|
DWORD dwSize = sizeof(szAdapterGuid)/sizeof(szAdapterGuid[0]);
|
|
|
|
dwError = RegEnumKeyEx(hKeyWlbs, index,
|
|
szAdapterGuid, &dwSize,
|
|
NULL, NULL, NULL, NULL);
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
if (dwError != ERROR_NO_MORE_ITEMS)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed at RegEnumKeyEx %d", dwError);
|
|
}
|
|
break;
|
|
}
|
|
|
|
GUID AdapterGuid;
|
|
HRESULT hr = CLSIDFromString(szAdapterGuid, &AdapterGuid);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed at CLSIDFromString %s", szAdapterGuid);
|
|
continue;
|
|
}
|
|
|
|
IOCTL_CVY_BUF in_buf;
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
DWORD status = WlbsLocalControl (m_hdl, AdapterGuid,
|
|
IOCTL_CVY_QUERY, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Use index instead of m_dwNumCluster as the cluster index
|
|
// m_dwNumCluster will change is a adapter get unbound.
|
|
// index will change only if an adapter get removed
|
|
//
|
|
m_pClusterArray[m_dwNumCluster] = new CWlbsCluster(index);
|
|
|
|
if (m_pClusterArray[m_dwNumCluster] == NULL)
|
|
{
|
|
LOG_ERROR("CWlbsControl::Initialize failed to allocate memory");
|
|
ASSERT(m_pClusterArray[m_dwNumCluster]);
|
|
}
|
|
else
|
|
{
|
|
m_pClusterArray[m_dwNumCluster]->Initialize(AdapterGuid);
|
|
m_dwNumCluster++;
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKeyWlbs);
|
|
|
|
return GetInitResult();
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::ReInitialize
|
|
//
|
|
// Description: Re-Initialization to get the current cluster list
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: bool - true if succeeded
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
bool CWlbsControl::ReInitialize()
|
|
{
|
|
ASSERT(m_hdl != INVALID_HANDLE_VALUE);
|
|
|
|
if ( m_hdl == INVALID_HANDLE_VALUE )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
HKEY hKeyWlbs;
|
|
DWORD dwError;
|
|
|
|
dwError = RegOpenKeyEx (HKEY_LOCAL_MACHINE,
|
|
L"SYSTEM\\CurrentControlSet\\Services\\WLBS\\Parameters\\Interface",
|
|
0L, KEY_READ, & hKeyWlbs);
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
LOG_ERROR("CWlbsControl::Initialize failed at RegOpenKeyEx");
|
|
return false;
|
|
}
|
|
|
|
|
|
//
|
|
// Re enumerate the clusters
|
|
//
|
|
|
|
DWORD dwNewNumCluster = 0; // the number of new clusters
|
|
bool fClusterExists[WLBS_MAX_CLUSTERS];
|
|
CWlbsCluster* NewClusterArray[WLBS_MAX_CLUSTERS];
|
|
|
|
for (DWORD i=0;i<m_dwNumCluster;i++)
|
|
{
|
|
fClusterExists[i] = false;
|
|
}
|
|
|
|
for (int index=0;;index++)
|
|
{
|
|
WCHAR szAdapterGuid[128];
|
|
DWORD dwSize = sizeof(szAdapterGuid)/sizeof(szAdapterGuid[0]);
|
|
|
|
dwError = RegEnumKeyEx(hKeyWlbs, index,
|
|
szAdapterGuid, &dwSize,
|
|
NULL, NULL, NULL, NULL);
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
if (dwError != ERROR_NO_MORE_ITEMS)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed at RegEnumKeyEx %d", dwError);
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
GUID AdapterGuid;
|
|
HRESULT hr = CLSIDFromString(szAdapterGuid, &AdapterGuid);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LOG_ERROR1("CWlbsControl::Initialize failed at CLSIDFromString %s", szAdapterGuid);
|
|
continue;
|
|
}
|
|
|
|
IOCTL_CVY_BUF in_buf;
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
DWORD status = WlbsLocalControl (m_hdl, AdapterGuid,
|
|
IOCTL_CVY_QUERY, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check if this is a new adapter
|
|
//
|
|
for (DWORD j=0; j<m_dwNumCluster; j++)
|
|
{
|
|
ASSERT(m_pClusterArray[j]);
|
|
|
|
if (IsEqualGUID(AdapterGuid, m_pClusterArray[j]->GetAdapterGuid()))
|
|
{
|
|
ASSERT(fClusterExists[j] == false);
|
|
|
|
fClusterExists[j] = true;
|
|
|
|
//
|
|
// Since adapter could be added or removed, since last time,
|
|
// The index could be changed
|
|
//
|
|
m_pClusterArray[j]->m_dwConfigIndex = index;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// It is a new adapter
|
|
//
|
|
if (j == m_dwNumCluster)
|
|
{
|
|
CWlbsCluster* pCluster = new CWlbsCluster(index);
|
|
|
|
if (pCluster == NULL)
|
|
{
|
|
LOG_ERROR("CWlbsControl::ReInitialize failed to allocate memory");
|
|
ASSERT(pCluster);
|
|
}
|
|
else
|
|
{
|
|
pCluster->Initialize(AdapterGuid);
|
|
|
|
//
|
|
// Add
|
|
//
|
|
NewClusterArray[dwNewNumCluster] = pCluster;
|
|
dwNewNumCluster++;
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKeyWlbs);
|
|
|
|
//
|
|
// Create the new cluster array
|
|
//
|
|
for (i=0; i< m_dwNumCluster; i++)
|
|
{
|
|
if (!fClusterExists[i])
|
|
{
|
|
delete m_pClusterArray[i];
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Reload settings
|
|
//
|
|
m_pClusterArray[i]->ReInitialize();
|
|
|
|
NewClusterArray[dwNewNumCluster] = m_pClusterArray[i];
|
|
dwNewNumCluster++;
|
|
}
|
|
|
|
m_pClusterArray[i] = NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// Copy the array back
|
|
//
|
|
m_dwNumCluster = dwNewNumCluster;
|
|
CopyMemory(m_pClusterArray, NewClusterArray, m_dwNumCluster * sizeof(m_pClusterArray[0]));
|
|
|
|
ASSERT(m_pClusterArray[m_dwNumCluster] == NULL);
|
|
|
|
return true;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: MapStateFromDriverToApi
|
|
//
|
|
// Description: Map the state return from wlbs driver to the API state
|
|
//
|
|
// Arguments: DWORD dwDriverState -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD MapStateFromDriverToApi(DWORD dwDriverState)
|
|
{
|
|
struct STATE_MAP
|
|
{
|
|
DWORD dwDriverState;
|
|
DWORD dwApiState;
|
|
} StateMap[] =
|
|
{
|
|
{IOCTL_CVY_ALREADY, WLBS_ALREADY},
|
|
{IOCTL_CVY_BAD_PARAMS, WLBS_BAD_PARAMS},
|
|
{IOCTL_CVY_NOT_FOUND, WLBS_NOT_FOUND},
|
|
{IOCTL_CVY_STOPPED, WLBS_STOPPED},
|
|
{IOCTL_CVY_SUSPENDED, WLBS_SUSPENDED},
|
|
{IOCTL_CVY_CONVERGING, WLBS_CONVERGING},
|
|
{IOCTL_CVY_SLAVE, WLBS_CONVERGED},
|
|
{IOCTL_CVY_MASTER, WLBS_DEFAULT},
|
|
{IOCTL_CVY_BAD_PASSWORD, WLBS_BAD_PASSW},
|
|
{IOCTL_CVY_DRAINING, WLBS_DRAINING},
|
|
{IOCTL_CVY_DRAINING_STOPPED, WLBS_DRAIN_STOP},
|
|
{IOCTL_CVY_DISCONNECTED, WLBS_DISCONNECTED},
|
|
};
|
|
|
|
for (int i=0; i<sizeof(StateMap) /sizeof(StateMap[0]); i++)
|
|
{
|
|
if (StateMap[i].dwDriverState == dwDriverState)
|
|
{
|
|
return StateMap[i].dwApiState;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Default
|
|
//
|
|
return WLBS_OK;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::GetClusterFromIp
|
|
//
|
|
// Description: Get the cluster object from IP
|
|
//
|
|
// Arguments: DWORD dwClusterIp -
|
|
//
|
|
// Returns: CWlbsCluster* - Caller can NOT free the return object
|
|
//
|
|
// History: fengsun Created Header 3/9/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
inline
|
|
CWlbsCluster* CWlbsControl::GetClusterFromIp(DWORD dwClusterIp)
|
|
{
|
|
for (DWORD i=0; i< m_dwNumCluster; i++)
|
|
{
|
|
if(m_pClusterArray[i]->GetClusterIp() == dwClusterIp)
|
|
{
|
|
return m_pClusterArray[i];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::GetClusterFromAdapter
|
|
//
|
|
// Description: Get the cluster object from adapter guid
|
|
//
|
|
// Arguments: GUID *pAdapterGuid -- GUID of the adapter.
|
|
//
|
|
// Returns: CWlbsCluster* - Caller can NOT free the return object
|
|
//
|
|
// History: JosephJ Created 4/20/01
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
inline
|
|
CWlbsCluster* CWlbsControl::GetClusterFromAdapter(IN const GUID &AdapterGuid)
|
|
{
|
|
for (DWORD i=0; i< m_dwNumCluster; i++)
|
|
{
|
|
const GUID& Guid = m_pClusterArray[i]->GetAdapterGuid();
|
|
if (IsEqualGUID(Guid, AdapterGuid))
|
|
{
|
|
return m_pClusterArray[i];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::ValidateParam
|
|
//
|
|
// Description: Validate the specified WLBS cluster parameter. It has no side effects other to munge paramp, for example reformatting
|
|
// IP addresses into canonical form.
|
|
//
|
|
// Arguments: paramp -- params to validate
|
|
//
|
|
// Returns: TRUE if params look valid, false otherwise.
|
|
//
|
|
// History: JosephJ Created 4/25/01
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL
|
|
CWlbsControl::ValidateParam(
|
|
IN OUT PWLBS_REG_PARAMS paramp
|
|
)
|
|
{
|
|
return ::ParamValidate(paramp)!=0;
|
|
}
|
|
|
|
//
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::LocalClusterControl
|
|
//
|
|
// Description: Performs local cluster-wide control operations on the
|
|
// specified GUID.
|
|
//
|
|
// Arguments: AdapterGuid -- GUID of the adapter.
|
|
// ioctl -- cluster control ioctl.
|
|
//
|
|
// Returns: WLBS return code
|
|
//
|
|
// History: JosephJ Created 4/25/01
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::LocalClusterControl(
|
|
IN const GUID& AdapterGuid,
|
|
IN LONG ioctl
|
|
)
|
|
{
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
status = GetInitResult();
|
|
if (status == WLBS_INIT_ERROR)
|
|
{
|
|
goto end;
|
|
}
|
|
|
|
//
|
|
// We only support cluster-wide operations...
|
|
//
|
|
switch(ioctl)
|
|
{
|
|
case IOCTL_CVY_CLUSTER_ON:
|
|
break;
|
|
case IOCTL_CVY_CLUSTER_OFF:
|
|
break;
|
|
case IOCTL_CVY_CLUSTER_SUSPEND:
|
|
break;
|
|
case IOCTL_CVY_CLUSTER_RESUME:
|
|
break;
|
|
case IOCTL_CVY_CLUSTER_DRAIN:
|
|
break;
|
|
default:
|
|
status = WLBS_BAD_PARAMS;
|
|
goto end;
|
|
}
|
|
|
|
ZeroMemory(&in_buf, sizeof(in_buf));
|
|
|
|
status = WlbsLocalControl (m_hdl, AdapterGuid,
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status != WLBS_IO_ERROR)
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf.ret_code);
|
|
}
|
|
|
|
end:
|
|
return status;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControlWrapper::GetClusterFromIpOrIndex
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: DWORD dwClusterIpOrIndex -
|
|
//
|
|
// Returns: CWlbsCluster* -
|
|
//
|
|
// History: fengsun Created Header 7/3/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CWlbsCluster* CWlbsControl::GetClusterFromIpOrIndex(DWORD dwClusterIpOrIndex)
|
|
{
|
|
for (DWORD i=0; i<m_dwNumCluster; i++)
|
|
{
|
|
if (m_pClusterArray[i]->GetClusterIpOrIndex(this) == dwClusterIpOrIndex)
|
|
{
|
|
return m_pClusterArray[i];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Function: CWlbsControlWrapper::IsClusterMember
|
|
* Description: This function searches the list of known NLB clusters on this
|
|
* host to determine whether or not this host is a member of a
|
|
* given cluster.
|
|
* Author: shouse, Created 4.16.01
|
|
*/
|
|
BOOLEAN CWlbsControl::IsClusterMember (DWORD dwClusterIp)
|
|
{
|
|
for (DWORD i = 0; i < m_dwNumCluster; i++) {
|
|
if (m_pClusterArray[i]->GetClusterIp() == dwClusterIp)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::EnumClusterObjects
|
|
//
|
|
// Description: Get a list of cluster objects
|
|
//
|
|
// Arguments: OUT CWlbsCluster** &pdwClusters - The memory is internal to CWlbsControl
|
|
/// Caller can NOT free the pdwClusters memory
|
|
// OUT DWORD* pdwNum -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 3/3/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::EnumClusterObjects(OUT CWlbsCluster** &ppClusters, OUT DWORD* pdwNum)
|
|
{
|
|
ASSERT(pdwNum);
|
|
|
|
ppClusters = m_pClusterArray;
|
|
|
|
*pdwNum = m_dwNumCluster;
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::EnumClusters
|
|
//
|
|
// Description: Get a list of cluster IP or index
|
|
//
|
|
// Arguments: OUT DWORD* pdwAddresses -
|
|
// IN OUT DWORD* pdwNum - IN size of the buffer, OUT element returned
|
|
//
|
|
// Returns: DWORD - WLBS error code.
|
|
//
|
|
// History: fengsun Created Header 3/3/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::EnumClusters(OUT DWORD* pdwAddresses, IN OUT DWORD* pdwNum)
|
|
{
|
|
if (pdwNum == NULL)
|
|
{
|
|
return WLBS_BAD_PARAMS;
|
|
}
|
|
|
|
if (pdwAddresses == NULL || *pdwNum < m_dwNumCluster)
|
|
{
|
|
*pdwNum = m_dwNumCluster;
|
|
return ERROR_MORE_DATA;
|
|
}
|
|
|
|
*pdwNum = m_dwNumCluster;
|
|
|
|
for (DWORD i=0; i< m_dwNumCluster; i++)
|
|
{
|
|
pdwAddresses[i] = m_pClusterArray[i]->GetClusterIpOrIndex(this);
|
|
}
|
|
|
|
return WLBS_OK;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: WlbsLocalControl
|
|
//
|
|
// Description: Send DeviceIoControl to local driver
|
|
//
|
|
// Arguments: HANDLE hDevice -
|
|
// const GUID& AdapterGuid - the guid of the adapter
|
|
// LONG ioctl -
|
|
// PIOCTL_CVY_BUF in_bufp -
|
|
// PIOCTL_CVY_BUF out_bufp -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 3/9/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD WlbsLocalControl(HANDLE hDevice,
|
|
const GUID& AdapterGuid,
|
|
LONG ioctl,
|
|
PIOCTL_CVY_BUF in_bufp,
|
|
PIOCTL_CVY_BUF out_bufp,
|
|
DWORD vip)
|
|
{
|
|
BOOLEAN res;
|
|
DWORD act;
|
|
|
|
//
|
|
// Add adapter GUID
|
|
//
|
|
IOCTL_LOCAL_HDR inBuf;
|
|
IOCTL_LOCAL_HDR outBuf;
|
|
|
|
WCHAR szGuid[128];
|
|
StringFromGUID2(AdapterGuid, szGuid, sizeof(szGuid)/ sizeof(szGuid[0]));
|
|
|
|
lstrcpy(inBuf.device_name, L"\\device\\");
|
|
lstrcat(inBuf.device_name, szGuid);
|
|
inBuf.ctrl = *in_bufp;
|
|
|
|
switch (ioctl) {
|
|
case IOCTL_CVY_CLUSTER_ON:
|
|
case IOCTL_CVY_CLUSTER_OFF:
|
|
break;
|
|
case IOCTL_CVY_PORT_ON:
|
|
case IOCTL_CVY_PORT_OFF:
|
|
case IOCTL_CVY_PORT_SET:
|
|
case IOCTL_CVY_PORT_DRAIN:
|
|
{
|
|
/* Set the port options. */
|
|
inBuf.options.port.flags = 0;
|
|
|
|
inBuf.options.port.virtual_ip_addr = vip;
|
|
|
|
break;
|
|
}
|
|
case IOCTL_CVY_QUERY:
|
|
break;
|
|
case IOCTL_CVY_CLUSTER_DRAIN:
|
|
case IOCTL_CVY_CLUSTER_SUSPEND:
|
|
case IOCTL_CVY_CLUSTER_RESUME:
|
|
break;
|
|
case IOCTL_CVY_QUERY_STATE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
res = (BOOLEAN) DeviceIoControl (hDevice, ioctl, &inBuf, sizeof (inBuf),
|
|
&outBuf, sizeof (outBuf), & act, NULL);
|
|
|
|
*out_bufp = outBuf.ctrl;
|
|
|
|
if (! res || act != sizeof (outBuf))
|
|
return WLBS_IO_ERROR;
|
|
|
|
return WLBS_OK;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: NotifyDriverConfigChanges
|
|
//
|
|
// Description: Notify wlbs driver to pick up configuration changes from
|
|
// registry
|
|
//
|
|
// Arguments: HANDLE hDeviceWlbs - The WLBS driver device handle
|
|
// const GUID& - AdapterGuid Adapter guid
|
|
//
|
|
//
|
|
// Returns: DWORD - Win32 Error code
|
|
//
|
|
// History: fengsun Created Header 2/3/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD WINAPI NotifyDriverConfigChanges(HANDLE hDeviceWlbs, const GUID& AdapterGuid)
|
|
{
|
|
LONG status;
|
|
|
|
IOCTL_CVY_BUF in_buf;
|
|
IOCTL_CVY_BUF out_buf;
|
|
status = WlbsLocalControl (hDeviceWlbs, AdapterGuid, IOCTL_CVY_RELOAD,
|
|
& in_buf, & out_buf, 0);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsRemoteControl
|
|
//
|
|
// Description: Send a remote control packet
|
|
//
|
|
// Arguments: ONG ioctl -
|
|
// PIOCTL_CVY_BUF pin_bufp -
|
|
// PIOCTL_CVY_BUF pout_bufp -
|
|
// PWLBS_RESPONSE pcvy_resp -
|
|
// PDWORD nump -
|
|
// DWORD trg_addr -
|
|
// DWORD hst_addr
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsRemoteControl
|
|
(
|
|
LONG ioctl,
|
|
PIOCTL_CVY_BUF pin_bufp,
|
|
PIOCTL_CVY_BUF pout_bufp,
|
|
PWLBS_RESPONSE pcvy_resp,
|
|
PDWORD nump,
|
|
DWORD trg_addr,
|
|
DWORD hst_addr,
|
|
DWORD vip
|
|
)
|
|
{
|
|
INT ret;
|
|
BOOLEAN responded [WLBS_MAX_HOSTS], heard;
|
|
BOOL broadcast;
|
|
DWORD mode, num_sends, num_recvs;
|
|
SOCKET sock = INVALID_SOCKET;
|
|
SOCKADDR_IN caddr, saddr;
|
|
DWORD i, hosts;
|
|
IOCTL_REMOTE_HDR rct_req;
|
|
IOCTL_REMOTE_HDR rct_rep;
|
|
PIOCTL_CVY_BUF in_bufp = & rct_req . ctrl;
|
|
DWORD timeout;
|
|
WORD port;
|
|
DWORD dst_addr;
|
|
DWORD passw;
|
|
|
|
* in_bufp = * pin_bufp;
|
|
timeout = m_def_timeout;
|
|
port = m_def_port;
|
|
dst_addr = m_def_dst_addr;
|
|
passw = m_def_passw;
|
|
|
|
// LOCK(m_lock);
|
|
|
|
//
|
|
// Find parameters for the cluster
|
|
//
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
if (m_cluster_params [i] . cluster == trg_addr)
|
|
break;
|
|
}
|
|
|
|
if (i < WLBS_MAX_CLUSTERS)
|
|
{
|
|
timeout = m_cluster_params [i] . timeout;
|
|
port = m_cluster_params [i] . port;
|
|
dst_addr = m_cluster_params [i] . dest;
|
|
passw = m_cluster_params [i] . passw;
|
|
}
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIp(trg_addr);
|
|
/*
|
|
if (pCluster)
|
|
{
|
|
//
|
|
// Always uses password in registry for local cluster
|
|
//
|
|
passw = pCluster->GetPassword();
|
|
}
|
|
*/
|
|
// UNLOCK(m_lock);
|
|
|
|
if (dst_addr == 0)
|
|
dst_addr = trg_addr;
|
|
|
|
rct_req . code = IOCTL_REMOTE_CODE;
|
|
rct_req . version = CVY_VERSION_FULL;
|
|
rct_req . id = GetTickCount ();
|
|
|
|
rct_req . cluster = trg_addr;
|
|
rct_req . host = hst_addr;
|
|
rct_req . addr = m_dwSrcAddress;
|
|
rct_req . password = passw;
|
|
rct_req . ioctrl = ioctl;
|
|
|
|
switch (ioctl) {
|
|
case IOCTL_CVY_CLUSTER_ON:
|
|
case IOCTL_CVY_CLUSTER_OFF:
|
|
break;
|
|
case IOCTL_CVY_PORT_ON:
|
|
case IOCTL_CVY_PORT_OFF:
|
|
case IOCTL_CVY_PORT_SET:
|
|
case IOCTL_CVY_PORT_DRAIN:
|
|
{
|
|
/* Set the port options. */
|
|
rct_req.options.port.flags = 0;
|
|
|
|
rct_req.options.port.virtual_ip_addr = vip;
|
|
|
|
break;
|
|
}
|
|
case IOCTL_CVY_QUERY:
|
|
{
|
|
BOOLEAN bIsMember = IsClusterMember(trg_addr);
|
|
|
|
/* Reset the flags. */
|
|
rct_req.options.query.flags = 0;
|
|
|
|
/* Reset the hostname. */
|
|
rct_req.options.query.hostname[0] = 0;
|
|
|
|
/* If I am myself a member of the target cluster, then set the query cluster flags appropriately. */
|
|
if (bIsMember)
|
|
rct_req.options.query.flags |= IOCTL_OPTIONS_QUERY_CLUSTER_MEMBER;
|
|
|
|
/* Request the hostname from each host. */
|
|
rct_req.options.query.flags |= IOCTL_OPTIONS_QUERY_HOSTNAME;;
|
|
|
|
break;
|
|
}
|
|
case IOCTL_CVY_CLUSTER_DRAIN:
|
|
case IOCTL_CVY_CLUSTER_SUSPEND:
|
|
case IOCTL_CVY_CLUSTER_RESUME:
|
|
break;
|
|
case IOCTL_CVY_QUERY_STATE:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* now create socket */
|
|
|
|
sock = socket (AF_INET, SOCK_DGRAM, 0);
|
|
|
|
if (sock == INVALID_SOCKET)
|
|
return WSAGetLastError();
|
|
|
|
/* set socket to nonblocking mode */
|
|
|
|
mode = 1;
|
|
ret = ioctlsocket (sock, FIONBIO, & mode);
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
|
|
/* bind client's address to socket */
|
|
|
|
caddr . sin_family = AF_INET;
|
|
caddr . sin_port = htons (0);
|
|
|
|
BOOLEAN fBound = FALSE;
|
|
|
|
if (pCluster)
|
|
{
|
|
//
|
|
// For local cluster, always bind to the cluster IP.
|
|
// Can not bind to the dedicated IP, which could be for a different NIC.
|
|
//
|
|
caddr . sin_addr . s_addr = trg_addr;
|
|
if (bind (sock, (LPSOCKADDR) & caddr, sizeof (caddr)) != SOCKET_ERROR)
|
|
{
|
|
fBound = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fBound)
|
|
{
|
|
//
|
|
// For remote cluster, or fail to bind VIP/DIP, bind to the any IP
|
|
//
|
|
caddr . sin_addr . s_addr = htonl (INADDR_ANY);
|
|
if (bind (sock, (LPSOCKADDR) & caddr, sizeof (caddr)) != SOCKET_ERROR)
|
|
{
|
|
fBound = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fBound)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::WlbsRemoteControl failed at bind %d", WSAGetLastError());
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
|
|
WORD wMyPort;
|
|
wMyPort = QueryPortFromSocket(sock);
|
|
|
|
//
|
|
// The client is bound to the remote control server port
|
|
// Let's get another port
|
|
//
|
|
if (wMyPort == htons (port))
|
|
{
|
|
closesocket (sock);
|
|
|
|
sock = socket (AF_INET, SOCK_DGRAM, 0);
|
|
|
|
if (sock == INVALID_SOCKET)
|
|
return WSAGetLastError();
|
|
|
|
/* set socket to nonblocking mode */
|
|
|
|
mode = 1;
|
|
ret = ioctlsocket (sock, FIONBIO, & mode);
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
|
|
ret = bind (sock, (LPSOCKADDR) & caddr, sizeof (caddr));
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
|
|
/* setup server's address */
|
|
|
|
saddr . sin_family = AF_INET;
|
|
saddr . sin_port = htons (port);
|
|
|
|
if ( pCluster ) // local cluster
|
|
{
|
|
/* enable sending broadcast on the socket */
|
|
broadcast = TRUE;
|
|
|
|
ret = setsockopt (sock, SOL_SOCKET, SO_BROADCAST, (char *) & broadcast,
|
|
sizeof (broadcast));
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
|
|
saddr . sin_addr . s_addr = INADDR_BROADCAST;
|
|
}
|
|
else
|
|
saddr . sin_addr . s_addr = dst_addr;
|
|
|
|
for (i = 0; i < WLBS_MAX_HOSTS; i ++)
|
|
responded [i] = FALSE;
|
|
|
|
heard = FALSE;
|
|
hosts = 0;
|
|
|
|
for (num_sends = 0; num_sends < IOCTL_REMOTE_SEND_RETRIES; num_sends ++)
|
|
{
|
|
/* send remote control request message */
|
|
|
|
ret = sendto (sock, (PCHAR) & rct_req, sizeof (rct_req), 0,
|
|
(LPSOCKADDR) & saddr, sizeof (saddr));
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
LOG_ERROR1("CWlbsControl::WlbsRemoteControl failed at sendto %d", WSAGetLastError());
|
|
|
|
//
|
|
// Sendto could fail if the adapter is too busy. Allow retry
|
|
//
|
|
Sleep (timeout);
|
|
continue;
|
|
|
|
// closesocket (sock);
|
|
// return WSAGetLastError();
|
|
}
|
|
|
|
if (ret != sizeof (rct_req))
|
|
continue;
|
|
|
|
for (num_recvs = 0; num_recvs < IOCTL_REMOTE_RECV_RETRIES; num_recvs ++)
|
|
{
|
|
/* recv remote control reply message */
|
|
|
|
ret = recv (sock, (PCHAR) & rct_rep, sizeof (rct_rep), 0);
|
|
|
|
if (ret == SOCKET_ERROR)
|
|
{
|
|
if (WSAGetLastError() == WSAEWOULDBLOCK)
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
else if (WSAGetLastError() == WSAECONNRESET)
|
|
{
|
|
//
|
|
// Remote control is disabled
|
|
//
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
closesocket (sock);
|
|
return WSAGetLastError();
|
|
}
|
|
}
|
|
|
|
if (ret != sizeof (rct_rep))
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
|
|
if (rct_rep . cluster != trg_addr)
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
|
|
if (rct_rep . code != IOCTL_REMOTE_CODE)
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
|
|
if (rct_rep . id != rct_req . id)
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
|
|
if (rct_rep . host > WLBS_MAX_HOSTS || rct_rep . host == 0 )
|
|
{
|
|
Sleep (timeout);
|
|
continue;
|
|
}
|
|
|
|
if (! responded [rct_rep . host - 1])
|
|
{
|
|
if (hosts < WLBS_MAX_HOSTS)
|
|
{
|
|
pout_bufp [hosts] = rct_rep . ctrl;
|
|
|
|
if (hosts < * nump && pcvy_resp != NULL)
|
|
{
|
|
pcvy_resp [hosts] . id = rct_rep . host;
|
|
pcvy_resp [hosts] . address = rct_rep . addr;
|
|
|
|
if (rct_req . ioctrl == IOCTL_CVY_QUERY) {
|
|
pcvy_resp [hosts] . status =
|
|
MapStateFromDriverToApi (rct_rep . ctrl . data . query . state);
|
|
lstrcpy(pcvy_resp[hosts].hostname, rct_rep.options.query.hostname);
|
|
} else {
|
|
pcvy_resp [hosts] . status =
|
|
MapStateFromDriverToApi (rct_rep . ctrl . ret_code);
|
|
}
|
|
}
|
|
hosts ++;
|
|
}
|
|
}
|
|
|
|
responded [rct_rep . host - 1] = TRUE;
|
|
heard = TRUE;
|
|
|
|
if (hst_addr != WLBS_ALL_HOSTS)
|
|
{
|
|
* nump = hosts;
|
|
closesocket (sock);
|
|
return WLBS_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
* nump = hosts;
|
|
closesocket (sock);
|
|
|
|
if (! heard)
|
|
return WLBS_TIMEOUT;
|
|
|
|
return WLBS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsQuery
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: CWlbsCluster* pCluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// PDWORD host_map -
|
|
// PVOID // reserved
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsQuery
|
|
(
|
|
CWlbsCluster* pCluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
PDWORD host_map,
|
|
PVOID // reserved
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_QUERY;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
/* The following condition is to take care of the case when num_hosts is null
|
|
* and host_map contains some junk value. This could crash this function. */
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (host_map != NULL)
|
|
* host_map = out_buf . data . query . host_map;
|
|
|
|
if (response != NULL)
|
|
{
|
|
response [0] . id = out_buf . data . query . host_id;
|
|
response [0] . address = 0;
|
|
response [0] . status = MapStateFromDriverToApi (out_buf . data . query . state);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 1;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . data . query . state);
|
|
}
|
|
else
|
|
{
|
|
status = RemoteQuery(pCluster->GetClusterIp(),
|
|
host, response, num_hosts, host_map);
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsQuery
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// PDWORD host_map -
|
|
// PVOID // reserved
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsQuery
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
PDWORD host_map,
|
|
PVOID // reserved
|
|
)
|
|
{
|
|
DWORD ret;
|
|
TRACE_INFO("> WlbsQuery: cluster=0x%lx, host=0x%lx", cluster, host);
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
{
|
|
ret = GetInitResult();
|
|
goto end;
|
|
}
|
|
|
|
if (cluster == WLBS_LOCAL_CLUSTER && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
{
|
|
ret = GetInitResult();
|
|
goto end;
|
|
}
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
|
|
if (pCluster == NULL)
|
|
{
|
|
ret = RemoteQuery(cluster, host, response, num_hosts, host_map);
|
|
goto end;
|
|
}
|
|
else
|
|
{
|
|
ret = WlbsQuery(pCluster, host, response, num_hosts, host_map, NULL);
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
|
|
TRACE_INFO("< WlbsQuery: return %d", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::RemoteQuery
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: DWORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// PDWORD host_map -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::RemoteQuery
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
PDWORD host_map
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_QUERY;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD hmap = 0;
|
|
DWORD active;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
{
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
return status;
|
|
}
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_STOPPED, active = 0, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . data . query . state))
|
|
{
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status == WLBS_STOPPED)
|
|
status = WLBS_SUSPENDED;
|
|
|
|
break;
|
|
|
|
case WLBS_CONVERGING:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_CONVERGING;
|
|
|
|
break;
|
|
|
|
case WLBS_DRAINING:
|
|
|
|
if (status == WLBS_STOPPED)
|
|
status = WLBS_DRAINING;
|
|
|
|
break;
|
|
|
|
case WLBS_CONVERGED:
|
|
|
|
if (status != WLBS_CONVERGING && status != WLBS_BAD_PASSW)
|
|
status = WLBS_CONVERGED;
|
|
|
|
hmap = out_buf [i] . data . query . host_map;
|
|
active ++;
|
|
break;
|
|
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_DEFAULT:
|
|
|
|
if (status != WLBS_CONVERGING && status != WLBS_BAD_PASSW)
|
|
status = WLBS_CONVERGED;
|
|
|
|
hmap = out_buf [i] . data . query . host_map;
|
|
active ++;
|
|
break;
|
|
|
|
case WLBS_STOPPED:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
if (status == WLBS_CONVERGED)
|
|
status = active;
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . data . query . state);
|
|
hmap = out_buf [0] . data . query . host_map;
|
|
}
|
|
|
|
if (host_map != NULL)
|
|
* host_map = hmap;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsSuspend
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsSuspend
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_CLUSTER_SUSPEND;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
CWlbsCluster* pCluster= GetClusterFromIpOrIndex(cluster);
|
|
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_STOPPED:
|
|
case WLBS_DRAIN_STOP:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsResume
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsResume
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_CLUSTER_RESUME;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsStart
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsStart
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_CLUSTER_ON;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PARAMS:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_BAD_PARAMS;
|
|
|
|
break;
|
|
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_BAD_PARAMS)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_DRAIN_STOP:
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsStop
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsStop
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_CLUSTER_OFF;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_DRAIN_STOP:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsDrainStop
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsDrainStop
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_CLUSTER_DRAIN;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl,pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_STOPPED, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_SUSPENDED)
|
|
status = WLBS_OK;
|
|
|
|
case WLBS_STOPPED:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsEnable
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// DWORD port
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsEnable
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
DWORD vip,
|
|
DWORD port
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_PORT_ON;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
in_buf . data . port . num = port;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster&& (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, vip);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, vip);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_NOT_FOUND:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_NOT_FOUND;
|
|
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_NOT_FOUND)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_STOPPED:
|
|
case WLBS_DRAINING:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsDisable
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// DWORD port
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsDisable
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
DWORD vip,
|
|
DWORD port
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_PORT_OFF;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
in_buf . data . port . num = port;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, vip);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, vip);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_NOT_FOUND:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_NOT_FOUND;
|
|
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_NOT_FOUND)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_STOPPED:
|
|
case WLBS_DRAINING:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsDrain
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// DWORD port
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsDrain
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
DWORD vip,
|
|
DWORD port
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_PORT_DRAIN;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts == NULL)
|
|
response = NULL;
|
|
else if (*num_hosts == 0)
|
|
response = NULL;
|
|
|
|
in_buf . data . port . num = port;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, vip);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, vip);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_NOT_FOUND:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_NOT_FOUND;
|
|
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_NOT_FOUND)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_STOPPED:
|
|
case WLBS_DRAINING:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsAdjust
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// DWORD host -
|
|
// PWLBS_RESPONSE response -
|
|
// PDWORD num_hosts -
|
|
// DWORD port -
|
|
// DWORD value
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CWlbsControl::WlbsAdjust
|
|
(
|
|
DWORD cluster,
|
|
DWORD host,
|
|
PWLBS_RESPONSE response,
|
|
PDWORD num_hosts,
|
|
DWORD port,
|
|
DWORD value
|
|
)
|
|
{
|
|
LONG ioctl = IOCTL_CVY_PORT_SET;
|
|
DWORD status;
|
|
IOCTL_CVY_BUF in_buf;
|
|
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR)
|
|
return GetInitResult();
|
|
|
|
in_buf . data . port . num = port;
|
|
in_buf . data . port . load = value;
|
|
|
|
CWlbsCluster* pCluster = GetClusterFromIpOrIndex(cluster);
|
|
if (pCluster && (GetInitResult() == WLBS_REMOTE_ONLY))
|
|
return GetInitResult();
|
|
|
|
if (pCluster && IsLocalHost(pCluster, host))
|
|
{
|
|
IOCTL_CVY_BUF out_buf;
|
|
|
|
|
|
status = WlbsLocalControl (m_hdl, pCluster->GetAdapterGuid(),
|
|
ioctl, & in_buf, & out_buf, 0);
|
|
|
|
if (status == WLBS_IO_ERROR)
|
|
return status;
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = 0;
|
|
|
|
status = MapStateFromDriverToApi (out_buf . ret_code);
|
|
}
|
|
else
|
|
{
|
|
IOCTL_CVY_BUF out_buf [WLBS_MAX_HOSTS];
|
|
DWORD hosts;
|
|
DWORD i;
|
|
|
|
|
|
if (GetInitResult() == WLBS_LOCAL_ONLY)
|
|
return GetInitResult();
|
|
|
|
if (num_hosts != NULL)
|
|
hosts = * num_hosts;
|
|
else
|
|
hosts = 0;
|
|
|
|
status = WlbsRemoteControl (ioctl, & in_buf, out_buf, response, & hosts,
|
|
cluster, host, 0);
|
|
|
|
if (status >= WSABASEERR || status == WLBS_TIMEOUT)
|
|
return status;
|
|
|
|
if (host == WLBS_ALL_HOSTS)
|
|
{
|
|
for (status = WLBS_OK, i = 0; i < hosts; i ++)
|
|
{
|
|
switch (MapStateFromDriverToApi (out_buf [i] . ret_code))
|
|
{
|
|
case WLBS_BAD_PASSW:
|
|
|
|
status = WLBS_BAD_PASSW;
|
|
break;
|
|
|
|
case WLBS_NOT_FOUND:
|
|
|
|
if (status != WLBS_BAD_PASSW)
|
|
status = WLBS_NOT_FOUND;
|
|
|
|
break;
|
|
|
|
case WLBS_SUSPENDED:
|
|
|
|
if (status != WLBS_BAD_PASSW && status != WLBS_NOT_FOUND)
|
|
status = WLBS_SUSPENDED;
|
|
break;
|
|
|
|
case WLBS_OK:
|
|
case WLBS_ALREADY:
|
|
case WLBS_STOPPED:
|
|
case WLBS_DRAINING:
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = MapStateFromDriverToApi (out_buf [0] . ret_code);
|
|
}
|
|
|
|
if (num_hosts != NULL)
|
|
* num_hosts = hosts;
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsPortSet
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: DWORD cluster -
|
|
// WORD port -
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
VOID CWlbsControl::WlbsPortSet(DWORD cluster, WORD port)
|
|
{
|
|
DWORD i;
|
|
DWORD j;
|
|
WORD rct_port;
|
|
|
|
|
|
// LOCK(global_info.lock);
|
|
|
|
if (port == 0)
|
|
rct_port = CVY_DEF_RCT_PORT;
|
|
else
|
|
rct_port = port;
|
|
|
|
if (cluster == WLBS_ALL_CLUSTERS)
|
|
{
|
|
/* when all clusters are targeted - change the default and go through
|
|
the entire parameter table setting new values */
|
|
|
|
m_def_port = rct_port;
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
m_cluster_params [i] . port = rct_port;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0, j = WLBS_MAX_CLUSTERS; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
/* mark an empty slot in case we will have to enter a new value */
|
|
|
|
if (j == WLBS_MAX_CLUSTERS && m_cluster_params [i] . cluster == 0)
|
|
j = i;
|
|
|
|
if (m_cluster_params [i] . cluster == cluster)
|
|
{
|
|
m_cluster_params [i] . port = rct_port;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we did not locate specified cluster in the table and there is an
|
|
empty slot - enter new cluster info in the table */
|
|
|
|
if (i >= WLBS_MAX_CLUSTERS && j != WLBS_MAX_CLUSTERS)
|
|
{
|
|
m_cluster_params [j] . cluster = cluster;
|
|
m_cluster_params [j] . port = rct_port;
|
|
}
|
|
}
|
|
|
|
// UNLOCK(global_info.lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsPasswordSet
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WORD cluster -
|
|
// PTCHAR password
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
VOID CWlbsControl::WlbsPasswordSet
|
|
(
|
|
DWORD cluster,
|
|
const WCHAR* password
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD j;
|
|
DWORD passw;
|
|
|
|
|
|
// LOCK(global_info.lock);
|
|
|
|
if (password != NULL)
|
|
{
|
|
#ifndef UNICODE
|
|
passw = License_string_encode (password);
|
|
#else
|
|
passw = License_wstring_encode((WCHAR*)password);
|
|
#endif
|
|
}
|
|
else
|
|
passw = CVY_DEF_RCT_PASSWORD;
|
|
|
|
if (cluster == WLBS_ALL_CLUSTERS)
|
|
{
|
|
/* when all clusters are targeted - change the default and go through
|
|
the entire parameter table setting new values */
|
|
|
|
m_def_passw = passw;
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
m_cluster_params [i] . passw = passw;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0, j = WLBS_MAX_CLUSTERS; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
/* mark an empty slot in case we will have to enter a new value */
|
|
|
|
if (j == WLBS_MAX_CLUSTERS && m_cluster_params [i] . cluster == 0)
|
|
j = i;
|
|
|
|
if (m_cluster_params [i] . cluster == cluster)
|
|
{
|
|
m_cluster_params [i] . passw = passw;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we did not locate specified cluster in the table and there is an
|
|
empty slot - enter new cluster info in the table */
|
|
|
|
if (i >= WLBS_MAX_CLUSTERS && j != WLBS_MAX_CLUSTERS)
|
|
{
|
|
m_cluster_params [j] . cluster = cluster;
|
|
m_cluster_params [j] . passw = passw;
|
|
}
|
|
}
|
|
|
|
// UNLOCK(global_info.lock);
|
|
|
|
} /* end WlbsPasswordSet */
|
|
|
|
|
|
VOID CWlbsControl::WlbsCodeSet
|
|
(
|
|
DWORD cluster,
|
|
DWORD passw
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD j;
|
|
|
|
|
|
// LOCK(global_info.lock);
|
|
|
|
if (cluster == WLBS_ALL_CLUSTERS)
|
|
{
|
|
/* when all clusters are targeted - change the default and go through
|
|
the entire parameter table setting new values */
|
|
|
|
m_def_passw = passw;
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
m_cluster_params [i] . passw = passw;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0, j = WLBS_MAX_CLUSTERS; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
/* mark an empty slot in case we will have to enter a new value */
|
|
|
|
if (j == WLBS_MAX_CLUSTERS && m_cluster_params [i] . cluster == 0)
|
|
j = i;
|
|
|
|
if (m_cluster_params [i] . cluster == cluster)
|
|
{
|
|
m_cluster_params [i] . passw = passw;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we did not locate specified cluster in the table and there is an
|
|
empty slot - enter new cluster info in the table */
|
|
|
|
if (i >= WLBS_MAX_CLUSTERS && j != WLBS_MAX_CLUSTERS)
|
|
{
|
|
m_cluster_params [j] . cluster = cluster;
|
|
m_cluster_params [j] . passw = passw;
|
|
}
|
|
}
|
|
|
|
// UNLOCK(global_info.lock);
|
|
|
|
} /* end WlbsCodeSet */
|
|
|
|
|
|
VOID CWlbsControl::WlbsDestinationSet
|
|
(
|
|
DWORD cluster,
|
|
DWORD dest
|
|
)
|
|
{
|
|
DWORD i;
|
|
DWORD j;
|
|
|
|
|
|
// LOCK(global_info.lock);
|
|
|
|
if (cluster == WLBS_ALL_CLUSTERS)
|
|
{
|
|
/* when all clusters are targeted - change the default and go through
|
|
the entire parameter table setting new values */
|
|
|
|
m_def_dst_addr = dest;
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
m_cluster_params [i] . dest = dest;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0, j = WLBS_MAX_CLUSTERS; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
/* mark an empty slot in case we will have to enter a new value */
|
|
|
|
if (j == WLBS_MAX_CLUSTERS && m_cluster_params [i] . cluster == 0)
|
|
j = i;
|
|
|
|
if (m_cluster_params [i] . cluster == cluster)
|
|
{
|
|
m_cluster_params [i] . dest = dest;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we did not locate specified cluster in the table and there is an
|
|
empty slot - enter new cluster info in the table */
|
|
|
|
if (i >= WLBS_MAX_CLUSTERS && j != WLBS_MAX_CLUSTERS)
|
|
{
|
|
m_cluster_params [j] . cluster = cluster;
|
|
m_cluster_params [j] . dest = dest;
|
|
}
|
|
}
|
|
|
|
// UNLOCK(global_info.lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CWlbsControl::WlbsTimeoutSet
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: DWORD cluster -
|
|
// DWORD milliseconds -
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 1/25/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
VOID CWlbsControl::WlbsTimeoutSet(DWORD cluster, DWORD milliseconds)
|
|
{
|
|
DWORD i;
|
|
DWORD j;
|
|
DWORD timeout;
|
|
|
|
|
|
// LOCK(global_info.lock);
|
|
|
|
if (milliseconds == 0)
|
|
timeout = IOCTL_REMOTE_RECV_DELAY;
|
|
else
|
|
timeout = milliseconds / (IOCTL_REMOTE_SEND_RETRIES *
|
|
IOCTL_REMOTE_RECV_RETRIES);
|
|
|
|
if (timeout < 10)
|
|
timeout = 10;
|
|
|
|
if (cluster == WLBS_ALL_CLUSTERS)
|
|
{
|
|
/* when all clusters are targeted - change the default and go through
|
|
the entire parameter table setting new values */
|
|
|
|
m_def_timeout = timeout;
|
|
|
|
for (i = 0; i < WLBS_MAX_CLUSTERS; i ++)
|
|
m_cluster_params [i] . timeout = timeout;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0, j = WLBS_MAX_CLUSTERS; i < WLBS_MAX_CLUSTERS; i ++)
|
|
{
|
|
/* mark an empty slot in case we will have to enter a new value */
|
|
|
|
if (j == WLBS_MAX_CLUSTERS && m_cluster_params [i] . cluster == 0)
|
|
j = i;
|
|
|
|
if (m_cluster_params [i] . cluster == cluster)
|
|
{
|
|
m_cluster_params [i] . timeout = timeout;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* if we did not locate specified cluster in the table and there is an
|
|
empty slot - enter new cluster info in the table */
|
|
|
|
if (i >= WLBS_MAX_CLUSTERS && j < WLBS_MAX_CLUSTERS)
|
|
{
|
|
m_cluster_params [j] . cluster = cluster;
|
|
m_cluster_params [j] . timeout = timeout;
|
|
}
|
|
}
|
|
|
|
// UNLOCK(global_info.lock);
|
|
|
|
} /* end WlbsTimeoutSet */
|
|
|
|
#if defined (SBH)
|
|
DWORD CWlbsControl::WlbsQueryStateInfo (DWORD cluster, DWORD host, PIOCTL_QUERY_STATE bufp) {
|
|
IOCTL_LOCAL_HDR Header;
|
|
CWlbsCluster * pCluster = NULL;
|
|
LONG Ioctl = IOCTL_CVY_QUERY_STATE;
|
|
ULONG BufferSize = 0;
|
|
WCHAR Guid[128];
|
|
ULONG Length;
|
|
BOOLEAN Ret;
|
|
|
|
if (GetInitResult() == WLBS_INIT_ERROR) return GetInitResult();
|
|
|
|
pCluster = GetClusterFromIpOrIndex(cluster);
|
|
|
|
if (!pCluster) return WLBS_IO_ERROR;
|
|
|
|
StringFromGUID2(pCluster->GetAdapterGuid(), Guid, sizeof(Guid)/ sizeof(Guid[0]));
|
|
|
|
ZeroMemory((VOID *)&Header, sizeof(IOCTL_LOCAL_HDR));
|
|
|
|
lstrcpy(Header.device_name, L"\\device\\");
|
|
lstrcat(Header.device_name, Guid);
|
|
|
|
Header.options.state.flags = 0;
|
|
Header.options.state.query = *bufp;
|
|
|
|
switch (bufp->Operation) {
|
|
case NLB_QUERY_REG_PARAMS:
|
|
case NLB_QUERY_PORT_RULE_STATE:
|
|
case NLB_QUERY_BDA_TEAM_STATE:
|
|
case NLB_QUERY_PACKET_STATISTICS:
|
|
return WLBS_IO_ERROR;
|
|
case NLB_QUERY_PACKET_FILTER:
|
|
Ret = (BOOLEAN)DeviceIoControl(m_hdl, Ioctl, &Header, sizeof(IOCTL_LOCAL_HDR), &Header, sizeof(IOCTL_LOCAL_HDR), &Length, NULL);
|
|
|
|
if (!Ret || (Length != sizeof(IOCTL_LOCAL_HDR))) return WLBS_IO_ERROR;
|
|
|
|
break;
|
|
default:
|
|
return WLBS_IO_ERROR;
|
|
}
|
|
|
|
*bufp = Header.options.state.query;
|
|
|
|
return WLBS_OK;
|
|
}
|
|
#endif
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: DllMain
|
|
//
|
|
// Description: Dll entry point
|
|
//
|
|
// Arguments: HINSTANCE handle -
|
|
// DWORD reason -
|
|
// LPVOID situation -
|
|
//
|
|
// Returns: BOOL WINAPI -
|
|
//
|
|
// History: fengsun Created Header 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL WINAPI DllMain(HINSTANCE handle, DWORD reason, LPVOID situation)
|
|
{
|
|
switch (reason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
_tsetlocale (LC_ALL, _TEXT(".OCP"));
|
|
DisableThreadLibraryCalls(handle);
|
|
g_hInstCtrl = handle;
|
|
|
|
//
|
|
// Enable tracing
|
|
//
|
|
WPP_INIT_TRACING(L"Microsoft\\NLB");
|
|
break;
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
//
|
|
// Disable tracing
|
|
//
|
|
WPP_CLEANUP();
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|