You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
594 lines
13 KiB
594 lines
13 KiB
/*++
|
|
|
|
Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
network.c
|
|
|
|
Abstract:
|
|
|
|
Provides interface for managing cluster networks
|
|
|
|
Author:
|
|
|
|
John Vert (jvert) 30-Jan-1996
|
|
Charlie Wickham (charlwi) 5-Jun-1997
|
|
|
|
Revision History:
|
|
copied from group.c
|
|
|
|
--*/
|
|
|
|
#include "clusapip.h"
|
|
|
|
|
|
HNETWORK
|
|
WINAPI
|
|
OpenClusterNetwork(
|
|
IN HCLUSTER hCluster,
|
|
IN LPCWSTR lpszNetworkName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens a handle to the specified network
|
|
|
|
Arguments:
|
|
|
|
hCluster - Supplies a handle to the cluster
|
|
|
|
lpszNetworkName - Supplies the name of the network to be opened
|
|
|
|
Return Value:
|
|
|
|
non-NULL - returns an open handle to the specified network.
|
|
|
|
NULL - The operation failed. Extended error status is available
|
|
using GetLastError()
|
|
|
|
--*/
|
|
|
|
{
|
|
PCLUSTER Cluster;
|
|
PCNETWORK Network;
|
|
error_status_t Status = ERROR_SUCCESS;
|
|
|
|
//
|
|
// get a pointer to the cluster struct, alloocate space for the network
|
|
// structure and the supplied name.
|
|
//
|
|
|
|
Cluster = (PCLUSTER)hCluster;
|
|
|
|
Network = LocalAlloc(LMEM_FIXED, sizeof(CNETWORK));
|
|
if (Network == NULL) {
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(NULL);
|
|
}
|
|
|
|
Network->Name = LocalAlloc(LMEM_FIXED, (lstrlenW(lpszNetworkName)+1)*sizeof(WCHAR));
|
|
if (Network->Name == NULL) {
|
|
LocalFree(Network);
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// init the network struct and call clussvc to open the network
|
|
//
|
|
|
|
lstrcpyW(Network->Name, lpszNetworkName);
|
|
Network->Cluster = Cluster;
|
|
InitializeListHead(&Network->NotifyList);
|
|
|
|
WRAP_NULL(Network->hNetwork,
|
|
(ApiOpenNetwork(Cluster->RpcBinding,
|
|
lpszNetworkName,
|
|
&Status)),
|
|
&Status,
|
|
Cluster);
|
|
|
|
if ((Network->hNetwork == NULL) || (Status != ERROR_SUCCESS)) {
|
|
|
|
LocalFree(Network->Name);
|
|
LocalFree(Network);
|
|
SetLastError(Status);
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// Link newly opened network onto the cluster structure.
|
|
//
|
|
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
InsertHeadList(&Cluster->NetworkList, &Network->ListEntry);
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
return ((HNETWORK)Network);
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
CloseClusterNetwork(
|
|
IN HNETWORK hNetwork
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Closes a network handle returned from OpenClusterNetwork
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies the network handle
|
|
|
|
Return Value:
|
|
|
|
TRUE - The operation was successful.
|
|
|
|
FALSE - The operation failed. Extended error status is available
|
|
using GetLastError()
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETWORK Network;
|
|
PCLUSTER Cluster;
|
|
|
|
Network = (PCNETWORK)hNetwork;
|
|
Cluster = (PCLUSTER)Network->Cluster;
|
|
|
|
//
|
|
// Unlink network from cluster list.
|
|
//
|
|
EnterCriticalSection(&Cluster->Lock);
|
|
RemoveEntryList(&Network->ListEntry);
|
|
|
|
//
|
|
// Remove any notifications posted against this network.
|
|
//
|
|
RundownNotifyEvents(&Network->NotifyList, Network->Name);
|
|
|
|
//if the cluster is dead and the reconnect has failed,
|
|
//the Network->hNetwork might be NULL if s_apiopennetinterface for
|
|
//this network failed on a reconnect
|
|
//the cluster may be dead and hinterface may be non null, say
|
|
//if reconnectnetworks succeeded but say the reconnectgroups
|
|
//failed
|
|
// At reconnect, the old context is saved in the obsolete
|
|
// list for deletion when the cluster handle is closed or when
|
|
// the next call is made
|
|
if ((Cluster->Flags & CLUS_DEAD) && (Network->hNetwork))
|
|
{
|
|
RpcSmDestroyClientContext(&Network->hNetwork);
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
goto FnExit;
|
|
}
|
|
|
|
LeaveCriticalSection(&Cluster->Lock);
|
|
|
|
//
|
|
// Close RPC context handle
|
|
//
|
|
ApiCloseNetwork(&Network->hNetwork);
|
|
|
|
FnExit:
|
|
//
|
|
// Free memory allocations
|
|
//
|
|
LocalFree(Network->Name);
|
|
LocalFree(Network);
|
|
|
|
//
|
|
// Give the cluster a chance to clean up in case this
|
|
// network was the only thing keeping it around.
|
|
//
|
|
CleanupCluster(Cluster);
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
CLUSTER_NETWORK_STATE
|
|
WINAPI
|
|
GetClusterNetworkState(
|
|
IN HNETWORK hNetwork
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the network's current state
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies a handle to a cluster network
|
|
|
|
Return Value:
|
|
|
|
Returns the current state of the network.
|
|
If the function fails, the return value is -1. Extended error
|
|
status is available using GetLastError()
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETWORK Network;
|
|
CLUSTER_NETWORK_STATE State;
|
|
DWORD Status;
|
|
|
|
Network = (PCNETWORK)hNetwork;
|
|
|
|
WRAP(Status,
|
|
(ApiGetNetworkState( Network->hNetwork,
|
|
(LPDWORD)&State )), // cast for win64 warning
|
|
Network->Cluster);
|
|
|
|
if (Status == ERROR_SUCCESS) {
|
|
|
|
return(State);
|
|
} else {
|
|
|
|
SetLastError(Status);
|
|
return( ClusterNetworkStateUnknown );
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
SetClusterNetworkName(
|
|
IN HNETWORK hNetwork,
|
|
IN LPCWSTR lpszNetworkName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the friendly name of a cluster network
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies a handle to a cluster network
|
|
|
|
lpszNetworkName - Supplies the new name of the cluster network
|
|
|
|
cchName - ?
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful
|
|
|
|
Win32 error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETWORK Network;
|
|
DWORD Status;
|
|
|
|
Network = (PCNETWORK)hNetwork;
|
|
|
|
WRAP(Status,
|
|
(ApiSetNetworkName(Network->hNetwork, lpszNetworkName)),
|
|
Network->Cluster);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
GetClusterNetworkId(
|
|
IN HNETWORK hNetwork,
|
|
OUT LPWSTR lpszNetworkId,
|
|
IN OUT LPDWORD lpcchName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the unique identifier of the specified network
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies the network whose unique ID is to be returned.
|
|
|
|
lpszNetworkId - Points to a buffer that receives the unique ID of the object,
|
|
including the terminating null character.
|
|
|
|
lpcchName - Points to a variable that specifies the size, in characters
|
|
of the buffer pointed to by the lpszNetworkId parameter. This size
|
|
should include the terminating null character. When the function
|
|
returns, the variable pointed to be lpcchName contains the number
|
|
of characters stored in the buffer. The count returned does not
|
|
include the terminating null character.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Status;
|
|
DWORD Length;
|
|
PCNETWORK Network = (PCNETWORK)hNetwork;
|
|
LPWSTR Guid=NULL;
|
|
|
|
WRAP(Status,
|
|
(ApiGetNetworkId(Network->hNetwork,
|
|
&Guid)),
|
|
Network->Cluster);
|
|
|
|
if (Status != ERROR_SUCCESS) {
|
|
return(Status);
|
|
}
|
|
|
|
MylstrcpynW(lpszNetworkId, Guid, *lpcchName);
|
|
Length = lstrlenW(Guid);
|
|
|
|
if (Length >= *lpcchName) {
|
|
if (lpszNetworkId == NULL) {
|
|
Status = ERROR_SUCCESS;
|
|
} else {
|
|
Status = ERROR_MORE_DATA;
|
|
}
|
|
}
|
|
|
|
*lpcchName = Length;
|
|
MIDL_user_free(Guid);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
HNETWORKENUM
|
|
WINAPI
|
|
ClusterNetworkOpenEnum(
|
|
IN HNETWORK hNetwork,
|
|
IN DWORD dwType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initiates an enumeration of the existing cluster network objects.
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies a handle to the specific network.
|
|
|
|
dwType - Supplies a bitmask of the type of properties to be
|
|
enumerated.
|
|
|
|
Return Value:
|
|
|
|
If successful, returns a handle suitable for use with ClusterNetworkEnum
|
|
|
|
If unsuccessful, returns NULL and GetLastError() returns a more
|
|
specific error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNETWORK Network = (PCNETWORK)hNetwork;
|
|
PENUM_LIST Enum = NULL;
|
|
DWORD errorStatus;
|
|
|
|
//
|
|
// validate bitmask
|
|
//
|
|
|
|
if ((dwType & CLUSTER_NETWORK_ENUM_ALL) == 0) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(NULL);
|
|
}
|
|
|
|
if ((dwType & ~CLUSTER_NETWORK_ENUM_ALL) != 0) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(NULL);
|
|
}
|
|
|
|
//
|
|
// open connection to service for enum'ing
|
|
//
|
|
|
|
WRAP(errorStatus,
|
|
(ApiCreateNetworkEnum(Network->hNetwork,
|
|
dwType,
|
|
&Enum)),
|
|
Network->Cluster);
|
|
|
|
if (errorStatus != ERROR_SUCCESS) {
|
|
|
|
SetLastError(errorStatus);
|
|
return(NULL);
|
|
}
|
|
|
|
return((HNETWORKENUM)Enum);
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterNetworkGetEnumCount(
|
|
IN HNETWORKENUM hNetworkEnum
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the number of items contained the the enumerator's collection.
|
|
|
|
Arguments:
|
|
|
|
hEnum - a handle to an enumerator returned by ClusterNetworkOpenEnum.
|
|
|
|
Return Value:
|
|
|
|
The number of items (possibly zero) in the enumerator's collection.
|
|
|
|
--*/
|
|
{
|
|
PENUM_LIST Enum = (PENUM_LIST)hNetworkEnum;
|
|
return Enum->EntryCount;
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterNetworkEnum(
|
|
IN HNETWORKENUM hNetworkEnum,
|
|
IN DWORD dwIndex,
|
|
OUT LPDWORD lpdwType,
|
|
OUT LPWSTR lpszName,
|
|
IN OUT LPDWORD lpcchName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the next enumerable resource object.
|
|
|
|
Arguments:
|
|
|
|
hNetworkEnum - Supplies a handle to an open cluster network enumeration
|
|
returned by ClusterNetworkOpenEnum
|
|
|
|
dwIndex - Supplies the index to enumerate. This parameter should be
|
|
zero for the first call to the ClusterEnum function and then
|
|
incremented for subsequent calls.
|
|
|
|
lpdwType - Returns the type of network.
|
|
|
|
lpszName - Points to a buffer that receives the name of the network
|
|
object, including the terminating null character.
|
|
|
|
lpcchName - Points to a variable that specifies the size, in characters,
|
|
of the buffer pointed to by the lpszName parameter. This size
|
|
should include the terminating null character. When the function
|
|
returns, the variable pointed to by lpcchName contains the
|
|
number of characters stored in the buffer. The count returned
|
|
does not include the terminating null character.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Status;
|
|
DWORD NameLen;
|
|
PENUM_LIST Enum = (PENUM_LIST)hNetworkEnum;
|
|
|
|
if (dwIndex >= Enum->EntryCount) {
|
|
return(ERROR_NO_MORE_ITEMS);
|
|
}
|
|
|
|
NameLen = lstrlenW( Enum->Entry[dwIndex].Name );
|
|
|
|
MylstrcpynW(lpszName, Enum->Entry[dwIndex].Name, *lpcchName);
|
|
|
|
if (*lpcchName < (NameLen + 1)) {
|
|
if (lpszName == NULL) {
|
|
Status = ERROR_SUCCESS;
|
|
} else {
|
|
Status = ERROR_MORE_DATA;
|
|
}
|
|
} else {
|
|
Status = ERROR_SUCCESS;
|
|
}
|
|
|
|
*lpdwType = Enum->Entry[dwIndex].Type;
|
|
*lpcchName = NameLen;
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
DWORD
|
|
WINAPI
|
|
ClusterNetworkCloseEnum(
|
|
IN HNETWORKENUM hNetworkEnum
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Closes an open enumeration for a network.
|
|
|
|
Arguments:
|
|
|
|
hNetworkEnum - Supplies a handle to the enumeration to be closed.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is ERROR_SUCCESS.
|
|
|
|
If the function fails, the return value is an error value.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD i;
|
|
PENUM_LIST Enum = (PENUM_LIST)hNetworkEnum;
|
|
|
|
//
|
|
// Walk through enumeration freeing all the names
|
|
//
|
|
for (i=0; i<Enum->EntryCount; i++) {
|
|
MIDL_user_free(Enum->Entry[i].Name);
|
|
}
|
|
MIDL_user_free(Enum);
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
|
|
|
|
HCLUSTER
|
|
WINAPI
|
|
GetClusterFromNetwork(
|
|
IN HNETWORK hNetwork
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the cluster handle from the associated network handle.
|
|
|
|
Arguments:
|
|
|
|
hNetwork - Supplies the network.
|
|
|
|
Return Value:
|
|
|
|
Handle to the cluster associated with the network handle.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD nStatus;
|
|
PCNETWORK Network = (PCNETWORK)hNetwork;
|
|
HCLUSTER hCluster = (HCLUSTER)Network->Cluster;
|
|
|
|
nStatus = AddRefToClusterHandle( hCluster );
|
|
if ( nStatus != ERROR_SUCCESS ) {
|
|
SetLastError( nStatus );
|
|
hCluster = NULL;
|
|
}
|
|
return( hCluster );
|
|
|
|
} // GetClusterFromNetwork()
|