able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ip/igmp/work.c

2577 lines
78 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//=============================================================================
// Copyright (c) 1997 Microsoft Corporation
// File: work.c
//
// Abstract:
// Implements the work items that are queued by igmp routines.
//
// Author: K.S.Lokesh (lokeshs@) 11-1-97
//
// Revision History:
//=============================================================================
#include "pchigmp.h"
#pragma hdrstop
//
// should each packet be queued to another work item again
//
#define BQUEUE_WORK_ITEM_FOR_PACKET 1
//------------------------------------------------------------------------------
// _WT_ProcessInputEvent
// called in the wait worker thread when the packet event is set.
// Queues: _WF_ProcessInputEvent()
// Runs in: WaitServerThread context
//------------------------------------------------------------------------------
VOID
WT_ProcessInputEvent(
PVOID pContext, // psee entry. the entry might have been deleted.
BOOLEAN NotUsed
)
{
HANDLE WaitHandle ;
//
// set the InputWaitEvent to NULL so that UnregisterWaitEx is not called.
// psee will be valid here, but might not be once queued to the worker Fn.
//
PSOCKET_EVENT_ENTRY psee = (PSOCKET_EVENT_ENTRY) pContext;
if (!EnterIgmpApi())
return;
Trace0(WORKER, "_WF_ProcessInputEvent queued by WaitThread");
// make a non-blocking UnregisterWaitEx call
WaitHandle = InterlockedExchangePointer(&psee->InputWaitEvent, NULL);
if (WaitHandle)
UnregisterWaitEx( WaitHandle, NULL ) ;
QueueIgmpWorker(WF_ProcessInputEvent, pContext);
LeaveIgmpApi();
return;
}
//------------------------------------------------------------------------------
// _WF_ProcessInputEvent
// Called by: _WT_ProcessInputEvent()
// Locks:
// Acquire socketsLockShared. Either queue processing the packet to
// _WF_ProcessPacket() or take shared interface lock and process the packet.
//------------------------------------------------------------------------------
VOID
WF_ProcessInputEvent (
PVOID pContext
)
{
DWORD Error = NO_ERROR;
PIF_TABLE_ENTRY pite;
PLIST_ENTRY ple, pHead;
WSANETWORKEVENTS wsane;
PSOCKET_EVENT_ENTRY psee = (PSOCKET_EVENT_ENTRY) pContext,
pseeTmp;
PSOCKET_ENTRY pse;
if (!EnterIgmpWorker()) return;
Trace0(ENTER1, "Entering _WF_ProcessInputEvent");
ACQUIRE_SOCKETS_LOCK_SHARED("_WF_ProcessInputEvent");
//
// make sure that the psee entry still exists
//
pHead = &g_ListOfSocketEvents;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pseeTmp = CONTAINING_RECORD(ple, SOCKET_EVENT_ENTRY, LinkBySocketEvents);
if (pseeTmp==psee)
break;
}
if (ple==pHead) {
RELEASE_SOCKETS_LOCK_SHARED("_WF_ProcessInputEvent");
Trace0(ERR, "Input Event received on deleted SocketEvent. not an error");
LeaveIgmpWorker();
return;
}
//
// go through the list of active interfaces
// processing sockets which have input packets
//
pHead = &psee->ListOfInterfaces;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pse = CONTAINING_RECORD(ple, SOCKET_ENTRY, LinkByInterfaces);
pite = CONTAINING_RECORD(pse, IF_TABLE_ENTRY, SocketEntry);
//
// process only activated interfaces. (Proxy wont be on this list)
//
if (!IS_IF_ACTIVATED(pite))
continue;
//
// process input event
//
BEGIN_BREAKOUT_BLOCK1 {
if (pse->Socket == INVALID_SOCKET)
GOTO_END_BLOCK1;
//
// enumerate network events to see whether
// any packets have arrived on this interface
//
Error = WSAEnumNetworkEvents(pse->Socket, NULL, &wsane);
if (Error != NO_ERROR) {
Trace3(RECEIVE,
"error %d checking for input on interface %d (%d.%d.%d.%d)",
Error, pite->IfIndex, PRINT_IPADDR(pite->IpAddr));
Logwarn1(ENUM_NETWORK_EVENTS_FAILED, "%I", pite->IpAddr, Error);
GOTO_END_BLOCK1;
}
if (!(wsane.lNetworkEvents & FD_READ))
GOTO_END_BLOCK1;
//
// the input flag is set, now see if there was an error
//
if (wsane.iErrorCode[FD_READ_BIT] != NO_ERROR) {
Trace3(RECEIVE,
"error %d in input record for interface %d (%d.%d.%d.%d)",
wsane.iErrorCode[FD_READ_BIT], pite->IfIndex,
PRINT_IPADDR(pite->IpAddr)
);
Logwarn1(INPUT_RECORD_ERROR, "%I", pite->IpAddr, Error);
GOTO_END_BLOCK1;
}
//
// Process the packet received on the interface
//
ProcessInputOnInterface(pite);
} END_BREAKOUT_BLOCK1;
} //for loop: for each interface
//
// register the event with the wait thread for future receives
//
if (g_RunningStatus!=IGMP_STATUS_STOPPING) {
DWORD dwRetval;
if (! RegisterWaitForSingleObject(
&psee->InputWaitEvent,
psee->InputEvent,
WT_ProcessInputEvent,
(VOID*)psee,
INFINITE,
(WT_EXECUTEINWAITTHREAD)|(WT_EXECUTEONLYONCE)
))
{
dwRetval = GetLastError();
Trace1(ERR, "error %d RtlRegisterWait", dwRetval);
IgmpAssertOnError(FALSE);
}
}
RELEASE_SOCKETS_LOCK_SHARED("_WF_ProcessInputEvent");
LeaveIgmpWorker();
Trace0(LEAVE1, "leaving _WF_ProcessInputEvent()\n");
Trace0(LEAVE, ""); //putting a newline
return;
} //end _WF_ProcessInputEvent
//------------------------------------------------------------------------------
// _ProcessInputOnInterface
// Does some minimal checking of packet length, etc. We can either queue to
// work item(_WF_ProcessPacket) or run it here itself.
//
// Called by: _WF_ProcessInputEvent()
// Locks: Assumes socket lock. Either queues the packet to _WF_ProcessPacket or
// takes shared interface lock and processes it here itself.
//------------------------------------------------------------------------------
VOID
ProcessInputOnInterface(
PIF_TABLE_ENTRY pite
)
{
WSABUF WsaBuf;
DWORD dwNumBytes, dwFlags, dwAddrLen;
SOCKADDR_IN saSrcAddr;
DWORD dwSrcAddr, DstnMcastAddr;
DWORD Error = NO_ERROR;
UCHAR *pPacket;
UCHAR IpHdrLen;
PIP_HEADER pIpHdr;
BOOL bRtrAlertSet = FALSE;
PBYTE Buffer;
WsaBuf.len = pite->Info.PacketSize;
WsaBuf.buf = IGMP_ALLOC(WsaBuf.len, 0x800040, pite->IfIndex);
PROCESS_ALLOC_FAILURE2(WsaBuf.buf,
"error %d allocating %d bytes for input packet",
Error, WsaBuf.len,
return);
Buffer = WsaBuf.buf;
BEGIN_BREAKOUT_BLOCK1 {
//
// read the incoming packet
//
dwAddrLen = sizeof(SOCKADDR_IN);
dwAddrLen = sizeof (saSrcAddr);
dwFlags = 0;
Error = WSARecvFrom(pite->SocketEntry.Socket, &WsaBuf, 1, &dwNumBytes,
&dwFlags, (SOCKADDR FAR *)&saSrcAddr, &dwAddrLen,
NULL, NULL);
// check if any error in reading packet
if ((Error!=0)||(dwNumBytes == 0)) {
Error = WSAGetLastError();
Trace2(RECEIVE, "error %d receiving packet on interface %d)",
Error, pite->IfIndex);
Logerr1(RECVFROM_FAILED, "%I", pite->IpAddr, Error);
GOTO_END_BLOCK1;
}
//
// dont ignore the packet even if it is from a local address
//
//
// set packet ptr, IpHdr ptr, dwNumBytes, SrcAddr, DstnMcastAddr
//
// set source addr of packet
dwSrcAddr = saSrcAddr.sin_addr.s_addr;
IpHdrLen = (Buffer[0]&0x0F)*4;
pPacket = &Buffer[IpHdrLen];
dwNumBytes -= IpHdrLen;
pIpHdr = (PIP_HEADER)Buffer;
DstnMcastAddr = (ULONG)pIpHdr->Dstn.s_addr;
//
// verify that the packet has igmp type
//
if (pIpHdr->Protocol!=0x2) {
Trace5(RECEIVE,
"Packet received with IpDstnAddr(%d.%d.%d.%d) %d.%d.%d.%d from(%s) on "
"IF:%0x is not of Igmp type(%d)",
PRINT_IPADDR(pIpHdr->Dstn.s_addr), PRINT_IPADDR(pIpHdr->Src.s_addr),
PRINT_IPADDR(dwSrcAddr), pite->IfIndex, pIpHdr->Protocol
);
Error = ERROR_CAN_NOT_COMPLETE;
GOTO_END_BLOCK1;
}
//
// check if packet has router alert option
//
{
PBYTE pOption = (PBYTE)(pIpHdr+1);
UCHAR i;
for (i=0; i<IpHdrLen-20; i+=4) {
if ( (pOption[0]==148) && (pOption[1]==4) ) {
bRtrAlertSet = TRUE;
break;
}
}
}
if (BQUEUE_WORK_ITEM_FOR_PACKET) {
PACKET_CONTEXT UNALIGNED *pPktContext;
//
// allocate and initialize a packet-context
//
CREATE_PACKET_CONTEXT(pPktContext, dwNumBytes, Error);
if (Error!=NO_ERROR)
GOTO_END_BLOCK1;
pPktContext->IfIndex = pite->IfIndex;
pPktContext->DstnMcastAddr = DstnMcastAddr;
pPktContext->InputSrc = dwSrcAddr;
pPktContext->Length = dwNumBytes;
pPktContext->Flags = bRtrAlertSet;
CopyMemory(pPktContext->Packet, pPacket, dwNumBytes);
//
// enqueue the work-item to process the packet
//
Error = QueueIgmpWorker(WF_ProcessPacket, (PVOID)pPktContext);
Trace2(WORKER, "Queuing IgmpWorker function: %s in %s",
"WF_ProcessPacket:", "ProcessInputOnInterface");
if (Error != NO_ERROR) {
Trace1(ERR, "error %d queueing work-item for packet", Error);
Logerr0(QUEUE_WORKER_FAILED, Error);
IGMP_FREE(pPktContext);
GOTO_END_BLOCK1;
}
}
//
// process the packet here itself
//
else {
ACQUIRE_IF_LOCK_SHARED(pite->IfIndex, "_ProcessInputOnInterface");
ProcessPacket(pite, dwSrcAddr, DstnMcastAddr, dwNumBytes, pPacket,
bRtrAlertSet);
RELEASE_IF_LOCK_SHARED(pite->IfIndex, "_ProcessInputOnInterface");
}
} END_BREAKOUT_BLOCK1;
IGMP_FREE(WsaBuf.buf);
return;
} //end _ProcessInputOnInterface
//------------------------------------------------------------------------------
// _WF_ProcessPacket
// Queued by: _ProcessInputOnInterface()
// Locks: takes shared interface lock
// Calls: _ProcessPacket()
//------------------------------------------------------------------------------
VOID
WF_ProcessPacket (
PVOID pvContext
)
{
PPACKET_CONTEXT pPktContext = (PPACKET_CONTEXT)pvContext;
DWORD IfIndex = pPktContext->IfIndex;
PIF_TABLE_ENTRY pite;
if (!EnterIgmpWorker()) { return; }
Trace0(ENTER1, "Entering _WF_ProcessPacket()");
ACQUIRE_IF_LOCK_SHARED(IfIndex, "_WF_ProcessPacket");
BEGIN_BREAKOUT_BLOCK1 {
//
// retrieve the interface
//
pite = GetIfByIndex(IfIndex);
if (pite == NULL) {
Trace1(ERR, "_WF_ProcessPacket: interface %d not found", IfIndex);
GOTO_END_BLOCK1;
}
//
// make sure that the interface is activated
//
if (!(IS_IF_ACTIVATED(pite))) {
Trace1(ERR,"_WF_ProcessPacket() called for inactive IfIndex(%0x)",
IfIndex);
GOTO_END_BLOCK1;
}
//
// process the packet
//
ProcessPacket (pite, pPktContext->InputSrc, pPktContext->DstnMcastAddr,
pPktContext->Length, pPktContext->Packet, pPktContext->Flags);
} END_BREAKOUT_BLOCK1;
RELEASE_IF_LOCK_SHARED(IfIndex, "_WF_ProcessPacket");
IGMP_FREE(pPktContext);
Trace0(LEAVE1, "Leaving _WF_ProcessPacket()");
LeaveIgmpWorker();
return;
} //end _WF_ProcessPacket
#define RETURN_FROM_PROCESS_PACKET() {\
if (DEBUG_TIMER_PACKET&&bPrintTimerDebug) {\
if (Error==NO_ERROR) {\
Trace0(TIMER1, " ");\
Trace0(TIMER1, "Printing Timer Queue after _ProcessPacket");\
DebugPrintTimerQueue();\
}\
}\
if (ExitLockRelease&IF_LOCK) \
RELEASE_IF_LOCK_SHARED(IfIndex, "_ProcessPacket"); \
if (ExitLockRelease&GROUP_LOCK) \
RELEASE_GROUP_LOCK(Group, "_ProcessPacket"); \
if (ExitLockRelease&TIMER_LOCK) \
RELEASE_TIMER_LOCK("_ProcessPacket");\
Trace0(LEAVE1, "Leaving _ProcessPacket1()\n"); \
return; \
}
//------------------------------------------------------------------------------
// _ProcessPacket
//
// Processes a packet received on an interface
//
// Locks: Assumes either shared Interface lock
// or shared Socket Lock.
// if ras interface, this procedure takes read lock on the ras table.
// Called by: _ProcessInputOnInterface() or _WF_ProcessPacket()
//------------------------------------------------------------------------------
VOID
ProcessPacket (
PIF_TABLE_ENTRY pite,
DWORD InputSrcAddr,
DWORD DstnMcastAddr,
DWORD NumBytes,
PBYTE pPacketData, // igmp packet hdr. data following it ignored
BOOL bRtrAlertSet
)
{
DWORD Error = NO_ERROR;
DWORD IfIndex = pite->IfIndex, Group=0, IfVersion;
IGMP_HEADER UNALIGNED *pHdr;
PIF_INFO pInfo = &pite->Info;
PIGMP_IF_CONFIG pConfig = &pite->Config;
PRAS_TABLE prt;
PRAS_TABLE_ENTRY prte;
PRAS_CLIENT_INFO pRasInfo;
BOOL bRasStats = FALSE, bPrintTimerDebug=TRUE;
LONGLONG llCurTime = GetCurrentIgmpTime();
INT cmp;
CHAR szPacketType[30];
enum {
NO_LOCK=0,
IF_LOCK=0x1,
RAS_LOCK=0x2,
GROUP_LOCK=0x4,
TIMER_LOCK=0x8
} ExitLockRelease;
ExitLockRelease = 0;
IfVersion = IS_IF_VER1(pite)? 1: (IS_IF_VER2(pite)?2:3);
Trace2(ENTER1, "Entering _ProcessPacket() IfIndex(%0x) DstnMcastAddr(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(DstnMcastAddr)
);
//
// the packet must be at least some minimum length
//
if (NumBytes < MIN_PACKET_SIZE) {
Trace4(RECEIVE,
"%d-byte packet from %d.%d.%d.%d on If %0x (%d.%d.%d.%d) is too small",
NumBytes, PRINT_IPADDR(InputSrcAddr), IfIndex, pite->IpAddr
);
Logwarn2(PACKET_TOO_SMALL, "%I%I", pite->IpAddr, InputSrcAddr, NO_ERROR);
InterlockedIncrement(&pite->Info.ShortPacketsReceived);
//todo: implement ras stats
/*if (bRasStats)
InterlockedIncrement(&pRasInfo->ShortPacketsReceived);
*/
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//
// initialize packet fields
//
pHdr = (IGMP_HEADER UNALIGNED *) pPacketData;
Group = pHdr->Group;
//
// Verify packet version
//
if ( (pHdr->Vertype==IGMP_QUERY)||(pHdr->Vertype==IGMP_REPORT_V1)
|| (pHdr->Vertype==IGMP_REPORT_V2) || (pHdr->Vertype==IGMP_REPORT_V3)
|| (pHdr->Vertype==IGMP_LEAVE) )
{
InterlockedIncrement(&pInfo->TotalIgmpPacketsForRouter);
//if (bRasStats)
// InterlockedIncrement(&pRasInfo->TotalIgmpPacketsForRouter);
}
else {
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
switch(pHdr->Vertype) {
case IGMP_QUERY:
lstrcpy(szPacketType, "igmp-query"); break;
case IGMP_REPORT_V1:
lstrcpy(szPacketType, "igmp-report-v1"); break;
case IGMP_REPORT_V2:
lstrcpy(szPacketType, "igmp-report-v2"); break;
case IGMP_REPORT_V3:
lstrcpy(szPacketType, "igmp-report-v3"); break;
case IGMP_LEAVE:
lstrcpy(szPacketType, "igmp-leave"); break;
};
//
// check for router alert option
//
if (!bRtrAlertSet) {
InterlockedIncrement(&pInfo->PacketsWithoutRtrAlert);
if (pite->Config.Flags&IGMP_ACCEPT_RTRALERT_PACKETS_ONLY) {
Trace3(RECEIVE,
"%s packet from %d ignored on IfIndex(%d%) due to no "
"RtrAlert option",
szPacketType, PRINT_IPADDR(InputSrcAddr), IfIndex
);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
}
//
// Make sure that the DstnMcastAddr is a valid multicast addr
// or the unicast address of the router
//
if (!IS_MCAST_ADDR(DstnMcastAddr) && DstnMcastAddr!=pite->IpAddr) {
Trace2(ERR,
"Error! Igmp router received packet from Src(%d.%d.%d.%d) with "
"dstn addr(%d.%d.%d.%d) which is not valid",
PRINT_IPADDR(InputSrcAddr), PRINT_IPADDR(DstnMcastAddr)
);
IgmpAssertOnError(FALSE);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//
// make sure that the interface is activated
//
if (!(IS_IF_ACTIVATED(pite))) {
Trace1(ERR,"ProcessPacket() called for inactive IfIndex(%0x)",
IfIndex);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//
//if ras-server, then get lock on ras table.
//
if ( IS_RAS_SERVER_IF(pite->IfType) ) {
prt = pite->pRasTable;
//
// retrieve ras client by addr
//
prte = GetRasClientByAddr(InputSrcAddr, prt);
if (prte==NULL) {
Trace3(ERR,
"Got Igmp packet from an unknown ras client(%d.%d.%d.%d) on "
"IF(%d:%d.%d.%d.%d)",
PRINT_IPADDR(InputSrcAddr), IfIndex, PRINT_IPADDR(pite->IpAddr)
);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
#if 0
// if the ras-client is not active, then return
if (prte->Status&DELETED_FLAG)
RETURN_FROM_PROCESS_PACKET();
#endif
// should I update ras client stats
bRasStats = g_Config.RasClientStats;
pRasInfo = &prte->Info;
}
//
// increment count of total igmp packets received
//
InterlockedIncrement(&pInfo->TotalIgmpPacketsReceived);
if (bRasStats)
InterlockedIncrement(&pRasInfo->TotalIgmpPacketsReceived);
//
// long packet received. print trace if not v3. But it is not an error
//
if ( (NumBytes > MIN_PACKET_SIZE) && !IS_CONFIG_IGMP_V3(&pite->Config)) {
Trace4( RECEIVE,
"%d-byte packet from %d.%d.%d.%d on If %d (%d.%d.%d.%d) is too large",
NumBytes, PRINT_IPADDR(InputSrcAddr), IfIndex,
PRINT_IPADDR(pite->IpAddr)
);
InterlockedIncrement(&pite->Info.LongPacketsReceived);
if (bRasStats)
InterlockedIncrement(&pRasInfo->LongPacketsReceived);
}
//
// Verify Igmp checksum
//
if (xsum(pHdr, NumBytes) != 0xffff) {
Trace0(RECEIVE, "Wrong checksum packet received");
InterlockedIncrement(&pInfo->WrongChecksumPackets);
if (bRasStats)
InterlockedIncrement(&pRasInfo->WrongChecksumPackets);
RETURN_FROM_PROCESS_PACKET();
}
switch (pHdr->Vertype) {
//////////////////////////////////////////////////////////////////
// IGMP-QUERY //
//////////////////////////////////////////////////////////////////
case IGMP_QUERY :
{
//
// ignore the query if it came from this interface
//
if (MatchIpAddrBinding(pite, InputSrcAddr)) {
/*
Trace3(RECEIVE,
"received query packet sent by myself: IfIndex(%0x)"
"IpAddr(%d.%d.%d.%d) DstnMcastAddr(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(InputSrcAddr), PRINT_IPADDR(DstnMcastAddr)
);
*/
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//
// Error if interface type is IGMP_IF_RAS_SERVER. can be
// IGMP_IF_RAS_ROUTER or IS_NOT_RAS_IF
//
if (! ( (IS_NOT_RAS_IF(pite->IfType))||(IS_RAS_ROUTER_IF(pite->IfType) ) )
)
{
Trace3(ERR,
"Error received Query on IfIndex(%d: %d.%d.%d.%d) from "
"Ras client(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(pite->IpAddr), PRINT_IPADDR(InputSrcAddr)
);
IgmpAssertOnError(FALSE);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//////////////////////////////////////////////////////////////////
// General Query
//////////////////////////////////////////////////////////////////
if (pHdr->Group==0) {
DWORD Version,//Min(interface,pkt vertion)
RealVersion;//pkt version
// get versions
Version = ((pHdr->ResponseTime==0)||IS_IF_VER1(pite))
? 1
: ( (NumBytes==sizeof(IGMP_HEADER)||IS_IF_VER2(pite)) ? 2 : 3);
RealVersion = (pHdr->ResponseTime==0)
? 1
: (NumBytes==sizeof(IGMP_HEADER) ? 2 : 3);
Trace3(RECEIVE,
"General Query Version:%d received on interface(%d) from %d.%d.%d.%d",
IfIndex, RealVersion, PRINT_IPADDR(InputSrcAddr));
if (Version!=RealVersion){
Trace2(RECEIVE, "Processing the Version:%d packet as Version:%d",
RealVersion, RealVersion);
}
//
// check that the dstn addr was AllHostsAddr
//
if (DstnMcastAddr!=ALL_HOSTS_MCAST) {
Trace3(RECEIVE,
"received query packet not on AllHostsGroup: IfIndex(%0x)"
"SrcAddr(%d.%d.%d.%d) DstnMcastAddr(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(InputSrcAddr),
PRINT_IPADDR(DstnMcastAddr)
);
RETURN_FROM_PROCESS_PACKET();
}
//
// acquire timer lock
//
ACQUIRE_TIMER_LOCK("_ProcessPacket");
ExitLockRelease |= TIMER_LOCK;
//
// log warning if incorrect version query received
//
if ( ((RealVersion==1)&&(!IS_PROTOCOL_TYPE_IGMPV1(pite)))
|| (RealVersion==2 && !IS_PROTOCOL_TYPE_IGMPV2(pite))
|| (RealVersion==3 && IS_PROTOCOL_TYPE_IGMPV3(pite)) )
{
// get warn interval in system time
LONGLONG llWarnInterval = OTHER_VER_ROUTER_WARN_INTERVAL*60*1000;
InterlockedIncrement(&pInfo->WrongVersionQueries);
//
// check if warn interval time has passed since last warning
// I check if OtherVerPresentTimeWarn>llCurTime to take care
// of timer resets
//
if ( (pInfo->OtherVerPresentTimeWarn+llWarnInterval<llCurTime)
|| (pInfo->OtherVerPresentTimeWarn>llCurTime) )
{
if (pHdr->ResponseTime==0) {
Trace3(RECEIVE,
"Detected ver-%d router(%d.%d.%d.%d) on "
"interface(%d.%d.%d.%d)",
Version, PRINT_IPADDR(InputSrcAddr),
PRINT_IPADDR(pite->IpAddr));
Logwarn2(VERSION_QUERY, "%I%I", InputSrcAddr,
pite->IpAddr, NO_ERROR);
}
pInfo->OtherVerPresentTimeWarn = llCurTime;
}
}
if (Version==1)
pite->Info.V1QuerierPresentTime = llCurTime
+ CONFIG_TO_SYSTEM_TIME(IGMP_VER1_RTR_PRESENT_TIMEOUT);
//
// if IpAddress less than my address then I become NonQuerier
// even if I am in Startup Mode
//
if (INET_CMP(InputSrcAddr, pite->IpAddr, cmp) <0) {
DWORD QQIC=0,QRV=0;
// last querier is being changed from myself to B, or from A to B.
if (InputSrcAddr != pite->Info.QuerierIpAddr)
pite->Info.LastQuerierChangeTime = llCurTime;
//
// if (version 3, change robustness variable and query interval
// if required) (only if I am not querier. else it will be
// changed when I change to non-querier
//
if (Version==3 && !IS_QUERIER(pite)
&&(INET_CMP(InputSrcAddr, pite->Info.QuerierIpAddr, cmp)<=0))
{
PIGMP_HEADER_V3_EXT pSourcesQuery;
pSourcesQuery = (PIGMP_HEADER_V3_EXT)
((PBYTE)pHdr+sizeof(IGMP_HEADER));
if (pSourcesQuery->QRV!=0) {
if (pite->Config.RobustnessVariable!=pSourcesQuery->QRV)
{
Trace3(CONFIG,
"Changing Robustness variable from %d to %d. "
"Querier:%d.%d.%d.%d",
pite->Config.RobustnessVariable,
pSourcesQuery->QRV,
PRINT_IPADDR(InputSrcAddr)
);
pite->Config.RobustnessVariable = pSourcesQuery->QRV;
}
}
QQIC = GET_QQIC_FROM_CODE(pSourcesQuery->QQIC)*1000;
if (pSourcesQuery->QQIC!=0 && pite->Config.GenQueryMaxResponseTime < QQIC) {
if (pite->Config.GenQueryInterval!=QQIC)
{
Trace3(CONFIG,
"Changing General-Query-Interval from %d to %d. "
"Querier:%d.%d.%d.%d",
pite->Config.GenQueryInterval/1000,
QQIC/1000,
PRINT_IPADDR(InputSrcAddr)
);
pite->Config.GenQueryInterval
= QQIC;
}
}
pite->Config.GroupMembershipTimeout =
pite->Config.RobustnessVariable*pite->Config.GenQueryInterval
+ pite->Config.GenQueryMaxResponseTime;
pite->Config.OtherQuerierPresentInterval
= pite->Config.RobustnessVariable*pite->Config.GenQueryInterval
+ (pite->Config.GenQueryMaxResponseTime)/2;
}
// change from querier to non-querier
if (IS_QUERIER(pite)) {
PQUERIER_CONTEXT pwi = IGMP_ALLOC(sizeof(QUERIER_CONTEXT),
0x800080,pite->IfIndex);
if (pwi==NULL)
RETURN_FROM_PROCESS_PACKET();
pwi->IfIndex = IfIndex;
pwi->QuerierIpAddr = InputSrcAddr;
pwi->NewRobustnessVariable = QRV;
pwi->NewGenQueryInterval = QQIC;
// I have to queue a work item as I have to take an If write lock
QueueIgmpWorker(WF_BecomeNonQuerier, (PVOID)pwi);
Trace2(RECEIVE, "_ProcessPacket queued _WF_BecomeNonQuerier "
"on If:%0x Querier(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(InputSrcAddr));
}
// I am non-querier already
else {
InterlockedExchange(&pite->Info.QuerierIpAddr, InputSrcAddr);
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pite->NonQueryTimer, 211, pite->IfIndex, 0, 0);
#endif
UpdateLocalTimer(&pite->NonQueryTimer,
pite->Config.OtherQuerierPresentInterval, DBG_N);
// not using interlockedExchange
pite->Info.QuerierPresentTimeout = llCurTime
+ CONFIG_TO_SYSTEM_TIME(pite->Config.OtherQuerierPresentInterval);
}
}
//
// Ignore query from querier with higher IpAddr
//
else {
}
RELEASE_TIMER_LOCK("_ProcessPacket");
ExitLockRelease &= ~TIMER_LOCK;
RETURN_FROM_PROCESS_PACKET();
} //end general query
//////////////////////////////////////////////////////////////////
// Group Specific Query
//////////////////////////////////////////////////////////////////
else {
Error = ProcessGroupQuery(pite, pHdr, NumBytes, InputSrcAddr, DstnMcastAddr);
RETURN_FROM_PROCESS_PACKET();
}
break;
} //end query (groupSpecific or general)
//////////////////////////////////////////////////////////////////
// IGMP_REPORT_V1, IGMP_REPORT_V2, IGMP_REPORT_V3 //
//////////////////////////////////////////////////////////////////
case IGMP_REPORT_V1 :
case IGMP_REPORT_V2 :
case IGMP_REPORT_V3 :
{
Error = ProcessReport(pite, pHdr, NumBytes, InputSrcAddr, DstnMcastAddr);
RETURN_FROM_PROCESS_PACKET();
}
//////////////////////////////////////////////////////////////////
// IGMP_LEAVE //
//////////////////////////////////////////////////////////////////
case IGMP_LEAVE :
{
PGROUP_TABLE_ENTRY pge; //group table entry
PGI_ENTRY pgie; //group interface entry
Trace3(RECEIVE,
"IGMP Leave for group(%d.%d.%d.%d) on IfIndex(%0x) from "
"SrcAddr(%d.%d.%d.%d)",
PRINT_IPADDR(Group), IfIndex, PRINT_IPADDR(InputSrcAddr)
);
//
// the multicast group should not be 224.0.0.x
//
if (LOCAL_MCAST_GROUP(DstnMcastAddr)) {
Trace2(RECEIVE,
"Leave Report received from %d.%d.%d.%d for "
"Local group(%d.%d.%d.%d)",
PRINT_IPADDR(InputSrcAddr), PRINT_IPADDR(DstnMcastAddr));
RETURN_FROM_PROCESS_PACKET();
}
//
// check that the dstn addr was AllRoutersAddr
// or dstn addr must match the group field
//
if ( (DstnMcastAddr!=ALL_ROUTERS_MCAST)&&(DstnMcastAddr!=Group) ) {
Trace3(RECEIVE,
"received IGMP Leave packet not on AllRoutersGroup: IfIndex(%0x)"
"SrcAddr(%d.%d.%d.%d) DstnMcastAddr(%d.%d.%d.%d)",
IfIndex, PRINT_IPADDR(InputSrcAddr), PRINT_IPADDR(DstnMcastAddr)
);
RETURN_FROM_PROCESS_PACKET();
}
//
// check that the Group field is a valid multicast addr
//
if ( !IS_MCAST_ADDR(Group) ) {
Trace4(RECEIVE,
"received IGMP Leave packet with illegal Group(%d.%d.%d.%d) field: "
"IfIndex(%0x) SrcAddr(%d.%d.%d.%d) DstnMcastAddr(%d.%d.%d.%d)",
PRINT_IPADDR(Group), IfIndex, PRINT_IPADDR(InputSrcAddr),
PRINT_IPADDR(DstnMcastAddr)
);
RETURN_FROM_PROCESS_PACKET();
}
//
// update statistics
//
InterlockedIncrement(&pite->Info.LeavesReceived);
if (bRasStats)
InterlockedIncrement(&pRasInfo->LeavesReceived);
//
// if Leave processing not enabled or not querier then ignore Leave.
//
if ( !((IS_IF_VER2(pite)||IS_IF_VER3(pite)) && (IS_QUERIER(pite))) ) {
Trace0(RECEIVE,"Ignoring the Leave Packet");
break;
}
//
// Lock the group table
//
ACQUIRE_GROUP_LOCK(Group, "_ProcessPacket");
ExitLockRelease |= GROUP_LOCK;
//
// find the group entry. If entry not found then ignore the leave messg
//
pge = GetGroupFromGroupTable(Group, NULL, llCurTime);
if (pge==NULL) {
Error = ERROR_CAN_NOT_COMPLETE;
Trace2(ERR, "Leave received for nonexisting group(%d.%d.%d.%d) on IfIndex(%0x)",
PRINT_IPADDR(Group), pite->IfIndex);
RETURN_FROM_PROCESS_PACKET();
}
//
// find the GI entry. If GI entry does not exist or has deletedFlag then
// ignore the leave
//
pgie = GetGIFromGIList(pge, pite, InputSrcAddr, NOT_STATIC_GROUP, NULL, llCurTime);
if ( (pgie==NULL)||(pgie->Status&DELETED_FLAG) ) {
Error = ERROR_CAN_NOT_COMPLETE;
Trace2(ERR, "leave received for nonexisting group(%d.%d.%d.%d) on IfIndex(%0x). Not member",
PRINT_IPADDR(Group), IfIndex);
RETURN_FROM_PROCESS_PACKET();
}
// ignore leave if it is not in ver 2 mode
if (pgie->Version!=2)
RETURN_FROM_PROCESS_PACKET();
// if static group, ignore leave
if (pgie->bStaticGroup) {
Trace2(ERR,
"Leave not processed for group(%d.%d.%d.%d) on IfIndex(%0x): "
"Static group",
PRINT_IPADDR(Group), IfIndex
);
RETURN_FROM_PROCESS_PACKET();
}
//
// if v1-query received recently for that group, then ignore leaves
//
//
if (pgie->Version==1)
{
Error = ERROR_CAN_NOT_COMPLETE;
Trace2(ERR,
"Leave not processed for group(%d.%d.%d.%d) on IfIndex(%0x)"
"(recent v1 report)",
PRINT_IPADDR(Group), IfIndex
);
bPrintTimerDebug = FALSE;
RETURN_FROM_PROCESS_PACKET();
}
//
// if ras server interface, then delete the group entry and I am done.
// GroupSpecific Query is not sent to ras clients
//
// if pConfig->LastMemQueryCount==0 then the group is expected to be
// deleted immediately
//
if ( IS_RAS_SERVER_IF(pite->IfType) || pConfig->LastMemQueryCount==0) {
DeleteGIEntry(pgie, TRUE, TRUE); //updateStats, CallMgm
RETURN_FROM_PROCESS_PACKET();
}
ACQUIRE_TIMER_LOCK("_ProcessPacket");
ExitLockRelease |= TIMER_LOCK;
//
// if timer already expired return.
// Leave the group deletion to Membership timer
//
if ( !(pgie->GroupMembershipTimer.Status&TIMER_STATUS_ACTIVE)
||(pgie->GroupMembershipTimer.Timeout<llCurTime) )
{
RETURN_FROM_PROCESS_PACKET();
}
//
// if currently processing a leave then exit.
//
if (pgie->LastMemQueryCount>0) {
RETURN_FROM_PROCESS_PACKET();
}
//
// in almost all places, I have to do this check.
// change the way insert and update timers' timeout is set
//
// set a new leave timer. Set the new LastMemQueryCount left
//
if (pConfig->LastMemQueryCount) {
pgie->LastMemQueryCount = pConfig->LastMemQueryCount - 1;
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pgie->LastMemQueryTimer, 410, pite->IfIndex,
Group, 0);
#endif
InsertTimer(&pgie->LastMemQueryTimer, pConfig->LastMemQueryInterval, TRUE, DBG_Y);
}
//
// set membership timer to
// min{currentValue,LastMemQueryInterval*LastMemQueryCount}
//
if (pgie->GroupMembershipTimer.Timeout >
(llCurTime+(pConfig->LastMemQueryCount
*CONFIG_TO_SYSTEM_TIME(pConfig->LastMemQueryInterval)))
)
{
#if DEBUG_TIMER_TIMERID
pgie->GroupMembershipTimer.Id = 340;
pgie->GroupMembershipTimer.Id2 = TimerId++;
#endif
UpdateLocalTimer(&pgie->GroupMembershipTimer,
pConfig->LastMemQueryCount*pConfig->LastMemQueryInterval,
DBG_N);
// update GroupExpiryTime so that correct stats are displayed
pgie->Info.GroupExpiryTime = llCurTime
+ CONFIG_TO_SYSTEM_TIME(pConfig->LastMemQueryCount
*pConfig->LastMemQueryInterval);
}
//
//release timer and groupBucket locks
//I still have read lock on the IfTable/RasTable
//
RELEASE_TIMER_LOCK("_ProcessPacket");
RELEASE_GROUP_LOCK(Group, "_ProcessPacket");
ExitLockRelease &= ~TIMER_LOCK;
ExitLockRelease &= ~GROUP_LOCK;
//
// send group specific query only if I am a querier
//
if (IS_QUERIER(pite))
SEND_GROUP_QUERY_V2(pite, Group);
//releae ifLock/RasLock and exit
RETURN_FROM_PROCESS_PACKET();
}//igmp leave
default :
{
Error = ERROR_CAN_NOT_COMPLETE;
Trace3(ERR,
"Incorrect Igmp type(%d) packet received on IfIndex(%d%) Group(%d.%d.%d.5d)",
pHdr->Vertype, IfIndex, PRINT_IPADDR(Group)
);
IgmpAssertOnError(FALSE);
RETURN_FROM_PROCESS_PACKET();
}
}
RETURN_FROM_PROCESS_PACKET();
} //end _ProcessPacket
//------------------------------------------------------------------------------
// _T_LastVer1ReportTimer
//
// For this GI entry, the last ver-1 report has timed out. Change to ver-2 if
// the interface is set to ver-2.
// Locks: Assumes timer lock.
//
// be careful as only timer lock held. make sure that the worker fn checks
// everything. recheck igmp version, etc.
//------------------------------------------------------------------------------
DWORD
T_LastVer1ReportTimer (
PVOID pvContext
)
{
PIGMP_TIMER_ENTRY pTimer; //ptr to timer entry
PGI_ENTRY pgie; //group interface entry
PIF_TABLE_ENTRY pite;
LONGLONG llCurTime = GetCurrentIgmpTime();
Trace0(ENTER1, "Entering _T_LastVer1ReportTimer()");
//
// get pointer to LastMemQueryTimer, GI entry, pite
//
pTimer = CONTAINING_RECORD( pvContext, IGMP_TIMER_ENTRY, Context);
pgie = CONTAINING_RECORD( pTimer, GI_ENTRY, LastVer1ReportTimer);
pite = pgie->pIfTableEntry;
//
// if IfTable not activated, then break
//
if (!IS_IF_ACTIVATED(pite) || (pgie->Status&DELETED_FLAG))
return NO_ERROR;
Trace2(TIMER, "T_LastVer1ReportTimer() called for If(%0x), Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pgie->pGroupTableEntry->Group));
// set the state to ver-2 unless the interface is ver-1, in which case
// set the version-1 timer again.
if (IS_PROTOCOL_TYPE_IGMPV2(pite)) {
pgie->Version = 2;
}
else if (IS_PROTOCOL_TYPE_IGMPV3(pite)) {
if (IS_TIMER_ACTIVE(pgie->LastVer2ReportTimer))
pgie->Version = 2;
else {
PWORK_CONTEXT pWorkContext;
DWORD Error=NO_ERROR;
//
// queue work item for shifting to v3 for that group
//
CREATE_WORK_CONTEXT(pWorkContext, Error);
if (Error!=NO_ERROR) {
return ERROR_CAN_NOT_COMPLETE;
}
pWorkContext->IfIndex = pite->IfIndex;
pWorkContext->Group = pgie->pGroupTableEntry->Group; //ptrs usage safe
pWorkContext->NHAddr = pgie->NHAddr; //valid only for ras: should i us
pWorkContext->WorkType = SHIFT_TO_V3;
Trace0(WORKER, "Queueing WF_TimerProcessing() to shift to v3");
QueueIgmpWorker(WF_TimerProcessing, (PVOID)pWorkContext);
}
}
Trace0(LEAVE1, "Leaving _T_LastVer1ReportTimer()");
return 0;
}
//------------------------------------------------------------------------------
// _T_LastMemQueryTimer
// called when LastMemQueryTimer() has expired. This timer is not used to
// time out memberships (GroupMembershipTimer is used for that). It is only
// used to send GroupSpecific Queries.
//
// Queues: WF_TimerProcessing() to send group specific query.
// Note: WT_ProcessTimerEvent() makes sure the protocol is not stopp-ing/ed
// Locks: Assumes timer lock. does not need any other lock.
// be careful as only timer lock held. make sure that the worker fn checks
// everything. recheck igmp version, etc.
//------------------------------------------------------------------------------
DWORD
T_LastMemQueryTimer (
PVOID pvContext
)
{
DWORD Error=NO_ERROR;
PIGMP_TIMER_ENTRY pTimer; //ptr to timer entry
PGI_ENTRY pgie; //group interface entry
PWORK_CONTEXT pWorkContext;
PIF_TABLE_ENTRY pite;
PRAS_TABLE_ENTRY prte;
BOOL bCompleted = FALSE; //if false, set count to 0
Trace0(ENTER1, "Entering _T_LastMemQueryTimer()");
//
// get pointer to LastMemQueryTimer, GI entry, pite, prte
//
pTimer = CONTAINING_RECORD( pvContext, IGMP_TIMER_ENTRY, Context);
pgie = CONTAINING_RECORD( pTimer, GI_ENTRY, LastMemQueryTimer);
pite = pgie->pIfTableEntry;
prte = pgie->pRasTableEntry;
//
// if IfTable not activated, then break
//
if (!IS_IF_ACTIVATED(pite))
return NO_ERROR;
Trace2(TIMER, "_T_LastMemQueryTimer() called for If(%0x), Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pgie->pGroupTableEntry->Group));
BEGIN_BREAKOUT_BLOCK1 {
//
// if GI or pite or prte has flag already set, then exit
//
if ( (pgie->Status&DELETED_FLAG) || (pite->Status&DELETED_FLAG) )
GOTO_END_BLOCK1;
if ( (prte!=NULL) && (prte->Status&DELETED_FLAG) )
GOTO_END_BLOCK1;
if (pgie->Version!=3) {
//
// if LeaveEnabled FALSE then return
//
if (!GI_PROCESS_GRPQUERY(pite, pgie))
GOTO_END_BLOCK1;
}
//
// have sent the last GroupSpecific query. GroupMembershipTimer will take care
// of deleting this GI entry
//
if (pgie->LastMemQueryCount==0) {
bCompleted = TRUE;
GOTO_END_BLOCK1;
}
//
// decrement count.
//
if (InterlockedDecrement(&pgie->LastMemQueryCount) == (ULONG)-1) {
pgie->LastMemQueryCount = 0;
}
//
// if count==0, dont insert timer again, but send the last groupSp Query
//
if (pgie->LastMemQueryCount>0) {
//reinsert the timer to send the next GroupSpQuery
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pgie->LastMemQueryTimer, 420, pite->IfIndex,
pgie->pGroupTableEntry->Group, 0);
#endif
InsertTimer(&pgie->LastMemQueryTimer,
pite->Config.LastMemQueryInterval, FALSE, DBG_Y);
}
//
// queue work item for sending the GroupSp query even if the router
// is not a Querier
//
CREATE_WORK_CONTEXT(pWorkContext, Error);
if (Error!=NO_ERROR) {
GOTO_END_BLOCK1;
}
pWorkContext->IfIndex = pite->IfIndex;
pWorkContext->Group = pgie->pGroupTableEntry->Group;
pWorkContext->NHAddr = pgie->NHAddr; //valid only for ras: should i use it?
pWorkContext->WorkType = (pgie->Version==3) ? MSG_GROUP_QUERY_V3
: MSG_GROUP_QUERY_V2;
Trace0(WORKER, "Queueing WF_TimerProcessing() to send GroupSpQuery:");
QueueIgmpWorker(WF_TimerProcessing, (PVOID)pWorkContext);
bCompleted = TRUE;
} END_BREAKOUT_BLOCK1;
// there was some error somewhere. so set the LastMemQueryCount to 0
if (!bCompleted)
InterlockedExchange(&pgie->LastMemQueryCount, 0);
Trace0(LEAVE1, "Leaving _T_LastMemQueryTimer()");
return 0;
} //end _T_LastMemQueryTimer
//------------------------------------------------------------------------------
// _T_MembershipTimer
//
// lock: has TimerLock
// called when the GroupMembershipTimer is fired
// delete the GI entry if it exists.
//
// be careful as only timer lock held. make sure that the worker fn checks
// everything. recheck igmp version, etc.
//------------------------------------------------------------------------------
DWORD
T_MembershipTimer (
PVOID pvContext
)
{
DWORD Error=NO_ERROR;
PIGMP_TIMER_ENTRY pTimer; //ptr to timer entry
PGI_ENTRY pgie; //group interface entry
PWORK_CONTEXT pWorkContext;
PIF_TABLE_ENTRY pite;
PRAS_TABLE_ENTRY prte;
Trace0(ENTER1, "Entering _T_MembershipTimer()");
BEGIN_BREAKOUT_BLOCK1 {
//
// get pointer to Membership Timer, GI entry, pite,
//
pTimer = CONTAINING_RECORD( pvContext, IGMP_TIMER_ENTRY, Context);
pgie = CONTAINING_RECORD( pTimer, GI_ENTRY, GroupMembershipTimer);
pite = pgie->pIfTableEntry;
prte = pgie->pRasTableEntry;
//
// if IfTable not activated, then break
//
if (!IS_IF_ACTIVATED(pite))
GOTO_END_BLOCK1;
Trace2(TIMER, "_T_MembershipTimer() called for If(%0x), Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pgie->pGroupTableEntry->Group));
//
// if GI or pite or prte has deleted flag already set, then exit
//
if ( (pgie->Status&DELETED_FLAG) || (pite->Status&DELETED_FLAG) ) {
GOTO_END_BLOCK1;
}
//
// if Ras, and ras table being deleted then break
//
if ( (prte!=NULL) && (prte->Status&DELETED_FLAG) )
GOTO_END_BLOCK1;
//
// if IfTable not activated, then break
//
if (!IS_IF_ACTIVATED(pite))
GOTO_END_BLOCK1;
//
// if LastMemTimer is active, remove it(cant remove it in this function
// as it is being processed by the timer queue simultaneously.
if (pgie->LastMemQueryCount>0)
pgie->LastMemQueryCount = 0;
//
// queue work item to delete the GI entry
//
CREATE_WORK_CONTEXT(pWorkContext, Error);
if (Error!=NO_ERROR)
GOTO_END_BLOCK1;
pWorkContext->IfIndex = pite->IfIndex;
pWorkContext->NHAddr = pgie->NHAddr;
pWorkContext->Group = pgie->pGroupTableEntry->Group;
pWorkContext->WorkType = DELETE_MEMBERSHIP;
Trace0(WORKER, "_T_MembershipTimer queued _WF_TimerProcessing:");
QueueIgmpWorker(WF_TimerProcessing, (PVOID)pWorkContext);
} END_BREAKOUT_BLOCK1;
Trace0(LEAVE1, "Leaving _T_MembershipTimer()");
return 0;
} //end _T_MembershipTimer
//------------------------------------------------------------------------------
// _T_QueryTimer
// fired when a general query timer is fired. Sends a general query.
// The timer queue is currently locked
//
// be careful as only timer lock held. make sure that the worker fn checks
// everything. recheck igmp version, etc.
//------------------------------------------------------------------------------
DWORD
T_QueryTimer (
PVOID pvContext
)
{
DWORD Error=NO_ERROR;
PIGMP_TIMER_ENTRY pTimer; //ptr to timer entry
PWORK_CONTEXT pWorkContext;
PIF_INFO pInfo;
PIF_TABLE_ENTRY pite;
static ULONG Seed = 123456;
ULONG ulTimeout;
BOOL bRandomize = FALSE; // [0,GenQueryInterval] for 1st gen query after startup.
Trace0(ENTER1, "Entering _T_QueryTimer()");
pTimer = CONTAINING_RECORD( pvContext, IGMP_TIMER_ENTRY, Context);
pite = CONTAINING_RECORD( pTimer, IF_TABLE_ENTRY, QueryTimer);
pInfo = &pite->Info;
//
// make sure that the interface is activated
//
if (!(IS_IF_ACTIVATED(pite))) {
Trace2(ERR, "T_QueryTimer() called for inactive IfIndex(%0x), IfType(%d)",
pite->IfIndex, pite->IfType);
return 0;
}
Trace2(TIMER, "Processing T_QueryTimer() for IfIndex(%0x), IfType(%d)",
pite->IfIndex, pite->IfType);
//
// check if still in startup Mode.
//
if (pInfo->StartupQueryCountCurrent>0) {
InterlockedDecrement(&pInfo->StartupQueryCountCurrent);
bRandomize = (pInfo->StartupQueryCountCurrent == 0);
}
// if non-querier, then done if I have sent startupQueries
if ( !IS_QUERIER(pite) && (pInfo->StartupQueryCountCurrent<=0) )
return 0;
// set the next query time
ulTimeout = (pInfo->StartupQueryCountCurrent>0)
? pite->Config.StartupQueryInterval
: (bRandomize )
? (DWORD) ((RtlRandom(&Seed)/(FLOAT)MAXLONG)
*pite->Config.GenQueryInterval)
: pite->Config.GenQueryInterval;
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pite->QueryTimer, 120, pite->IfIndex, 0, 0);
#endif
InsertTimer(&pite->QueryTimer, ulTimeout, FALSE, DBG_Y);
//
// queue work item for sending the general query
//
CREATE_WORK_CONTEXT(pWorkContext, Error);
if (Error!=NO_ERROR)
return 0;
pWorkContext->IfIndex = pite->IfIndex;
pWorkContext->WorkType = MSG_GEN_QUERY;
QueueIgmpWorker(WF_TimerProcessing, (PVOID)pWorkContext);
Trace0(WORKER,
"_T_QueryTimer queued _WF_TimerProcessing: Querier State");
Trace0(LEAVE1, "Leaving _T_QueryTimer()");
return 0;
} //end _T_QueryTimer
//------------------------------------------------------------------------------
// _T_NonQueryTimer
// fired when it is in non-querier Mode and hasnt heard a query for a long time
//
// be careful as only timer lock held. make sure that the worker fn checks
// everything. recheck igmp version, etc.
//------------------------------------------------------------------------------
DWORD
T_NonQueryTimer (
PVOID pvContext
)
{
DWORD Error=NO_ERROR;
PIGMP_TIMER_ENTRY pTimer; //ptr to timer entry
PIF_TABLE_ENTRY pite;
Trace0(ENTER1, "Entering _T_NonQueryTimer()");
pTimer = CONTAINING_RECORD( pvContext, IGMP_TIMER_ENTRY, Context);
pite = CONTAINING_RECORD( pTimer, IF_TABLE_ENTRY, NonQueryTimer);
//
// make sure that the interface is activated
//
if (!(IS_IF_ACTIVATED(pite))) {
/*Trace2(ERR, "T_NonQueryTimer() called for inactive IfIndex(%0x), IfType(%d)",
pite->IfIndex, pite->IfType);
IgmpAssertOnError(FALSE);*/
return 0;
}
Trace2(TIMER, "Processing T_NonQueryTimer() for IfIndex(%0x), IfType(%d)",
pite->IfIndex, pite->IfType);
//
// if non-querier, then queue work item to become querier
//
if (!IS_QUERIER(pite)) {
QueueIgmpWorker(WF_BecomeQuerier, (PVOID)(DWORD_PTR)pite->IfIndex);
Trace1(WORKER, "_T_NonQueryTimer queued _WF_BecomeQuerier on If:%0x",
pite->IfIndex);
}
Trace0(LEAVE1, "Leaving _T_NonQueryTimer()");
return 0;
}
VOID
WF_BecomeQuerier(
PVOID pvIfIndex
)
//Called by T_NonQueryTimer
{
ChangeQuerierState(PtrToUlong(pvIfIndex), QUERIER_FLAG, 0, 0, 0);
}
VOID
WF_BecomeNonQuerier(
PVOID pvContext
)
{
PQUERIER_CONTEXT pwi = (PQUERIER_CONTEXT)pvContext;
ChangeQuerierState(pwi->IfIndex, NON_QUERIER_FLAG, pwi->QuerierIpAddr,
pwi->NewRobustnessVariable, pwi->NewGenQueryInterval);
IGMP_FREE(pwi);
}
VOID
ChangeQuerierState(
DWORD IfIndex,
DWORD Flag, //QUERIER_CHANGE_V1_ONLY,QUERIER_FLAG,NON_QUERIER_FLAG
DWORD QuerierIpAddr, // only when changing from querier-->nonquerier
DWORD NewRobustnessVariable, //only for v3:querier->non-querier
DWORD NewGenQueryInterval //only for v3:querier->non-querier
)
{
PIF_TABLE_ENTRY pite;
BOOL bPrevCanAddGroupsToMgm;
if (!EnterIgmpWorker()) return;
Trace0(ENTER1, "Entering _ChangeQuerierState");
ACQUIRE_IF_LOCK_EXCLUSIVE(IfIndex, "_ChangeQuerierState");
BEGIN_BREAKOUT_BLOCK1 {
//
// retrieve the interface entry
//
pite = GetIfByIndex(IfIndex);
//
// return error if interface does not exist, or it is not activated
// or is already in that state
//
if ( (pite == NULL)||(!IS_IF_ACTIVATED(pite)) ) {
Trace1(ERR,
"Warning: worker fn could not change querier state for If:%0x",
IfIndex
);
GOTO_END_BLOCK1;
}
//
// if it is supposed to be a V1 interface, make sure that it is
//
if ( (Flag & QUERIER_CHANGE_V1_ONLY)
&& (!IS_PROTOCOL_TYPE_IGMPV1(pite)) )
{
GOTO_END_BLOCK1;
}
bPrevCanAddGroupsToMgm = CAN_ADD_GROUPS_TO_MGM(pite);
//
// changing from non querier to querier
//
if (Flag & QUERIER_FLAG) {
// if already querier, then done
if (IS_QUERIER(pite))
GOTO_END_BLOCK1;
SET_QUERIER_STATE_QUERIER(pite->Info.QuerierState);
Trace2(QUERIER,
"NonQuerier --> Querier. IfIndex(%0x), IpAddr(%d.%d.%d.%d) ",
IfIndex, PRINT_IPADDR(pite->IpAddr)
);
// copy back the old robustness, genquery, etc values. for v3
// interface
if (IS_IF_VER3(pite)) {
pite->Config.RobustnessVariable = pite->Config.RobustnessVariableOld;
pite->Config.GenQueryInterval = pite->Config.GenQueryIntervalOld;
pite->Config.OtherQuerierPresentInterval
= pite->Config.OtherQuerierPresentIntervalOld;
pite->Config.GroupMembershipTimeout = pite->Config.GroupMembershipTimeoutOld;
}
// register all groups with MGM if I wasnt doing earlier
if (CAN_ADD_GROUPS_TO_MGM(pite) && !bPrevCanAddGroupsToMgm) {
RefreshMgmIgmprtrGroups(pite, ADD_FLAG);
Trace1(MGM,
"Igmp Router start propagating groups to MGM on If:%0x",
pite->IfIndex
);
}
// I am the querier again. Set the addr in Info.
InterlockedExchange(&pite->Info.QuerierIpAddr, pite->IpAddr);
// update the time when querier was last changed
pite->Info.LastQuerierChangeTime = GetCurrentIgmpTime();
//
// set the GenQuery timer and remove NonQueryTimer if set.
//
ACQUIRE_TIMER_LOCK("_ChangeQuerierState");
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pite->QueryTimer, 220, pite->IfIndex, 0, 0);
#endif
if (!IS_TIMER_ACTIVE(pite->QueryTimer))
InsertTimer(&pite->QueryTimer, pite->Config.GenQueryInterval, FALSE, DBG_Y);
if (IS_TIMER_ACTIVE(pite->NonQueryTimer))
RemoveTimer(&pite->NonQueryTimer, DBG_Y);
RELEASE_TIMER_LOCK("_ChangeQuerierState");
// send general query
SEND_GEN_QUERY(pite);
}
//
// changing from querier to non querier
//
else {
LONGLONG llCurTime = GetCurrentIgmpTime();
BOOL bPrevAddGroupsToMgm;
// if already non querier, then done
if (!IS_QUERIER(pite))
GOTO_END_BLOCK1;
// change querier state
SET_QUERIER_STATE_NON_QUERIER(pite->Info.QuerierState);
Trace2(QUERIER,
"Querier --> NonQuerier. IfIndex(%0x), IpAddr(%d.%d.%d.%d) ",
IfIndex, PRINT_IPADDR(pite->IpAddr)
);
InterlockedExchange(&pite->Info.QuerierIpAddr, QuerierIpAddr);
//
// if previously, groups were propagated to MGM, but should
// not be propagated now, then deregister the groups from MGM
//
if (!CAN_ADD_GROUPS_TO_MGM(pite) && bPrevCanAddGroupsToMgm) {
RefreshMgmIgmprtrGroups(pite, DELETE_FLAG);
Trace1(MGM,
"Igmp Router stop propagating groups to MGM on If:%0x",
pite->IfIndex
);
}
if (IS_IF_VER3(pite)) {
if (NewRobustnessVariable==0)
NewRobustnessVariable = pite->Config.RobustnessVariableOld;
if (NewGenQueryInterval==0)
NewGenQueryInterval = pite->Config.GenQueryIntervalOld;
if (pite->Config.GenQueryMaxResponseTime > NewGenQueryInterval)
NewGenQueryInterval = pite->Config.GenQueryIntervalOld;
if (NewRobustnessVariable != pite->Config.RobustnessVariable
|| NewGenQueryInterval != pite->Config.RobustnessVariable
) {
pite->Config.RobustnessVariable = NewRobustnessVariable;
pite->Config.GenQueryInterval = NewGenQueryInterval;
pite->Config.OtherQuerierPresentInterval
= NewRobustnessVariable*NewGenQueryInterval
+ (pite->Config.GenQueryMaxResponseTime)/2;
pite->Config.GroupMembershipTimeout = NewRobustnessVariable*NewGenQueryInterval
+ pite->Config.GenQueryMaxResponseTime;
Trace3(CONFIG,
"Querier->NonQuerier: Robustness:%d GenQueryInterval:%d "
"GroupMembershipTimeout:%d. ",
NewRobustnessVariable, NewGenQueryInterval/1000,
pite->Config.GroupMembershipTimeout/1000
);
}
}
//
// set other querier present timer, and remove querier timer if not
// in startup query Mode
//
ACQUIRE_TIMER_LOCK("_ChangeQuerierState");
#if DEBUG_TIMER_TIMERID
SET_TIMER_ID(&pite->NonQueryTimer, 210, pite->IfIndex, 0, 0);
#endif
if (!IS_TIMER_ACTIVE(pite->NonQueryTimer)) {
InsertTimer(&pite->NonQueryTimer,
pite->Config.OtherQuerierPresentInterval, TRUE, DBG_Y);
}
if (IS_TIMER_ACTIVE(pite->QueryTimer) &&
(pite->Info.StartupQueryCountCurrent<=0) )
{
RemoveTimer(&pite->QueryTimer, DBG_Y);
}
pite->Info.QuerierPresentTimeout = llCurTime
+ CONFIG_TO_SYSTEM_TIME(pite->Config.OtherQuerierPresentInterval);
RELEASE_TIMER_LOCK("_ChangeQuerierState");
}
} END_BREAKOUT_BLOCK1;
RELEASE_IF_LOCK_EXCLUSIVE(IfIndex, "_ChangeQuerierState");
Trace0(LEAVE1, "leaving _ChangeQuerierState\n");
LeaveIgmpWorker();
return;
}//end _ChangeQuerierState
//------------------------------------------------------------------------------
// _WF_TimerProcessing
//------------------------------------------------------------------------------
VOID
WF_TimerProcessing (
PVOID pvContext
)
{
DWORD IfIndex;
PWORK_CONTEXT pWorkContext = (PWORK_CONTEXT)pvContext;
PIF_TABLE_ENTRY pite;
DWORD Error = NO_ERROR;
DWORD Group = pWorkContext->Group;
BOOL bCreate;
PRAS_TABLE prt;
PRAS_TABLE_ENTRY prte;
PGROUP_TABLE_ENTRY pge;
PGI_ENTRY pgie; //group interface entry
enum {
NO_LOCK=0x0,
IF_LOCK=0x1,
RAS_LOCK=0x2,
GROUP_LOCK=0x4,
TIMER_LOCK=0x8
} ExitLockRelease;
ExitLockRelease = NO_LOCK;
//todo: remove the read lock get/release
//used only for DELETE_MEMBERSHIP
#define RETURN_FROM_TIMER_PROCESSING() {\
IGMP_FREE(pvContext); \
if (ExitLockRelease&IF_LOCK) \
RELEASE_IF_LOCK_SHARED(IfIndex, "_WF_TimerProcessing"); \
if (ExitLockRelease&GROUP_LOCK) \
RELEASE_GROUP_LOCK(Group, "_WF_TimerProcessing"); \
if (ExitLockRelease&TIMER_LOCK) \
RELEASE_TIMER_LOCK("_WF_TimerProcessing"); \
Trace0(LEAVE1, "Leaving _WF_TimerProcessing()\n");\
LeaveIgmpWorker();\
return;\
}
if (!EnterIgmpWorker()) { return; }
Trace0(ENTER1, "Entering _WF_TimerProcessing");
// take shared interface lock
IfIndex = pWorkContext->IfIndex;
ACQUIRE_IF_LOCK_SHARED(IfIndex, "_WF_TimerProcessing");
ExitLockRelease |= IF_LOCK;
BEGIN_BREAKOUT_BLOCK1 {
//
// retrieve the interface
//
pite = GetIfByIndex(IfIndex);
if (pite == NULL) {
Trace1(IF, "_WF_TimerProcessing: interface %d not found", IfIndex);
Error = ERROR_CAN_NOT_COMPLETE;
GOTO_END_BLOCK1;
}
//
// exit quitely if the interface is not activated
//
if ( !(IS_IF_ACTIVATED(pite)) ) {
Trace1(ERR, "Trying to send packet on inactive interface(%d)",
pite->IfIndex);
Error = ERROR_CAN_NOT_COMPLETE;
GOTO_END_BLOCK1;
}
switch (pWorkContext->WorkType) {
//-----------------------------------------
// GENERAL QUERY
//-----------------------------------------
case MSG_GEN_QUERY:
{
Trace2(TIMER,
"Timer fired leads to General-query being sent on If(%0x)"
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group));
SEND_GEN_QUERY(pite);
break;
}
//-----------------------------------------
// GROUP SPECIFIC QUERY
//-----------------------------------------
case MSG_GROUP_QUERY_V2 :
{
Trace2(TIMER,
"Timer fired leads to group query being sent on If(%0x)"
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group)
);
SEND_GROUP_QUERY_V2(pite, pWorkContext->Group);
break;
}
//
// MEMBERSHIP TIMED OUT
//
case DELETE_MEMBERSHIP:
{
//
// Lock the group table bucket
//
ACQUIRE_GROUP_LOCK(Group, "_WF_TimerProcessing");
ExitLockRelease |= GROUP_LOCK;
//
// find the group entry. If entry not found then ignore the timer
//
pge = GetGroupFromGroupTable(Group, NULL, 0); //llCurTime not req
if (pge==NULL) {
RETURN_FROM_TIMER_PROCESSING();
}
//
// find the GI entry. If GI entry does not exist or has deletedFlag
// or is static group, then ignore the timer
//
pgie = GetGIFromGIList(pge, pite, pWorkContext->NHAddr, FALSE, NULL, 0);
if ( (pgie==NULL)||(pgie->bStaticGroup) ) {
RETURN_FROM_TIMER_PROCESSING();
}
// gi entry might be deleted here
if (pgie->Version==3 && pgie->FilterType==EXCLUSION) {
if (pgie->bStaticGroup) {
PLIST_ENTRY pHead, ple;
//
// remove all sources in exclusion list
//
pHead = &pgie->V3ExclusionList;
for (ple=pHead->Flink; ple!=pHead; ) {
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(ple, GI_SOURCE_ENTRY,
LinkSources);
ple = ple->Flink;
// dont have to call mgm as it will remain in -ve mfe
if (!pSourceEntry->bStaticSource) {
RemoveEntryList(&pSourceEntry->LinkSources);
IGMP_FREE(pSourceEntry);
}
}
break;
}
Trace2(TIMER,
"Timer fired leads to group filter mode change If(%0x) "
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group)
);
ChangeGroupFilterMode(pgie, INCLUSION);
}
else if (pgie->Version!=3) {
if (pgie->bStaticGroup)
break;
Trace2(TIMER,
"Timer fired leads to membership being timed out If(%0x) "
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group)
);
//
// finally delete the entry
//
Error = DeleteGIEntry(pgie, TRUE, TRUE); //updateStats, CallMgm
}
break;
} //end case:DELETE_MEMBERSHIP
//
// SOURCE TIMED OUT
//
case DELETE_SOURCE:
case MSG_SOURCES_QUERY:
case MSG_GROUP_QUERY_V3:
case SHIFT_TO_V3:
case MOVE_SOURCE_TO_EXCL:
{
PGI_SOURCE_ENTRY pSourceEntry;
if ((pWorkContext->WorkType)==DELETE_SOURCE){
Trace3(TIMER,
"Timer fired leads to membership being timed out If(%0x) "
"Group(%d.%d.%d.%d) Source(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group),
PRINT_IPADDR(pWorkContext->Source)
);
}
else if ((pWorkContext->WorkType)==MSG_SOURCES_QUERY){
Trace2(TIMER,
"Timer fired leads to sources specific msg being sent If(%0x) "
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group));
}
else if ((pWorkContext->WorkType)==MSG_GROUP_QUERY_V3){
Trace2(TIMER,
"Timer fired leads to group query being sent on If(%0x) "
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group)
);
}
else if ((pWorkContext->WorkType)==SHIFT_TO_V3){
Trace2(TIMER,
"Timer fired leads to group shifting to v3 mode If(%0x) "
"Group(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group)
);
}
else if (pWorkContext->WorkType==MOVE_SOURCE_TO_EXCL){
Trace3(TIMER,
"Timer fired leads to source shifting to exclList If(%0x) "
"Group(%d.%d.%d.%d) Source(%d.%d.%d.%d)",
pite->IfIndex, PRINT_IPADDR(pWorkContext->Group),
PRINT_IPADDR(pWorkContext->Source)
);
}
//
// Lock the group table bucket
//
ACQUIRE_GROUP_LOCK(Group, "_WF_TimerProcessing");
ExitLockRelease |= GROUP_LOCK;
//
// find the group entry. If entry not found then ignore the timer
//
pge = GetGroupFromGroupTable(Group, NULL, 0); //llCurTime not req
if (pge==NULL) {
RETURN_FROM_TIMER_PROCESSING();
}
//
// find the GI entry. If GI entry does not exist or has deletedFlag
// or is static group, then ignore the timer
//
pgie = GetGIFromGIList(pge, pite, pWorkContext->NHAddr, FALSE, NULL, 0);
if ( (pgie==NULL)||(pgie->bStaticGroup) ) {
RETURN_FROM_TIMER_PROCESSING();
}
ACQUIRE_TIMER_LOCK("_WF_Timer_Processing");
ExitLockRelease |= TIMER_LOCK;
//
// if changeSourceMode to excl, but filtertype is not excl
// then delete the source
//
if ( (pWorkContext->WorkType==MOVE_SOURCE_TO_EXCL)
&& (pgie->FilterType != EXCLUSION)
) {
pWorkContext->WorkType = DELETE_SOURCE;
Trace2(TIMER, "DeleteSource instead of moving to excl "
"Group(%d.%d.%d.%d) Source(%d.%d.%d.%d)",
PRINT_IPADDR(pWorkContext->Group),
PRINT_IPADDR(pWorkContext->Source)
);
}
if ((pWorkContext->WorkType)==DELETE_SOURCE){
//
// get the source entry from inclusion list
//
pSourceEntry = GetSourceEntry(pgie, pWorkContext->Source,
INCLUSION, NULL, 0, 0);
if (pSourceEntry==NULL) {
Trace1(TIMER, "Source %d.%d.%d.%d not found",
PRINT_IPADDR(pWorkContext->Source));
RETURN_FROM_TIMER_PROCESSING();
}
if (!pSourceEntry->bStaticSource) {
DeleteSourceEntry(pSourceEntry, TRUE); //process mgm
if (pgie->NumSources==0) {
DeleteGIEntry(pgie, TRUE, TRUE);
}
}
}
else if ((pWorkContext->WorkType)==MSG_SOURCES_QUERY) {
SEND_SOURCES_QUERY(pgie);
}
else if ((pWorkContext->WorkType)==MSG_GROUP_QUERY_V3) {
SendV3GroupQuery(pgie);
}
else if ((pWorkContext->WorkType)==SHIFT_TO_V3) {
// make sure that version has not changed
if (pgie->Version != 3 && IS_IF_VER3(pite)) {
// shift to v3 exclusion mode
// membership timer already running
pgie->Version = 3;
pgie->FilterType = EXCLUSION;
// dont have to join to mgm as already joined in v1,v2
}
}
else if (pWorkContext->WorkType==MOVE_SOURCE_TO_EXCL) {
pSourceEntry = GetSourceEntry(pgie, pWorkContext->Source,
INCLUSION, NULL, 0, 0);
if (pSourceEntry==NULL) {
Trace1(TIMER, "Source %d.%d.%d.%d not found",
PRINT_IPADDR(pWorkContext->Source));
RETURN_FROM_TIMER_PROCESSING();
}
if (pSourceEntry->bInclusionList==TRUE) {
if (pSourceEntry==NULL)
RETURN_FROM_TIMER_PROCESSING();
ChangeSourceFilterMode(pgie, pSourceEntry);
}
}
break;
} //end case:DELETE_SOURCE,MSG_SOURCES_QUERY
} //end switch There should not be any code between here and
//endBreakout block
} END_BREAKOUT_BLOCK1;
RETURN_FROM_TIMER_PROCESSING();
return;
} //end _WF_TimerProcessing
//------------------------------------------------------------------------------
// DeleteRasClient
//
// Takes the if_group list lock and deletes all the GI entries associated with
// the ras client.
// Then takes write lock on the ras table and decrements the refCount. The
// ras table and interface entries are deleted if the deleted flag is set on pite.
// also releases the ras client from MGM.
//
// Queued by:
// DisconnectRasClient(), DeActivateInterfaceComplete() for ras server
// Locks:
// Initially runs in IF_GROUP_LIST_LOCK
// then runs in exclusive ras table lock.
// assumes if exclusive lock
// May call: _CompleteIfDeletion()
//------------------------------------------------------------------------------
VOID
DeleteRasClient (
PRAS_TABLE_ENTRY prte
)
{
PLIST_ENTRY pHead, ple;
PGI_ENTRY pgie;
PIF_TABLE_ENTRY pite = prte->IfTableEntry;
PRAS_TABLE prt = prte->IfTableEntry->pRasTable;
DWORD Error = NO_ERROR, IfIndex=pite->IfIndex;
//
// take exclusive lock on the If_Group List and remove all timers
//
ACQUIRE_IF_GROUP_LIST_LOCK(IfIndex, "_WF_DeleteRasClient");
//
// Remove all timers associtated with that ras client's GI list
//
ACQUIRE_TIMER_LOCK("_WF_DeleteRasClient");
pHead = &prte->ListOfSameClientGroups;
DeleteAllTimers(pHead, RAS_CLIENT);
RELEASE_TIMER_LOCK("_WF_DeleteRasClient");
RELEASE_IF_GROUP_LIST_LOCK(IfIndex, "_WF_DeleteRasClient");
//
// revisit the list and delete all GI entries. Need to take
// exclusive lock on the group bucket before deleting the GI entry
// No need to lock the If-Group list as no one can access it anymore
//
for (ple=pHead->Flink; ple!=pHead; ) {
DWORD dwGroup;
pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameClientGroups);
ple=ple->Flink;
dwGroup = pgie->pGroupTableEntry->Group;
ACQUIRE_GROUP_LOCK(dwGroup, "_WF_DeleteRasClient");
DeleteGIEntryFromIf(pgie);
RELEASE_GROUP_LOCK(dwGroup, "_WF_DeleteRasClient");
}
//
// Take exclusive lock on the interface. If deleted flag set on interface
// and refcount==0 then delete the ras table and pite, else just decrement
// the refcount
//
// decrement Refcount
prt->RefCount --;
//
// if deleted flag set and Refcount ==0 then delete Ras server completely
//
if ( (pite->Status&IF_DELETED_FLAG) &&(prt->RefCount==0) ){
CompleteIfDeletion(pite);
}
IGMP_FREE(prte);
return;
} //end _WF_DeleteRasClient
//------------------------------------------------------------------------------
// _WF_CompleteIfDeactivateDelete
//
// Completes deactivation an activated interface.
//
// Locking:
// does not require any lock on IfTable, as it is already removed from
// global interface lists.
// takes lock on Sockets list, as socket is getting deactivated
// Calls:
// DeActivateInterfaceComplete(). That function will also call
// _CompleteIfDeletion if the delete flag is set.
// Called by:
// _DeleteIfEntry() after it has called _DeActivationDeregisterFromMgm
// _UnbindIfEntry() after it has called _DeActivateInterfaceInitial
// _DisableIfEntry() after it has called _DeActivateInterfaceInitial
//------------------------------------------------------------------------------
VOID
CompleteIfDeactivateDelete (
PIF_TABLE_ENTRY pite
)
{
DWORD IfIndex = pite->IfIndex;
Trace1(ENTER1, "Entering _WF_CompleteIfDeactivateDelete(%d)", IfIndex);
ACQUIRE_SOCKETS_LOCK_EXCLUSIVE("_WF_CompleteIfDeactivateDelete");
DeActivateInterfaceComplete(pite);
RELEASE_SOCKETS_LOCK_EXCLUSIVE("_WF_CompleteIfDeactivateDelete");
// dont have to call _CompleteIfDeletion as it will be called in
// DeactivateInterface() as the delete flag is set.
Trace1(LEAVE1, "Leaving _WF_CompleteIfDeactivateDelete(%d)", IfIndex);
return;
} //end _WF_CompleteIfDeactivateDelete
Reference in a new issue Copy permalink