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.
943 lines
22 KiB
943 lines
22 KiB
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
net\routing\ip\rtrmgr\mhrtbt.c
|
|
|
|
Abstract:
|
|
|
|
Multicast heartbeat
|
|
|
|
Revision History:
|
|
|
|
Amritansh Raghav
|
|
|
|
--*/
|
|
|
|
#include "allinc.h"
|
|
|
|
HANDLE g_hMHbeatSocketEvent;
|
|
|
|
DWORD
|
|
SetMHeartbeatInfo(
|
|
IN PICB picb,
|
|
IN PRTR_INFO_BLOCK_HEADER pInfoHdr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Sets multicast heartbeat information passed to the ICB.
|
|
|
|
Locks
|
|
|
|
Must be called with ICB_LIST lock held as WRITER
|
|
|
|
Arguments
|
|
|
|
picb The ICB of the interface for whom the multicast hearbeat
|
|
related variables have to be set
|
|
pInfoHdr Interface Info header
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_INFO pInfo;
|
|
PRTR_TOC_ENTRY pToc;
|
|
DWORD dwResult;
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
|
|
TraceEnter("SetMHeartbeatInfo");
|
|
|
|
pHbeatCb = &picb->mhcHeartbeatInfo;
|
|
|
|
pToc = GetPointerToTocEntry(IP_MCAST_HEARBEAT_INFO,
|
|
pInfoHdr);
|
|
|
|
if(!pToc)
|
|
{
|
|
//
|
|
// Leave things as they are
|
|
//
|
|
|
|
TraceLeave("SetMHeartbeatInfo");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
pInfo = (PMCAST_HBEAT_INFO)GetInfoFromTocEntry(pInfoHdr,
|
|
pToc);
|
|
|
|
|
|
if((pToc->InfoSize is 0) or (pInfo is NULL))
|
|
{
|
|
//
|
|
// If the size is zero, stop detecting
|
|
//
|
|
|
|
DeActivateMHeartbeat(picb);
|
|
|
|
//
|
|
// Also, blow away any old info
|
|
//
|
|
|
|
ZeroMemory(pHbeatCb,
|
|
sizeof(MCAST_HBEAT_CB));
|
|
|
|
//
|
|
// Set the socket to invalid
|
|
//
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Set the info present. We dont care if resolution is in progress
|
|
// because it will find that the name has changed or that detection has
|
|
// been deactivated and will not do anything
|
|
//
|
|
|
|
//
|
|
// If the address protocol or port changes deactivate the heartbeat
|
|
//
|
|
|
|
if((pInfo->bActive is FALSE) or
|
|
(wcsncmp(pInfo->pwszGroup,
|
|
pHbeatCb->pwszGroup,
|
|
MAX_GROUP_LEN) isnot 0) or
|
|
(pInfo->byProtocol isnot pHbeatCb->byProtocol) or
|
|
(pInfo->wPort isnot pHbeatCb->wPort))
|
|
{
|
|
DeActivateMHeartbeat(picb);
|
|
}
|
|
|
|
//
|
|
// Copy out the info
|
|
//
|
|
|
|
wcsncpy(pHbeatCb->pwszGroup,
|
|
pInfo->pwszGroup,
|
|
MAX_GROUP_LEN);
|
|
|
|
pHbeatCb->pwszGroup[MAX_GROUP_LEN - 1] = UNICODE_NULL;
|
|
|
|
pHbeatCb->wPort = pInfo->wPort;
|
|
pHbeatCb->byProtocol = pInfo->byProtocol;
|
|
pHbeatCb->ullDeadInterval =
|
|
(ULONGLONG)(60 * SYS_UNITS_IN_1_SEC * pInfo->ulDeadInterval);
|
|
|
|
//
|
|
// Leave the group and socket as they are
|
|
//
|
|
|
|
//
|
|
// If the info says that detection should be on, but the i/f is not
|
|
// detecting, either it is being switched on or it was deactivated due
|
|
// to a info change and needs to be on
|
|
//
|
|
|
|
dwResult = NO_ERROR;
|
|
|
|
if((pHbeatCb->bActive is FALSE) and
|
|
(pInfo->bActive is TRUE))
|
|
{
|
|
pHbeatCb->bActive = TRUE;
|
|
|
|
dwResult = ActivateMHeartbeat(picb);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
Trace2(ERR,
|
|
"SetMHeartbeatInfo: Error %d activating hbeat for %S",
|
|
GetLastError(),
|
|
picb->pwszName);
|
|
|
|
ZeroMemory(pHbeatCb,
|
|
sizeof(MCAST_HBEAT_CB));
|
|
}
|
|
}
|
|
|
|
TraceLeave("SetMHeartbeatInfo");
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD
|
|
GetMHeartbeatInfo(
|
|
PICB picb,
|
|
PRTR_TOC_ENTRY pToc,
|
|
PBYTE pbDataPtr,
|
|
PRTR_INFO_BLOCK_HEADER pInfoHdr,
|
|
PDWORD pdwSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Gets the multicast hearbeat info related to the interface
|
|
|
|
Locks
|
|
|
|
Called with ICB_LIST lock held as READER
|
|
|
|
Arguments
|
|
|
|
picb The ICB of the interface whose multicast heartbeat information
|
|
is being retrieved
|
|
pToc Pointer to TOC for router discovery info
|
|
pbDataPtr Pointer to start of data buffer
|
|
pInfoHdr Pointer to the header of the whole info
|
|
pdwSize [IN] Size of data buffer
|
|
[OUT] Size of buffer consumed
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_INFO pInfo;
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
|
|
TraceEnter("GetMHeartbeatInfo");
|
|
|
|
if(*pdwSize < sizeof(MCAST_HBEAT_INFO))
|
|
{
|
|
*pdwSize = sizeof(MCAST_HBEAT_INFO);
|
|
|
|
TraceLeave("GetMHeartbeatInfo");
|
|
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
*pdwSize = pToc->InfoSize = sizeof(MCAST_HBEAT_INFO);
|
|
|
|
//pToc->InfoVersion IP_MCAST_HEARBEAT_INFO;
|
|
pToc->InfoType = IP_MCAST_HEARBEAT_INFO;
|
|
pToc->Count = 1;
|
|
pToc->Offset = (ULONG)(pbDataPtr - (PBYTE) pInfoHdr);
|
|
|
|
pInfo = (PMCAST_HBEAT_INFO)pbDataPtr;
|
|
|
|
pHbeatCb = &picb->mhcHeartbeatInfo;
|
|
|
|
wcsncpy(pHbeatCb->pwszGroup,
|
|
pInfo->pwszGroup,
|
|
MAX_GROUP_LEN);
|
|
|
|
pHbeatCb->pwszGroup[MAX_GROUP_LEN - 1] = UNICODE_NULL;
|
|
|
|
|
|
pInfo->bActive = pHbeatCb->bActive;
|
|
pInfo->byProtocol = pHbeatCb->byProtocol;
|
|
pInfo->wPort = pHbeatCb->wPort;
|
|
pInfo->ulDeadInterval =
|
|
(ULONG)(pHbeatCb->ullDeadInterval/(60 * SYS_UNITS_IN_1_SEC));
|
|
|
|
|
|
TraceLeave("GetMHeartbeatInfo");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ActivateMHeartbeat(
|
|
PICB picb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Function to activate heartbeat detection. If there is no info or the
|
|
detection is configured to be inactive, we quit. We try to get the
|
|
group address. If a name is given we queue a worker to resolve the
|
|
group name, otherwise we start detection
|
|
|
|
Locks
|
|
|
|
ICB_LIST lock held as WRITER
|
|
|
|
Arguments
|
|
|
|
picb ICB of the interface to activate
|
|
|
|
Return Value
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
CHAR pszGroup[MAX_GROUP_LEN];
|
|
PHEARTBEAT_CONTEXT pContext;
|
|
DWORD dwResult;
|
|
|
|
|
|
TraceEnter("ActivateMHeartbeat");
|
|
|
|
pHbeatCb = &picb->mhcHeartbeatInfo;
|
|
|
|
if((pHbeatCb->bActive is FALSE) or
|
|
(pHbeatCb->bResolutionInProgress is TRUE))
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Convert to ansi
|
|
//
|
|
|
|
WideCharToMultiByte(CP_ACP,
|
|
0,
|
|
pHbeatCb->pwszGroup,
|
|
-1,
|
|
pszGroup,
|
|
MAX_GROUP_LEN,
|
|
NULL,
|
|
NULL);
|
|
|
|
pHbeatCb->dwGroup = inet_addr((CONST CHAR *)pszGroup);
|
|
|
|
if(pHbeatCb->dwGroup is INADDR_NONE)
|
|
{
|
|
//
|
|
// we need to resolve the name. This will be done in a
|
|
// worker function. Create a context for the function and
|
|
// queue it
|
|
//
|
|
|
|
pContext = HeapAlloc(IPRouterHeap,
|
|
0,
|
|
sizeof(HEARTBEAT_CONTEXT));
|
|
|
|
if(pContext is NULL)
|
|
{
|
|
Trace2(ERR,
|
|
"SetMHeartbeatInfo: Error %d allocating context for %S",
|
|
GetLastError(),
|
|
picb->pwszName);
|
|
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
pContext->dwIfIndex = picb->dwIfIndex;
|
|
pContext->picb = picb;
|
|
|
|
|
|
CopyMemory(&pContext->pwszGroup,
|
|
pHbeatCb->pwszGroup,
|
|
sizeof(MAX_GROUP_LEN));
|
|
|
|
dwResult = QueueAsyncFunction(ResolveHbeatName,
|
|
pContext,
|
|
FALSE);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
HeapFree(IPRouterHeap,
|
|
0,
|
|
pContext);
|
|
|
|
Trace2(ERR,
|
|
"SetMHeartbeatInfo: Error %d queuing worker for %S",
|
|
GetLastError(),
|
|
picb->pwszName);
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
pHbeatCb->bResolutionInProgress = TRUE;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// No need to do name resultion. Just start
|
|
//
|
|
|
|
dwResult = StartMHeartbeat(picb);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
Trace2(ERR,
|
|
"SetMHeartbeatInfo: Error %d starting hbeat for %S",
|
|
dwResult,
|
|
picb->pwszName);
|
|
|
|
}
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
DWORD
|
|
StartMHeartbeat(
|
|
IN PICB picb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Activates router discovery messages on an interface. The interface must
|
|
already be bound.
|
|
|
|
Locks
|
|
|
|
Called with the ICB_LIST lock held as WRITER
|
|
|
|
Arguments
|
|
|
|
picb The ICB of the interface to activate
|
|
|
|
Return Value
|
|
|
|
NO_ERROR or some error code
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
DWORD dwResult;
|
|
|
|
TraceEnter("ActivateMHeartbeat");
|
|
|
|
if((picb->dwAdminState isnot IF_ADMIN_STATUS_UP) or
|
|
(picb->dwOperationalState < IF_OPER_STATUS_CONNECTING))
|
|
{
|
|
TraceLeave("ActivateMHeartbeat");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
pHbeatCb = &picb->mhcHeartbeatInfo;
|
|
|
|
dwResult = CreateHbeatSocket(picb);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
Trace2(ERR,
|
|
"ActivateMHeartbeat: Couldnt create socket for %S. Error %d",
|
|
picb->pwszName,
|
|
dwResult);
|
|
|
|
TraceLeave("ActivateMHeartbeat");
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
//
|
|
// Yes we are active
|
|
//
|
|
|
|
pHbeatCb->bActive = TRUE;
|
|
|
|
TraceLeave("ActivateMHeartbeat");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
CreateHbeatSocket(
|
|
IN PICB picb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Creates a socket to listen to multicast hearbeat messages
|
|
|
|
Locks
|
|
|
|
ICB_LIST lock must be held as WRITER
|
|
|
|
Arguments
|
|
|
|
picb The ICB of the interface for which the socket has to be created
|
|
|
|
Return Value
|
|
|
|
NO_ERROR or some error code
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
DWORD i, dwResult, dwBytesReturned;
|
|
struct linger lingerOption;
|
|
BOOL bOption, bLoopback;
|
|
SOCKADDR_IN sinSockAddr;
|
|
struct ip_mreq imOption;
|
|
|
|
TraceEnter("CreateHbeatSocket");
|
|
|
|
if(picb->bBound)
|
|
{
|
|
Trace1(ERR,
|
|
"CreateHbeatSocket: Can not activate heartbeat on %S as it is not bound",
|
|
picb->pwszName);
|
|
|
|
TraceLeave("CreateHbeatSocket");
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
//
|
|
// Create the sockets for the interface
|
|
//
|
|
|
|
pHbeatCb = &(picb->mhcHeartbeatInfo);
|
|
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
|
|
if(pHbeatCb->byProtocol is IPPROTO_RAW)
|
|
{
|
|
//
|
|
// If we are raw proto, then the port number contains protocol
|
|
//
|
|
|
|
pHbeatCb->sHbeatSocket = WSASocket(AF_INET,
|
|
SOCK_RAW,
|
|
LOBYTE(pHbeatCb->wPort),
|
|
NULL,
|
|
0,
|
|
MHBEAT_SOCKET_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
IpRtAssert(pHbeatCb->byProtocol is IPPROTO_UDP);
|
|
|
|
pHbeatCb->sHbeatSocket = WSASocket(AF_INET,
|
|
SOCK_DGRAM,
|
|
IPPROTO_UDP,
|
|
NULL,
|
|
0,
|
|
MHBEAT_SOCKET_FLAGS);
|
|
|
|
}
|
|
|
|
if(pHbeatCb->sHbeatSocket is INVALID_SOCKET)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace2(ERR,
|
|
"CreateHbeatSocket: Couldnt create socket on %S. Error %d",
|
|
picb->pwszName,
|
|
dwResult);
|
|
|
|
TraceLeave("CreateHbeatSocket");
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
#if 0
|
|
|
|
//
|
|
// Set to SO_DONTLINGER
|
|
//
|
|
|
|
bOption = TRUE;
|
|
|
|
if(setsockopt(pHbeatCb->sHbeatSocket,
|
|
SOL_SOCKET,
|
|
SO_DONTLINGER,
|
|
(const char FAR*)&bOption,
|
|
sizeof(BOOL)) is SOCKET_ERROR)
|
|
{
|
|
Trace1(ERR,
|
|
"CreateHbeatSocket: Couldnt set linger option - continuing. Error %d",
|
|
WSAGetLastError());
|
|
}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Set to SO_REUSEADDR
|
|
//
|
|
|
|
bOption = TRUE;
|
|
|
|
if(setsockopt(pHbeatCb->sHbeatSocket,
|
|
SOL_SOCKET,
|
|
SO_REUSEADDR,
|
|
(const char FAR*)&bOption,
|
|
sizeof(BOOL)) is SOCKET_ERROR)
|
|
{
|
|
Trace1(ERR,
|
|
"CreateHbeatSocket: Couldnt set reuse option - continuing. Error %d",
|
|
WSAGetLastError());
|
|
}
|
|
|
|
//
|
|
// we are interested in READ events only and want the event to be set
|
|
// for those
|
|
//
|
|
|
|
if(WSAEventSelect(pHbeatCb->sHbeatSocket,
|
|
g_hMHbeatSocketEvent,
|
|
FD_READ) is SOCKET_ERROR)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace2(ERR,
|
|
"CreateHbeatSocket: WSAEventSelect() failed for socket on %S.Error %d",
|
|
picb->pwszName,
|
|
dwResult);
|
|
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
|
|
//
|
|
// Bind to one of the addresses on the interface. We just bind to the
|
|
// first address (and the port if specified)
|
|
//
|
|
|
|
sinSockAddr.sin_family = AF_INET;
|
|
sinSockAddr.sin_addr.s_addr = picb->pibBindings[0].dwAddress;
|
|
|
|
if(pHbeatCb->byProtocol is IPPROTO_UDP)
|
|
{
|
|
sinSockAddr.sin_port = pHbeatCb->wPort;
|
|
}
|
|
else
|
|
{
|
|
sinSockAddr.sin_port = 0;
|
|
}
|
|
|
|
if(bind(pHbeatCb->sHbeatSocket,
|
|
(const struct sockaddr FAR*)&sinSockAddr,
|
|
sizeof(SOCKADDR_IN)) is SOCKET_ERROR)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace3(ERR,
|
|
"CreateHbeatSocket: Couldnt bind to %s on interface %S. Error %d",
|
|
inet_ntoa(*(PIN_ADDR)&(picb->pibBindings[0].dwAddress)),
|
|
picb->pwszName,
|
|
dwResult);
|
|
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return dwResult;
|
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
//
|
|
// Join the multicast session
|
|
//
|
|
|
|
sinSockAddr.sin_family = AF_INET;
|
|
sinSockAddr.sin_addr.s_addr = pHbeatCb->dwGroup;
|
|
sinSockAddr.sin_port = 0;
|
|
|
|
if(WSAJoinLeaf(pHbeatCb->sHbeatSocket,
|
|
(const struct sockaddr FAR*)&sinSockAddr,
|
|
sizeof(SOCKADDR_IN),
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
JL_BOTH) is INVALID_SOCKET)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace2(ERR,
|
|
"CreateHbeatSocket: Couldnt join multicast group over %s on %S",
|
|
inet_ntoa(*(PIN_ADDR)&(picb->pibBindings[i].dwAddress)),
|
|
picb->pwszName);
|
|
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
#else
|
|
|
|
sinSockAddr.sin_addr.s_addr = picb->pibBindings[0].dwAddress;
|
|
|
|
if(setsockopt(pHbeatCb->sHbeatSocket,
|
|
IPPROTO_IP,
|
|
IP_MULTICAST_IF,
|
|
(PBYTE)&sinSockAddr.sin_addr,
|
|
sizeof(IN_ADDR)) is SOCKET_ERROR)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace2(ERR,
|
|
"CreateHbeatSocket: Couldnt enable mcast over %s on %S",
|
|
inet_ntoa(*(PIN_ADDR)&(picb->pibBindings[0].dwAddress)),
|
|
picb->pwszName);
|
|
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
imOption.imr_multiaddr.s_addr = pHbeatCb->dwGroup;
|
|
imOption.imr_interface.s_addr = picb->pibBindings[0].dwAddress;
|
|
|
|
if(setsockopt(pHbeatCb->sHbeatSocket,
|
|
IPPROTO_IP,
|
|
IP_ADD_MEMBERSHIP,
|
|
(PBYTE)&imOption,
|
|
sizeof(imOption)) is SOCKET_ERROR)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
Trace3(ERR,
|
|
"CreateHbeatSocket: Couldnt join %d.%d.%d.%d on socket over %s on %S",
|
|
PRINT_IPADDR(pHbeatCb->dwGroup),
|
|
inet_ntoa(*(PIN_ADDR)&(picb->pibBindings[0].dwAddress)),
|
|
picb->pwszName);
|
|
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
#endif
|
|
|
|
TraceLeave("CreateHbeatSocket");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VOID
|
|
DeleteHbeatSocket(
|
|
IN PICB picb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Deletes the sockets (if any) created for running Router Discovery
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
picb The interface whose sockets need to be deleted
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
|
|
{
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
DWORD i;
|
|
|
|
|
|
pHbeatCb = &(picb->mhcHeartbeatInfo);
|
|
|
|
if(pHbeatCb->sHbeatSocket isnot INVALID_SOCKET)
|
|
{
|
|
closesocket(pHbeatCb->sHbeatSocket);
|
|
}
|
|
|
|
pHbeatCb->sHbeatSocket = INVALID_SOCKET;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
DeActivateMHeartbeat(
|
|
IN PICB picb
|
|
)
|
|
{
|
|
PMCAST_HBEAT_CB pHbeatCb;
|
|
|
|
|
|
TraceEnter("DeActivateMHeartbeat");
|
|
|
|
pHbeatCb = &(picb->mhcHeartbeatInfo);
|
|
|
|
if(!pHbeatCb->bActive)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DeleteHbeatSocket(picb);
|
|
|
|
pHbeatCb->bActive = FALSE;
|
|
|
|
TraceLeave("DeActivateMHeartbeat");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VOID
|
|
HandleMHeartbeatMessages(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY pleNode;
|
|
PICB picb;
|
|
DWORD i, dwResult, dwRcvAddrLen, dwSizeOfHeader;
|
|
DWORD dwBytesRead, dwFlags;
|
|
WSANETWORKEVENTS wsaNetworkEvents;
|
|
SOCKADDR_IN sinFrom;
|
|
WSABUF wsaRcvBuf;
|
|
SYSTEMTIME stSysTime;
|
|
ULARGE_INTEGER uliTime;
|
|
|
|
wsaRcvBuf.len = 0;
|
|
wsaRcvBuf.buf = NULL;
|
|
|
|
GetSystemTime(&stSysTime);
|
|
|
|
SystemTimeToFileTime(&stSysTime,
|
|
(PFILETIME)&uliTime);
|
|
|
|
TraceEnter("HandleMHeartbeatMessages");
|
|
|
|
for(pleNode = ICBList.Flink;
|
|
pleNode isnot &ICBList;
|
|
pleNode = pleNode->Flink)
|
|
{
|
|
picb = CONTAINING_RECORD(pleNode, ICB, leIfLink);
|
|
|
|
//
|
|
// If the interface has no bindings, or isnot involved in
|
|
// multicast heartbeat detection, we wouldnt have
|
|
// opened a socket on it so the FD_READ notification cant be for it
|
|
//
|
|
|
|
if((picb->bBound is FALSE) or
|
|
(picb->mhcHeartbeatInfo.bActive is FALSE))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(picb->mhcHeartbeatInfo.sHbeatSocket is INVALID_SOCKET)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(WSAEnumNetworkEvents(picb->mhcHeartbeatInfo.sHbeatSocket,
|
|
NULL,
|
|
&wsaNetworkEvents) is SOCKET_ERROR)
|
|
{
|
|
dwResult = GetLastError();
|
|
|
|
Trace1(ERR,
|
|
"HandleMHeartbeatMessages: WSAEnumNetworkEvents() returned %d",
|
|
dwResult);
|
|
|
|
continue;
|
|
}
|
|
|
|
if(!(wsaNetworkEvents.lNetworkEvents & FD_READ))
|
|
{
|
|
//
|
|
// Read bit isnot set and we arent interested in anything else
|
|
//
|
|
|
|
continue;
|
|
}
|
|
|
|
if(wsaNetworkEvents.iErrorCode[FD_READ_BIT] isnot NO_ERROR)
|
|
{
|
|
Trace2(ERR,
|
|
"HandleMHeartbeatMessages: Error %d associated with socket on %S for FD_READ",
|
|
wsaNetworkEvents.iErrorCode[FD_READ_BIT],
|
|
picb->pwszName);
|
|
|
|
continue;
|
|
}
|
|
|
|
dwRcvAddrLen = sizeof(SOCKADDR_IN);
|
|
dwFlags = 0;
|
|
|
|
//
|
|
// We dont want the data, we just want to clear out the read
|
|
// notification
|
|
//
|
|
|
|
dwResult = WSARecvFrom(picb->mhcHeartbeatInfo.sHbeatSocket,
|
|
&wsaRcvBuf,
|
|
1,
|
|
&dwBytesRead,
|
|
&dwFlags,
|
|
(struct sockaddr FAR*)&sinFrom,
|
|
&dwRcvAddrLen,
|
|
NULL,
|
|
NULL);
|
|
|
|
if(dwResult is SOCKET_ERROR)
|
|
{
|
|
dwResult = WSAGetLastError();
|
|
|
|
if(dwResult isnot WSAEMSGSIZE)
|
|
{
|
|
Trace3(ERR,
|
|
"HandleMHeartbeatMessages: Error %d in WSARecvFrom on %S. Bytes read %d",
|
|
dwResult,
|
|
picb->pwszName,
|
|
dwBytesRead);
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If the message is on the group we need to hear from
|
|
// then update the last heard time
|
|
//
|
|
|
|
picb->mhcHeartbeatInfo.ullLastHeard = uliTime.QuadPart;
|
|
|
|
}
|
|
|
|
TraceLeave("HandleMHeartbeatMessages");
|
|
}
|
|
|