able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/wlbs/api/control.cpp

3134 lines
77 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+----------------------------------------------------------------------------
//
// 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;
}
Reference in a new issue Copy permalink