able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ip/igmp/table.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2894 lines
90 KiB
C
Raw Permalink Blame History

//=============================================================================
// Copyright (c) 1997 Microsoft Corporation
// File: table.c
//
// Abstract:
// This module implements some of the routines associated with creating,
// initializing, deleting timers, GI entries, table entries etc
//
// Author: K.S.Lokesh (lokeshs@) 11-1-97
//
// Revision History:
//=============================================================================
#include "pchigmp.h"
#pragma hdrstop
//------------------------------------------------------------------------------
// _CreateIfSockets
//
// Creates the sockets.
// for proxy: a raw IPPROTO_IP socket so that igmp host functionality will
// take over for all groups added on that interface.
// for router: a raw IPPROTO_IGMP socket so that it receives all igmp packets
// A router never does Add Memberships
//
// Called by: _ActivateInterface()
// Locks: assumes exclusive lock on the interface, and socketsList
//------------------------------------------------------------------------------
DWORD
CreateIfSockets (
PIF_TABLE_ENTRY pite
)
{
DWORD Error = NO_ERROR, dwRetval, SockType;
DWORD IpAddr = pite->IpAddr;
DWORD IfIndex = pite->IfIndex;
SOCKADDR_IN saLocalIf;
BOOL bProxy = IS_PROTOCOL_TYPE_PROXY(pite);
PSOCKET_ENTRY pse = &pite->SocketEntry;
BEGIN_BREAKOUT_BLOCK1 {
//
// for proxy, create a IPPROTO_IP socket so that igmp host functionality
// takes over.
// for igmp router, create a raw IPPROTO_IGMP socket
//
SockType = (bProxy)? IPPROTO_IP : IPPROTO_IGMP;
//
// create input socket
//
pse->Socket = WSASocket(AF_INET, SOCK_RAW, SockType, NULL, 0, 0);
if (pse->Socket == INVALID_SOCKET) {
Error = WSAGetLastError();
Trace3(IF,
"error %d creating socket for interface %d (%d.%d.%d.%d)",
Error, IfIndex, PRINT_IPADDR(IpAddr));
Logerr1(CREATE_SOCKET_FAILED_2, "%I", IpAddr, Error);
GOTO_END_BLOCK1;
}
//
// bind socket to local interface. If I dont bind multicast may
// not work.
//
ZeroMemory(&saLocalIf, sizeof(saLocalIf));
saLocalIf.sin_family = PF_INET;
saLocalIf.sin_addr.s_addr = IpAddr;
saLocalIf.sin_port = 0; //port shouldnt matter
// bind the input socket
Error = bind(pse->Socket, (SOCKADDR FAR *)&saLocalIf, sizeof(SOCKADDR));
if (Error == SOCKET_ERROR) {
Error = WSAGetLastError();
Trace3(IF, "error %d binding on socket for interface %d (%d.%d.%d.%d)",
Error, IfIndex, PRINT_IPADDR(IpAddr));
Logerr1(BIND_FAILED, "%I", IpAddr, Error);
GOTO_END_BLOCK1;
}
//
// A proxy never sends/receives any packets. It is just expected to enable
// igmp host functionality to take over for the groups on which it joins.
//
//------------------------------
// if proxy then done
//------------------------------
if (bProxy)
GOTO_END_BLOCK1;
//------------------------------
// NOT PROXY INTERFACE
//------------------------------
if (!bProxy) {
// set ttl to 1: not required as it is set to 1 by default.
McastSetTtl(pse->Socket, 1);
//
// disable multicast packets from being loopedback.
// This may not work due to promiscuous mode,
// so you still have to check the input packets
//
{
BOOL bLoopBack = FALSE;
DWORD dwRetval;
dwRetval = setsockopt(pse->Socket, IPPROTO_IP, IP_MULTICAST_LOOP,
(char *)&bLoopBack, sizeof(BOOL));
if (dwRetval==SOCKET_ERROR) {
Trace2(ERR, "error %d disabling multicast loopBack on IfIndex %d",
WSAGetLastError(), IfIndex);
IgmpAssertOnError(FALSE);
}
}
//
// if RasServerInterface, then activate hdrInclude option so that I can
// send GenQuery to all RAS clients
//
if (IS_RAS_SERVER_IF(pite->IfType)) {
INT iSetHdrIncl = 1;
Error = setsockopt( pse->Socket, IPPROTO_IP, IP_HDRINCL,
(char *) &iSetHdrIncl, sizeof(INT));
if (Error!=NO_ERROR) {
Error = WSAGetLastError();
Trace2(ERR, "error %d unable to set IP_HDRINCL option on interface %d",
Error, IfIndex,);
IgmpAssertOnError(FALSE);
Logerr1(SET_HDRINCL_FAILED, "%I", pite->IpAddr, Error);
GOTO_END_BLOCK1;
}
}
else {
//
// set the interface on which multicasts must be sent
// set only for non rasserver (not internal) interfaces
//
dwRetval = setsockopt(pse->Socket, IPPROTO_IP, IP_MULTICAST_IF,
(PBYTE)&saLocalIf.sin_addr, sizeof(IN_ADDR));
if (dwRetval == SOCKET_ERROR) {
Error = WSAGetLastError();
Trace3(IF, "error %d setting interface %d (%d.%d.%d.%d) to send multicast",
Error, IfIndex, PRINT_IPADDR(pite->IpAddr));
Logerr1(SET_MCAST_IF_FAILED, "%I", pite->IpAddr, Error);
Error = SOCKET_ERROR;
GOTO_END_BLOCK1;
}
{
//
// set router alert option for packets sent. dont have to set it for
// RasServerInterface where I do hdrInclude.
//
u_char Router_alert[4] = {148, 4, 0, 0};
dwRetval = setsockopt(pse->Socket, IPPROTO_IP, IP_OPTIONS,
(void *)Router_alert, sizeof(Router_alert));
if (dwRetval!=0) {
dwRetval = WSAGetLastError();
Trace2(ERR,
"error %d unable to set router alert option on interface %d",
dwRetval, IfIndex
);
IgmpAssertOnError(FALSE);
Logerr1(SET_ROUTER_ALERT_FAILED, "%I", pite->IpAddr, dwRetval);
Error = dwRetval;
GOTO_END_BLOCK1;
}
}
}
//
// set the interface in promiscuous igmp multicast mode.
//
{
DWORD dwEnable = 1;
DWORD dwNum;
dwRetval = WSAIoctl(pse->Socket, SIO_RCVALL_IGMPMCAST, (char *)&dwEnable,
sizeof(dwEnable), NULL , 0, &dwNum, NULL, NULL);
if (dwRetval !=0) {
dwRetval = WSAGetLastError();
Trace2(IF, "error %d setting interface %d as promiscuous multicast",
dwRetval, IfIndex);
Logerr1(SET_ROUTER_ALERT_FAILED, "%I", pite->IpAddr, dwRetval);
Error = dwRetval;
GOTO_END_BLOCK1;
}
else {
Trace1(IF, "promiscuous igmp multicast enabled on If (%d)",
IfIndex);
}
}
//
// Router doesnt have to join any group as it is in promiscuous mode
//
//
// create entry in the SocketsEvents list
//
{
BOOLEAN bCreateNewEntry;
PLIST_ENTRY ple, pHead = &g_ListOfSocketEvents;
PSOCKET_EVENT_ENTRY psee;
bCreateNewEntry = TRUE;
//
// see if a new socket-event entry has to be created
//
if (g_pIfTable->NumInterfaces>NUM_SINGLE_SOCKET_EVENTS) {
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
psee = CONTAINING_RECORD(ple, SOCKET_EVENT_ENTRY,
LinkBySocketEvents);
if (psee->NumInterfaces < MAX_SOCKETS_PER_EVENT) {
bCreateNewEntry = FALSE;
break;
}
}
}
//
// create a new socket-event entry and insert in the list
// register the event entry with the wait thread
//
if (bCreateNewEntry) {
psee = IGMP_ALLOC(sizeof(SOCKET_EVENT_ENTRY),
0x80000,pite->IfIndex);
PROCESS_ALLOC_FAILURE2(psee,
"error %d allocating %d bytes for SocketEventEntry",
Error, sizeof(SOCKET_EVENT_ENTRY),
GOTO_END_BLOCK1);
InitializeListHead(&psee->ListOfInterfaces);
psee->NumInterfaces = 0;
InsertHeadList(pHead, &psee->LinkBySocketEvents);
psee->InputEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
if (psee->InputEvent == NULL) {
Error = GetLastError();
Trace1(ERR,
"error %d creating InputEvent in CreateIfSockets",
Error);
IgmpAssertOnError(FALSE);
Logerr0(CREATE_EVENT_FAILED, Error);
GOTO_END_BLOCK1;
}
if (! RegisterWaitForSingleObject(
&psee->InputWaitEvent,
psee->InputEvent,
WT_ProcessInputEvent, psee,
INFINITE,
(WT_EXECUTEINWAITTHREAD)|(WT_EXECUTEONLYONCE)
))
{
Error = GetLastError();
Trace1(ERR, "error %d RegisterWaitForSingleObject", Error);
IgmpAssertOnError(FALSE);
GOTO_END_BLOCK1;
}
}
//
// put the socketEntry in the list
//
InsertTailList(&psee->ListOfInterfaces, &pse->LinkByInterfaces);
pse->pSocketEventsEntry = psee;
//
// if the socket-event entry cannot take any more sockets,
// then put it at end of list
//
if (++psee->NumInterfaces==MAX_SOCKETS_PER_EVENT) {
RemoveEntryList(&psee->LinkBySocketEvents);
InsertTailList(pHead, &psee->LinkBySocketEvents);
}
} //end:create entry in the sockets list
//
// create socket for static joins.
//
{
pite->StaticGroupSocket =
WSASocket(AF_INET, SOCK_RAW, IPPROTO_IP, NULL, 0, 0);
if (pite->StaticGroupSocket == INVALID_SOCKET) {
Error = WSAGetLastError();
Trace3(IF,
"error %d creating static group socket for interface "
"%d (%d.%d.%d.%d)",
Error, pite->IfIndex, PRINT_IPADDR(pite->IpAddr));
Logerr1(CREATE_SOCKET_FAILED_2, "%I", pite->IpAddr, Error);
GOTO_END_BLOCK1;
}
//
// bind socket to local interface. If I dont bind multicast may
// not work.
//
saLocalIf.sin_family = PF_INET;
saLocalIf.sin_addr.s_addr = pite->IpAddr;
saLocalIf.sin_port = 0; //port shouldnt matter
Error = bind(pite->StaticGroupSocket, (SOCKADDR FAR *)&saLocalIf,
sizeof(SOCKADDR));
}
} // end: not proxy interface
} END_BREAKOUT_BLOCK1;
if (Error!=NO_ERROR)
DeleteIfSockets(pite);
return Error;
} //end _CreateIfSockets
//------------------------------------------------------------------------------
// _DeleteIfSockets
//
// Called by: _DeActivateInterfaceComplete()
//------------------------------------------------------------------------------
VOID
DeleteIfSockets (
PIF_TABLE_ENTRY pite
)
{
PSOCKET_ENTRY pse = &pite->SocketEntry;
PSOCKET_EVENT_ENTRY psee = pse->pSocketEventsEntry;
BOOL bProxy = IS_PROTOCOL_TYPE_PROXY(pite);
// close input socket
if (pse->Socket!=INVALID_SOCKET) {
if (closesocket(pse->Socket) == SOCKET_ERROR) {
Trace1(IF, "error %d closing socket", WSAGetLastError());
}
pse->Socket = INVALID_SOCKET;
}
//
// if router interface. delete socket from socketEventList
// and free the socketEventEntry only if they were initialized.
//
if ((!bProxy)&&(pse->pSocketEventsEntry!=NULL)) {
PSOCKET_EVENT_ENTRY psee = pse->pSocketEventsEntry;
RemoveEntryList(&pse->LinkByInterfaces);
if (--psee->NumInterfaces==0) {
if (psee->InputWaitEvent) {
HANDLE WaitHandle ;
WaitHandle = InterlockedExchangePointer(&psee->InputWaitEvent, NULL);
if (WaitHandle)
UnregisterWaitEx( WaitHandle, NULL ) ;
}
CloseHandle(psee->InputEvent);
RemoveEntryList(&psee->LinkBySocketEvents);
IGMP_FREE(psee);
}
if (pite->StaticGroupSocket!=INVALID_SOCKET) {
closesocket(pite->StaticGroupSocket);
pite->StaticGroupSocket = INVALID_SOCKET;
}
}
return;
}
//------------------------------------------------------------------------------
// _DeleteAllTimers
//
// Deletes all timers associated with a GI entry.
//
// Called by: _DeActivateInterfaceComplete()
// Locks: Assumes Timer lock and GroupBucket lock.
//------------------------------------------------------------------------------
VOID
DeleteAllTimers (
PLIST_ENTRY pHead,
DWORD bEntryType
)
{
PLIST_ENTRY ple;
PGI_ENTRY pgie;
Trace0(ENTER1, "entering _DeleteAllTimers()");
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pgie = (bEntryType==RAS_CLIENT)
? CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameClientGroups)
: CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameIfGroups);
if (IS_TIMER_ACTIVE(pgie->GroupMembershipTimer))
RemoveTimer(&pgie->GroupMembershipTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastMemQueryTimer))
RemoveTimer(&pgie->LastMemQueryTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastVer1ReportTimer))
RemoveTimer(&pgie->LastVer1ReportTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastVer2ReportTimer))
RemoveTimer(&pgie->LastVer2ReportTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->V3SourcesQueryTimer))
RemoveTimer(&pgie->V3SourcesQueryTimer, DBG_N);
// delete all sources timers
if (pgie->Version==3) {
PLIST_ENTRY pleSrc, pHeadSrc;
pHeadSrc = &pgie->V3InclusionListSorted;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; pleSrc=pleSrc->Flink){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSourcesInclListSorted);
if (IS_TIMER_ACTIVE(pSourceEntry->SourceExpTimer))
RemoveTimer(&pSourceEntry->SourceExpTimer, DBG_Y);
}
pHeadSrc = &pgie->V3ExclusionList;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; pleSrc=pleSrc->Flink){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSources);
if (IS_TIMER_ACTIVE(pSourceEntry->SourceExpTimer))
RemoveTimer(&pSourceEntry->SourceExpTimer, DBG_Y);
}
}
}
Trace0(LEAVE1, "Leaving _DeleteAllTimers()");
return;
}
//------------------------------------------------------------------------------
// _DeleteGIEntry
//
// Locks: Assumes lock on the group bucket. takes lock on IfGroup list.
// takes lock on groupList if group being deleted.
//------------------------------------------------------------------------------
DWORD
DeleteGIEntry (
PGI_ENTRY pgie, //group interface entry
BOOL bUpdateStats,
BOOL bCallMgm
)
{
PIF_TABLE_ENTRY pite = pgie->pIfTableEntry;
PRAS_TABLE_ENTRY prte = pgie->pRasTableEntry;
PGROUP_TABLE_ENTRY pge = pgie->pGroupTableEntry;
PGI_ENTRY pgieCur;
BOOL bRas = (prte!=NULL);
DWORD NHAddr;
DWORD dwRetval;
Trace0(ENTER1, "Entering _DeleteGIEntry()");
NHAddr = (bRas) ? prte->NHAddr : 0;
Trace4(GROUP, "Deleting group(%d.%d.%d.%d) on Interface(%d)(%d.%d.%d.%d) "
"NHAddr(%d.%d.%d.%d)",
PRINT_IPADDR(pge->Group), pite->IfIndex,
PRINT_IPADDR(pite->IpAddr), PRINT_IPADDR(NHAddr));
bCallMgm = bCallMgm && (CAN_ADD_GROUPS_TO_MGM(pite));
//
// exclusion mode. remove all exclusion entries
// dont have to call MGM as it still has to be excluded
//
if (pgie->Version==3) {
PLIST_ENTRY pleSrc, pHeadSrc;
pHeadSrc = &pgie->V3InclusionListSorted;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; ){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSources);
pleSrc=pleSrc->Flink;
DeleteSourceEntry(pSourceEntry, bCallMgm);
}
pHeadSrc = &pgie->V3ExclusionList;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; ){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSources);
pleSrc=pleSrc->Flink;
DeleteSourceEntry(pSourceEntry, bCallMgm);
}
}
//
// call mgm to remove this group
//
if ( bCallMgm ) {
if ( (pgie->Version==3 && pgie->FilterType==EXCLUSION)
|| pgie->Version!=3)
{
MGM_DELETE_GROUP_MEMBERSHIP_ENTRY(pite, NHAddr,
0, 0,
pge->Group, 0xffffffff, MGM_JOIN_STATE_FLAG);
}
}
//
// remove all timers
//
ACQUIRE_TIMER_LOCK("_DeleteGIEntry");
if (IS_TIMER_ACTIVE(pgie->GroupMembershipTimer))
RemoveTimer(&pgie->GroupMembershipTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastMemQueryTimer))
RemoveTimer(&pgie->LastMemQueryTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastVer1ReportTimer))
RemoveTimer(&pgie->LastVer1ReportTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->LastVer2ReportTimer))
RemoveTimer(&pgie->LastVer2ReportTimer, DBG_N);
if (IS_TIMER_ACTIVE(pgie->V3SourcesQueryTimer))
RemoveTimer(&pgie->V3SourcesQueryTimer, DBG_Y);
RELEASE_TIMER_LOCK("_DeleteGIEntry");
//
// Remove from IfGroupList. needs lock on IfGroupList
//
ACQUIRE_IF_GROUP_LIST_LOCK(pite->IfIndex, "_DeleteGIEntry");
// if interface being deleted, then return from here
if (IS_IF_DELETED(pgie->pIfTableEntry)) {
RELEASE_IF_GROUP_LIST_LOCK(pite->IfIndex, "_DeleteGIEntry");
return NO_ERROR;
}
// remove GI entry from group's GI list
RemoveEntryList(&pgie->LinkByGI);
//
// remove entry from interface list
//
RemoveEntryList(&pgie->LinkBySameIfGroups);
if (bRas)
RemoveEntryList(&pgie->LinkBySameClientGroups);
RELEASE_IF_GROUP_LIST_LOCK(pite->IfIndex, "_DeleteGIEntry");
//
// decrement the number of virtual interfaces. I have to do
// interlocked decrement as I dont take group_list lock
//
InterlockedDecrement(&pge->NumVifs);
//
// if group has no more interfaces hanging from it, then delete it
// and update statistics
//
if (IsListEmpty(&pge->ListOfGIs)) {
// take groupList lock before deleting it from the group list
ACQUIRE_GROUP_LIST_LOCK("_DeleteGIEntry");
RemoveEntryList(&pge->LinkByGroup);
RELEASE_GROUP_LIST_LOCK("_DeleteGIEntry");
// remove group entry from the group hash table
RemoveEntryList(&pge->HTLinkByGroup);
IGMP_FREE(pge);
pge = NULL;
//global stats (has to be updated even if bUpdateStats==FALSE)
InterlockedDecrement(&g_Info.CurrentGroupMemberships);
#if DBG
DebugPrintGroupsList(1);
#endif
}
//
// update statistics
//
if (bUpdateStats) {
//
// ras interface statistics (decrement only if last GI for ras)
//
if (bRas) {
// see if GI entry exists for that ras client. very inefficient
if (pge!=NULL) {
PLIST_ENTRY pHead, ple;
pHead = &pge->ListOfGIs;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pgieCur = CONTAINING_RECORD(ple, GI_ENTRY, LinkByGI);
if (pgieCur->IfIndex>=pite->IfIndex)
break;
}
if ( (ple==pHead)||(pgieCur->IfIndex!=pite->IfIndex) ) {
InterlockedDecrement(&pite->Info.CurrentGroupMemberships);
}
}
// last GI entry
else {
InterlockedDecrement(&pite->Info.CurrentGroupMemberships);
}
// update ras client stats
if (g_Config.RasClientStats) {
InterlockedDecrement(&prte->Info.CurrentGroupMemberships);
}
}
// not ras interace
else {
InterlockedDecrement(&pite->Info.CurrentGroupMemberships);
}
}
IGMP_FREE_NOT_NULL(pgie->V3InclusionList);
IGMP_FREE(pgie);
Trace0(LEAVE1, "Leaving _DeleteGIEntry");
return NO_ERROR;
}//end _DeleteGIEntry
//------------------------------------------------------------------------------
// _DeleteAllGIEntries
//
// Repeatedly calls _DeleteGIEntryFromIf() to delete each GI entry from the list.
// If there are a lot of GI entries, optimizes on the GroupBucket locks
// by grouping all GI entries hashing to the same bucket and then acquiring
// GroupBucket locks to delete them.
//
// Locks: interface_group_list lock not req. exclusive interface lock not req.
// as the interface has been removed from external lists.
// Calls: Repeatedly calls _DeleteGIEntryFromIf() to remove each GI entry
// Called by: _DeActivateInterfaceComplete()
//------------------------------------------------------------------------------
VOID
DeleteAllGIEntries(
PIF_TABLE_ENTRY pite
)
{
PLIST_ENTRY pHead, ple, pleOld;
PGI_ENTRY pgie;
DWORD dwGroup;
//
// concatenate ListOfSameIfGroupsNew at the end of ListOfSameIfGroups so
// that I have to delete only one list
//
CONCATENATE_LISTS(pite->ListOfSameIfGroups, pite->ListOfSameIfGroupsNew);
// if ras interface then return as list will be deleted through RAS clients
if (IS_RAS_SERVER_IF(pite->IfType))
return;
pHead = &pite->ListOfSameIfGroups;
if (IsListEmpty(pHead))
return;
//--------------------------------------------------------
// do optimization only if there are lots of GI entries
//--------------------------------------------------------
if (pite->Info.CurrentGroupMemberships > GROUP_HASH_TABLE_SZ*2) {
DWORD i;
LIST_ENTRY TmpGroupTable[GROUP_HASH_TABLE_SZ];
// initialize the temp group table
for (i=0; i<GROUP_HASH_TABLE_SZ; i++) {
InitializeListHead(&TmpGroupTable[i]);
}
// move the GI entries to the temp group table using LinkBySameIfGroups
// LinkBySameIfGroups is not used anymore
pHead = &pite->ListOfSameIfGroups;
for (ple=pHead->Flink; ple!=pHead; ) {
// remove from old list
pleOld = ple;
ple = ple->Flink;
RemoveEntryList(pleOld);
pgie = CONTAINING_RECORD(pleOld, GI_ENTRY, LinkBySameIfGroups);
dwGroup = pgie->pGroupTableEntry->Group;
// put in appropriate bucket
InsertHeadList(&TmpGroupTable[GROUP_HASH_VALUE(dwGroup)],
&pgie->LinkBySameIfGroups);
}
//
// now delete GI entries going by all groups which hash to same bucket
//
for (i=0; i<GROUP_HASH_TABLE_SZ; i++) {
if (IsListEmpty(&TmpGroupTable[i]))
continue;
//
// LOCK GROUP BUCKET (done use ACQUIRE_GROUP_LOCK macros)
//
ACQUIRE_GROUP_LOCK(i, "_DeleteAllGIEntries");
pHead = &TmpGroupTable[i];
// delete all GI entries that hash to that bucket
for (ple=pHead->Flink; ple!=pHead; ) {
pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameIfGroups);
ple=ple->Flink;
//
// remove the entry from the group's GI list and update
// statistics. If group's GI list becomes empty, removes group
//
DeleteGIEntryFromIf(pgie);
}
RELEASE_GROUP_LOCK(i, "_DeleteAllGIEntries");
}
InitializeListHead(&pite->ListOfSameIfGroups);
return;
}
//-----------------------------------------------------------
// NO OPTIMIZATION
//-----------------------------------------------------------
pHead = &pite->ListOfSameIfGroups;
//
// delete all GI entries hanging from that interface.
//
for (ple=pHead->Flink; ple!=pHead; ) {
pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameIfGroups);
ple=ple->Flink;
dwGroup = pgie->pGroupTableEntry->Group;
// LOCK GROUP BUCKET
ACQUIRE_GROUP_LOCK(dwGroup,
"_DeActivateInterfaceComplete");
DeleteGIEntryFromIf(pgie);
RELEASE_GROUP_LOCK(dwGroup, "_DeActivateInterfaceComplete");
}
InitializeListHead(&pite->ListOfSameIfGroups);
return;
}
//------------------------------------------------------------------------------
// _DeleteGIEntryFromIf
//
// Called to delete a GI entry when an interface/RAS client is being deleted.
// The GI entries cannot be accessed from anywhere except through enumeration of
// group list.
//
// Locks: Assumes lock on the group bucket. lock on IfGroup list not req.
// Called by: _DeleteAllGIEntries() which in turn called by
// _DeActivateInterfaceComplete().
//------------------------------------------------------------------------------
VOID
DeleteGIEntryFromIf (
PGI_ENTRY pgie //group interface entry
)
{
PIF_TABLE_ENTRY pite = pgie->pIfTableEntry;
PGROUP_TABLE_ENTRY pge = pgie->pGroupTableEntry;
PLIST_ENTRY pHead, ple;
DWORD IfIndex = pite->IfIndex;
Trace1(ENTER1, "Entering _DeleteGIEntryFromIf(): IfIndex(%0x)", IfIndex);
//
// delete sources
//
if (pgie->Version==3) {
PLIST_ENTRY pleSrc, pHeadSrc;
pHeadSrc = &pgie->V3InclusionListSorted;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; ){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSourcesInclListSorted);
pleSrc=pleSrc->Flink;
IGMP_FREE(pSourceEntry);
}
pHeadSrc = &pgie->V3ExclusionList;
for (pleSrc=pHeadSrc->Flink; pleSrc!=pHeadSrc; ){
PGI_SOURCE_ENTRY pSourceEntry;
pSourceEntry = CONTAINING_RECORD(pleSrc, GI_SOURCE_ENTRY, LinkSources);
pleSrc=pleSrc->Flink;
IGMP_FREE(pSourceEntry);
}
}
//
// Remove pgie from gi list. Dont have to remove from ListBySameIfGroups
//
RemoveEntryList(&pgie->LinkByGI);
InterlockedDecrement(&pge->NumVifs);
//
// if group has no more interfaces hanging from it, then delete it
// and update statistics
//
if (IsListEmpty(&pge->ListOfGIs)) {
// have to lock the group-list before deleting any group
ACQUIRE_GROUP_LIST_LOCK("_DeleteGIEntryFromIf");
RemoveEntryList(&pge->LinkByGroup);
RELEASE_GROUP_LIST_LOCK("_DeleteGIEntryFromIf");
RemoveEntryList(&pge->HTLinkByGroup);
IGMP_FREE(pge);
InterlockedDecrement(&g_Info.CurrentGroupMemberships);
}
IGMP_FREE_NOT_NULL(pgie->V3InclusionList);
IGMP_FREE(pgie);
Trace1(LEAVE1, "Leaving _DeleteGIEntryFromIf(%d)", IfIndex);
return;
}//end _DeleteGIEntryFromIf
//------------------------------------------------------------------------------
// DebugPrintIfConfig
//------------------------------------------------------------------------------
VOID
DebugPrintIfConfig (
PIGMP_MIB_IF_CONFIG pConfigExt,
DWORD IfIndex
)
{
DWORD i;
PCHAR StaticGroupStr[5];
BOOL bVersion3 = IS_CONFIG_IGMP_V3(pConfigExt);
Trace1(CONFIG, "Printing Config Info for interface(%0x)", IfIndex);
Trace1(CONFIG, "Version: 0x%0x", pConfigExt->Version);
Trace1(CONFIG, "IfType: %d", pConfigExt->IfType);
{
CHAR str[150];
strcpy(str, "");
if (pConfigExt->Flags&IGMP_INTERFACE_ENABLED_IN_CONFIG)
strcat(str, "IF_ENABLED ");
else
strcat(str, "IF_DISABLED ");
if (pConfigExt->Flags&IGMP_ACCEPT_RTRALERT_PACKETS_ONLY)
strcat(str, "RTRALERT_PACKETS_ONLY ");
Trace1(CONFIG, "Flags: %s", str);
}
Trace1(CONFIG, "IgmpProtocolType: %d", pConfigExt->IgmpProtocolType);
Trace1(CONFIG, "RobustnessVariable: %d", pConfigExt->RobustnessVariable);
Trace1(CONFIG, "StartupQueryInterval: %d",
pConfigExt->StartupQueryInterval);
Trace1(CONFIG, "StartupQueryCount : %d",
pConfigExt->StartupQueryCount);
Trace1(CONFIG, "GenQueryInterval: %d", pConfigExt->GenQueryInterval);
Trace1(CONFIG, "GenQueryMaxResponseTime: %d",
pConfigExt->GenQueryMaxResponseTime);
Trace1(CONFIG, "LastMemQueryInterval: %d (ms)",
pConfigExt->LastMemQueryInterval);
Trace1(CONFIG, "LastMemQueryCount: %d", pConfigExt->LastMemQueryCount);
Trace1(CONFIG, "OtherQuerierPresentInterval:%d",
pConfigExt->OtherQuerierPresentInterval);
Trace1(CONFIG, "GroupMembershipTimeout: %d",
pConfigExt->GroupMembershipTimeout);
if (pConfigExt->NumStaticGroups>0) {
PIGMP_STATIC_GROUP pStaticGroup;
PSTATIC_GROUP_V3 pStaticGroupV3;
Trace1(CONFIG, "NumStaticGroups: %d",
pConfigExt->NumStaticGroups);
pStaticGroup = GET_FIRST_IGMP_STATIC_GROUP(pConfigExt);
if (bVersion3) {
pStaticGroupV3 = GET_FIRST_STATIC_GROUP_V3(pConfigExt);
Trace0(CONFIG, " Group Mode(Host/MGM) Filter(In/Ex) "
"NumSources");
}
else
Trace0(CONFIG, " Group Mode(Host/MGM)");
for (i=0; i<pConfigExt->NumStaticGroups; i++){
if (bVersion3) {
DWORD j;
Trace5(CONFIG, "%d. %15s %d %d %d",
i+1, INET_NTOA(pStaticGroupV3->GroupAddr),
pStaticGroupV3->Mode, pStaticGroupV3->FilterType,
pStaticGroupV3->NumSources
);
for (j=0; j<pStaticGroupV3->NumSources; j++) {
Trace1(CONFIG, " %d.%d.%d.%d",
PRINT_IPADDR(pStaticGroupV3->Sources[j]));
}
pStaticGroupV3 = (PSTATIC_GROUP_V3)
GET_NEXT_STATIC_GROUP_V3(pStaticGroupV3);
}
else {
Trace3(CONFIG, "%d. %15s Mode:%d",
i+1, INET_NTOA(pStaticGroup->GroupAddr),
pStaticGroup->Mode
);
pStaticGroup++;
}
}
}
Trace0(CONFIG, "");
return;
}
//------------------------------------------------------------------------------
// CopyinIfConfigAndUpdate
//
// Copies the if config struct passed by mib to igmp and update the timers
// and does static joins if req.
// Called when the interface is activated
//------------------------------------------------------------------------------
DWORD
CopyinIfConfigAndUpdate (
PIF_TABLE_ENTRY pite,
PIGMP_MIB_IF_CONFIG pConfigExt,
ULONG IfIndex
)
{
PIGMP_IF_CONFIG pConfig = &pite->Config;
BOOL bGroupMembershipTimer=FALSE, bLastMemQueryTimer=FALSE;
ULONG NewStartupQueryInterval, NewGenQueryInterval,
NewGenQueryMaxResponseTime, NewLastMemQueryInterval,
NewOtherQuerierPresentInterval, NewGroupMembershipTimeout;
BOOL bFound;
DWORD Error=NO_ERROR;
DWORD bVer3=IS_CONFIG_IGMP_V3(pConfigExt);
NewStartupQueryInterval
= CONFIG_TO_INTERNAL_TIME(pConfigExt->StartupQueryInterval);
NewGenQueryInterval
= CONFIG_TO_INTERNAL_TIME(pConfigExt->GenQueryInterval);
NewGenQueryMaxResponseTime
= CONFIG_TO_INTERNAL_TIME(pConfigExt->GenQueryMaxResponseTime);
NewOtherQuerierPresentInterval
= CONFIG_TO_INTERNAL_TIME(pConfigExt->OtherQuerierPresentInterval);
NewLastMemQueryInterval = pConfigExt->LastMemQueryInterval; //already in ms
NewGroupMembershipTimeout
= CONFIG_TO_INTERNAL_TIME(pConfigExt->GroupMembershipTimeout);
//
// used only in ver3
//
pConfig->RobustnessVariableOld = pConfigExt->RobustnessVariable;
pConfig->GenQueryIntervalOld = NewGenQueryInterval;
pConfig->OtherQuerierPresentIntervalOld
= NewOtherQuerierPresentInterval;
pConfig->GroupMembershipTimeoutOld = NewGroupMembershipTimeout;
//
// update values only if it is ver1,ver2 or ver3&&Querier
//
if (!IS_IF_VER3(pite) || (IS_IF_VER3(pite) && IS_QUERIER(pite)) ){
ACQUIRE_TIMER_LOCK("_CopyinIfConfigAndUpdate");
//
// change Info.StartupQueryCountCurrent if it was set to some very high value.
// During startup, Info.StartupQueryCountCurrent is used, and not the Config value.
//
if (pConfigExt->StartupQueryCount < pite->Info.StartupQueryCountCurrent)
InterlockedExchange(&pite->Info.StartupQueryCountCurrent,
pConfigExt->StartupQueryCount);
// in startup mode. StartupQueryInterval active and to be reduced
if (pite->Info.StartupQueryCountCurrent>0) {
if ( (NewStartupQueryInterval < pConfig->StartupQueryInterval)
&& (IS_TIMER_ACTIVE(pite->QueryTimer)) )
{
UpdateLocalTimer(&pite->QueryTimer, NewStartupQueryInterval, DBG_Y);
}
}
// in querier mode. GenQueryInterval is active and to be updated
else {
if ( (NewGenQueryInterval < pConfig->GenQueryInterval)
&& (IS_TIMER_ACTIVE(pite->QueryTimer)) )
{
UpdateLocalTimer(&pite->QueryTimer, NewGenQueryInterval, DBG_Y);
}
}
// OtherQuerierPresentInterval active and to be updated
if ( (NewOtherQuerierPresentInterval<pConfig->OtherQuerierPresentInterval)
&& (IS_TIMER_ACTIVE(pite->NonQueryTimer)) )
{
UpdateLocalTimer(&pite->NonQueryTimer, NewOtherQuerierPresentInterval, DBG_Y);
}
// NewLastMemQueryInterval is to be processed only if in ver-2 mode and not
// server
if ( (pConfigExt->IgmpProtocolType==IGMP_ROUTER_V2)
&& (pite->IfType!=IGMP_IF_RAS_SERVER) )
{
if (NewLastMemQueryInterval < pConfig->LastMemQueryInterval)
bLastMemQueryTimer = TRUE;
}
// check if GroupMembership timeout is reduced
if (NewGroupMembershipTimeout < pConfig->GroupMembershipTimeout)
bGroupMembershipTimer = TRUE;
//
// Go through the GI list for that interface (all ras clients) and update
// their timers if they are higher
//
if ( ((bLastMemQueryTimer||bGroupMembershipTimer)&&(!IS_RAS_SERVER_IF(pite->IfType)))
|| ((bGroupMembershipTimer)&&(IS_RAS_SERVER_IF(pite->IfType))) )
{
PLIST_ENTRY pHead, ple;
PGI_ENTRY pgie;
LONGLONG llNewLastMemQueryInterval, llNewGroupMembershipTimeout;
LONGLONG llMaxTime, llCurTime = GetCurrentIgmpTime();
//
// get the absolute timeout values
//
llNewLastMemQueryInterval = llCurTime
+ CONFIG_TO_SYSTEM_TIME(NewLastMemQueryInterval);
llNewGroupMembershipTimeout = llCurTime
+ CONFIG_TO_SYSTEM_TIME(NewGroupMembershipTimeout);
// if not ras interface, then go through the list from interface
if ( !IS_RAS_SERVER_IF(pite->IfType)) {
// merge the IfGroup lists
MergeIfGroupsLists(pite);
pHead = &pite->ListOfSameIfGroups;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameIfGroups);
// update LastMemQueryTimer/V3SourcesQueryTimer if it is active and has a higher value
if (bLastMemQueryTimer && IS_TIMER_ACTIVE(pgie->LastMemQueryTimer)
&& (llNewLastMemQueryInterval<pgie->LastMemQueryTimer.Timeout))
{
UpdateLocalTimer(&pgie->LastMemQueryTimer,
NewLastMemQueryInterval, DBG_Y);
}
if (bLastMemQueryTimer && IS_TIMER_ACTIVE(pgie->V3SourcesQueryTimer)
&& (llNewLastMemQueryInterval<pgie->V3SourcesQueryTimer.Timeout))
{
UpdateLocalTimer(&pgie->V3SourcesQueryTimer,
NewLastMemQueryInterval, DBG_Y);
}
// update GroupMembershipTimeout if it is active and has a higher value
if (bGroupMembershipTimer
&& IS_TIMER_ACTIVE(pgie->GroupMembershipTimer)
&& (llNewGroupMembershipTimeout<pgie->GroupMembershipTimer.Timeout))
{
UpdateLocalTimer(&pgie->GroupMembershipTimer,
NewGroupMembershipTimeout, DBG_Y);
}
// update LastVer1ReportTimer/LastVer2ReportTimer if it is active and has a higher value
// LastVer1ReportTimeout is set to GroupMembershipTimeout
if (bGroupMembershipTimer
&& IS_TIMER_ACTIVE(pgie->LastVer1ReportTimer)
&& (llNewGroupMembershipTimeout<pgie->LastVer1ReportTimer.Timeout))
{
UpdateLocalTimer(&pgie->LastVer1ReportTimer,
NewGroupMembershipTimeout, DBG_Y);
}
if (bGroupMembershipTimer
&& IS_TIMER_ACTIVE(pgie->LastVer2ReportTimer)
&& (llNewGroupMembershipTimeout<pgie->LastVer2ReportTimer.Timeout))
{
UpdateLocalTimer(&pgie->LastVer2ReportTimer,
NewGroupMembershipTimeout, DBG_Y);
}
}
}
// IS_RAS_SERVER_IF: process for all clients. have to process
// GroupMembershipTimeout only
else {
PLIST_ENTRY pHeadClient, pleClient;
PRAS_TABLE_ENTRY prte;
PRAS_TABLE prt = pite->pRasTable;
//
// process GI list of each ras client
//
pHeadClient = &pite->pRasTable->ListByAddr;
for (pleClient=pHeadClient->Flink; pleClient!=pHeadClient;
pleClient=pleClient->Flink)
{
prte = CONTAINING_RECORD(pleClient, RAS_TABLE_ENTRY, LinkByAddr);
pHead = &prte->ListOfSameClientGroups;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pgie = CONTAINING_RECORD(ple, GI_ENTRY, LinkBySameClientGroups);
if (IS_TIMER_ACTIVE(pgie->GroupMembershipTimer)
&& (llNewGroupMembershipTimeout
<pgie->GroupMembershipTimer.Timeout))
{
UpdateLocalTimer(&pgie->GroupMembershipTimer,
NewGroupMembershipTimeout, DBG_Y);
}
}
}
}
}
RELEASE_TIMER_LOCK("_CopyinIfConfigAndUpdate");
//
// finally copy the new values
//
CopyMemory(pConfig, pConfigExt, sizeof(IGMP_MIB_IF_CONFIG));
pConfig->StartupQueryInterval = NewStartupQueryInterval;
pConfig->GenQueryInterval = NewGenQueryInterval;
pConfig->GenQueryMaxResponseTime = NewGenQueryMaxResponseTime;
pConfig->LastMemQueryInterval = NewLastMemQueryInterval;
pConfig->OtherQuerierPresentInterval = NewOtherQuerierPresentInterval;
pConfig->GroupMembershipTimeout = NewGroupMembershipTimeout;
pConfig->IfIndex = IfIndex;
}
pConfig->NumStaticGroups = 0;
return Error;
#if 0
{
PSTATIC_GROUP_V3 pStaticGroupExt;
PIF_STATIC_GROUP pStaticGroup;
PLIST_ENTRY ple, pHead;
DWORD i, GroupAddr;
SOCKADDR_IN saLocalIf;
//
// delete all static groups which are different in the old config
//
pHead = &pite->Config.ListOfStaticGroups;
for (ple=pHead->Flink; ple!=pHead; ) {
pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
GroupAddr = pStaticGroup->GroupAddr;
ple = ple->Flink;
bFound = FALSE;
pStaticGroupExt = GET_FIRST_STATIC_GROUP_V3(pConfigExt);
for (i=0; i<pConfigExt->NumStaticGroups; i++) {
if ( (GroupAddr == pStaticGroupExt->GroupAddr)
&& (pStaticGroup->Mode == pStaticGroupExt->Mode) )
{
bFound = TRUE;
break;
}
pStaticGroupExt = GET_NEXT_STATIC_GROUP_V3(pStaticGroupExt);
}
//
// group exists in old and new config. check for changes in sources.
//
if (bFound && bVer3) {
if (pStaticGroupExt->NumSources==0) {
//delete all static sources
}
if (pStaticGroupExt->NumSources==0 &&
pStaticGroupExt->FilterType!=EXCLUSION) {
// delete the static group
}
// check for differences in sources
}
// if old static group not found in new list, delete it
// Router
if (IS_CONFIG_IGMPRTR(pConfig)) {
if (pStaticGroup->Mode==IGMP_HOST_JOIN) {
LeaveMulticastGroup(pite->StaticGroupSocket, GroupAddr,
pite->IfIndex, pite->IpAddr, 0 );
}
else {
PGROUP_TABLE_ENTRY pge;
PGI_ENTRY pgie;
ACQUIRE_GROUP_LOCK(GroupAddr, "_CopyinIfConfigAndUpdate");
pge = GetGroupFromGroupTable(GroupAddr, NULL, 0);
pgie = GetGIFromGIList(pge, pite, 0, STATIC_GROUP, NULL, 0);
pgie->bStaticGroup = 0;
if (bVer3) {
PLIST_ENTRY pHead, ple;
PGI_SOURCE_ENTRY pSourceEntry;
//
// delete all static source entries
//
pHead = &pgie->V3ExclusionList;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pSourceEntry = CONTAINING_RECORD(ple, GI_SOURCE_ENTRY,LinkSources);
// delete source entry (forward the packets)
if (pSourceEntry->bStaticSource) {
DeleteSourceEntry(pSourceEntry, MGM_YES);
}
}
pHead = &pgie->V3InclusionListSorted;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pSourceEntry = CONTAINING_RECORD(ple, GI_SOURCE_ENTRY,LinkSourcesInclListSorted);
if (pSourceEntry->bStaticSource) {
pSourceEntry->bStaticSource = FALSE;
if (!IS_TIMER_ACTIVE(pSourceEntry->SourceExpTimer))
DeleteSourceEntry(pSourceEntry, MGM_YES);
}
}
}
else {
if (!(pgie->GroupMembershipTimer.Status&TIMER_STATUS_ACTIVE))
DeleteGIEntry(pgie, TRUE, TRUE);
}
RELEASE_GROUP_LOCK(GroupAddr, "_CopyinIfConfigAndUpdate");
}
}
// Proxy Interface
else {
if (bVer3){
for (i=0; i<pStaticGroup->NumSources; i++){
ProcessProxyGroupChange(pStaticGroup->Sources[i],
GroupAddr, DELETE_FLAG, STATIC_GROUP);
}
}
if (!bVer3 || pStaticGroup->NumSources==0)
ProcessProxyGroupChange(0,GroupAddr, DELETE_FLAG, STATIC_GROUP);
}
RemoveEntryList(&pStaticGroup->Link);
IGMP_FREE(pStaticGroup);
}
//
// for all new static groups, if not in old list, create it
//
pStaticGroupExt = GET_FIRST_STATIC_GROUP_V3(pConfigExt);
for (i=0; i<pConfigExt->NumStaticGroups; i++,pStaticGroupExt++) {
pHead = &pite->Config.ListOfStaticGroups;
bFound = FALSE;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
if (pStaticGroup->GroupAddr==pStaticGroupExt->GroupAddr) {
bFound = TRUE;
break;
}
}
// not found: create the new static group
if (!bFound) {
pStaticGroup = IGMP_ALLOC(
IGMP_MIB_STATIC_GROUP_SIZE(pConfigExt,
pStaticGroupExt), 0x100000,IfIndex);
PROCESS_ALLOC_FAILURE3(pStaticGroup,
"error %d allocating %d bytes for static group for IF:%0x",
Error, sizeof(IF_STATIC_GROUP), pite->IfIndex,
return Error);
memcpy(pStaticGroup, pStaticGroupExt,
IGMP_MIB_STATIC_GROUP_SIZE(pConfigExt, pStaticGroupExt));
InsertHeadList(&pConfig->ListOfStaticGroups, &pStaticGroup->Link);
if (IS_IF_ACTIVATED(pite)) {
// if proxy
if (IS_CONFIG_IGMPPROXY(pConfig)) {
if (pStaticGroup->NumSources==0)
ProcessProxyGroupChange(0, pStaticGroup->GroupAddr,
ADD_FLAG, STATIC_GROUP);
else {
for (i=0; i<pStaticGroup->NumSources; i++) {
ProcessProxyGroupChange(pStaticGroup->Sources[i],
pStaticGroup->GroupAddr,
ADD_FLAG, STATIC_GROUP);
}
}
}
// Add static group to Router
else {
if (pStaticGroup->Mode==IGMP_HOST_JOIN) {
if (!bVer3) {
JoinMulticastGroup(pite->StaticGroupSocket,
pStaticGroup->GroupAddr,
pite->IfIndex,
pite->IpAddr,
0
);
}
else {
// include filter
if (pStaticGroup->FilterType==INCLUSION) {
if (pStaticGroup->NumSources==0) {
JoinMulticastGroup(pite->StaticGroupSocket,
pStaticGroup->GroupAddr,
pite->IfIndex,
pite->IpAddr,
0
);
}
for (i=0; i<pStaticGroup->NumSources; i++) {
JoinMulticastGroup(pite->StaticGroupSocket,
pStaticGroup->GroupAddr,
pite->IfIndex,
pite->IpAddr,
pStaticGroup->Sources[i]
);
}
}
// exclude filter
else {
if (pStaticGroup->NumSources==0) {
JoinMulticastGroup(pite->StaticGroupSocket,
pStaticGroup->GroupAddr,
pite->IfIndex,
pite->IpAddr,
0
);
}
for (i=0; i<pStaticGroup->NumSources; i++) {
BlockSource(pite->StaticGroupSocket,
pStaticGroup->GroupAddr,
pite->IfIndex,
pite->IpAddr,
pStaticGroup->Sources[i]
);
}
}
}
}
// IGMPRTR_MGM_ONLY
else {
PGROUP_TABLE_ENTRY pge;
PGI_ENTRY pgie;
BOOL bCreate;
PGI_SOURCE_ENTRY pSourceEntry;
GroupAddr = pStaticGroup->GroupAddr;
ACQUIRE_GROUP_LOCK(GroupAddr,
"_CopyinIfConfigAndUpdate");
bCreate = TRUE;
pge = GetGroupFromGroupTable(GroupAddr, &bCreate, 0);
bCreate = TRUE;
pgie = GetGIFromGIList(pge, pite, 0,
(pStaticGroup->NumSources==0)
?STATIC_GROUP:NOT_STATIC_GROUP,
&bCreate, 0);
for (i=0; i<pStaticGroup->NumSources; i++) {
if (pStaticGroup->FilterType!=pgie->FilterType) {
pSourceEntry = GetSourceEntry(pgie,
pStaticGroup->Sources[i],
pStaticGroup->FilterType ^ 1,
NULL, 0, 0);
if (pSourceEntry) {
pSourceEntry->bStaticSource = TRUE;
ChangeSourceFilterMode(pgie,
pSourceEntry);
continue;
}
}
bCreate = TRUE;
pSourceEntry = GetSourceEntry(pgie,
pStaticGroup->Sources[i],
pStaticGroup->FilterType,
&bCreate, STATIC, MGM_YES);
}
RELEASE_GROUP_LOCK(GroupAddr,
"_CopyinIfConfigAndUpdate");
}
}
}
}
}
}
return Error;
#endif
} //end _CopyinIfConfigAndUpdate
//------------------------------------------------------------------------------
// _CopyinIfConfig
// Copies the if config struct passed by mib to igmp.
// called after the interface is in disabled state
//------------------------------------------------------------------------------
DWORD
CopyinIfConfig (
PIGMP_IF_CONFIG pConfig,
PIGMP_MIB_IF_CONFIG pConfigExt,
ULONG IfIndex
)
{
DWORD Error=NO_ERROR;
CopyMemory(pConfig, pConfigExt, sizeof(IGMP_MIB_IF_CONFIG));
CONV_CONFIG_TO_INTERNAL_TIME(pConfig->StartupQueryInterval);
CONV_CONFIG_TO_INTERNAL_TIME(pConfig->GenQueryInterval);
CONV_CONFIG_TO_INTERNAL_TIME(pConfig->GenQueryMaxResponseTime);
// already in ms
//CONV_CONFIG_TO_INTERNAL_TIME(pConfig->LastMemQueryInterval);
CONV_CONFIG_TO_INTERNAL_TIME(pConfig->OtherQuerierPresentInterval);
CONV_CONFIG_TO_INTERNAL_TIME(pConfig->GroupMembershipTimeout);
pConfig->RobustnessVariableOld = pConfig->RobustnessVariable;
pConfig->GenQueryIntervalOld = pConfig->GenQueryInterval;
pConfig->OtherQuerierPresentIntervalOld
= pConfig->OtherQuerierPresentInterval;
pConfig->GroupMembershipTimeoutOld = pConfig->GroupMembershipTimeout;
pConfig->ExtSize = IgmpMibIfConfigSize(pConfigExt);
pConfig->IfIndex = IfIndex ;
pConfig->NumStaticGroups = 0;
return Error;
#if 0
{
PIGMP_STATIC_GROUP pStaticGroupExt;
PSTATIC_GROUP_V3 pStaticGroupExtV3;
PIF_STATIC_GROUP pStaticGroup;
DWORD i;
PLIST_ENTRY ple;
BOOL bVersion3=IS_CONFIG_IGMP_V3(pConfigExt);
// delete all old static groups
for (ple=pConfig->ListOfStaticGroups.Flink;
ple!=&pConfig->ListOfStaticGroups; )
{
pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
ple = ple->Flink;
IGMP_FREE(pStaticGroup);
}
// copy all static groups
InitializeListHead(&pConfig->ListOfStaticGroups);
if (bVersion3)
pStaticGroupExtV3 = GET_FIRST_STATIC_GROUP_V3(pConfigExt);
else
pStaticGroupExt = GET_FIRST_IGMP_STATIC_GROUP(pConfigExt);
for (i=0; i<pConfig->NumStaticGroups; i++) {
DWORD Size = IGMP_MIB_STATIC_GROUP_SIZE(pConfigExt, pStaticGroupExtV3);
pStaticGroup = IGMP_ALLOC(Size, 0x200000,IfIndex);
PROCESS_ALLOC_FAILURE2(pStaticGroup,
"error %d allocating %d bytes for static group for IF:%0x",
Error, Size,return Error);
if (!bVersion3) {
pStaticGroup->GroupAddr = pStaticGroupExt->GroupAddr;
pStaticGroup->Mode = pStaticGroupExt->Mode;
pStaticGroupExt++;
}
else {
memcpy(pStaticGroup, pStaticGroupExtV3, Size);
pStaticGroupExtV3 = (PSTATIC_GROUP_V3)
((PCHAR)pStaticGroupExtV3 + Size);
}
InsertHeadList(&pConfig->ListOfStaticGroups, &pStaticGroup->Link);
}
}
#endif
}
//------------------------------------------------------------------------------
// _CopyoutIfConfig
//------------------------------------------------------------------------------
VOID
CopyoutIfConfig (
PIGMP_MIB_IF_CONFIG pConfigMib,
PIF_TABLE_ENTRY pite
)
{
PIGMP_IF_CONFIG pConfig = &pite->Config;
BOOL bVersion3 = IS_CONFIG_IGMP_V3(pConfig);
//
// the initial IGMP_MIB_IF_CONFIG size of struct is common
//
CopyMemory(pConfigMib, pConfig, sizeof(IGMP_MIB_IF_CONFIG));
CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->StartupQueryInterval);
CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->GenQueryInterval);
CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->GenQueryMaxResponseTime);
// keep in ms
//CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->LastMemQueryInterval);
CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->OtherQuerierPresentInterval);
CONV_INTERNAL_TO_CONFIG_TIME(pConfigMib->GroupMembershipTimeout);
pConfigMib->IfIndex = pite->IfIndex;
pConfigMib->IpAddr = pite->IpAddr;
// have to convert the Iftype to external type
pConfigMib->IfType = GET_EXTERNAL_IF_TYPE(pite);
{
PLIST_ENTRY pHead, ple;
PIGMP_STATIC_GROUP pStaticGroupExt;
PSTATIC_GROUP_V3 pStaticGroupExtV3;
PIF_STATIC_GROUP pStaticGroup;
if (bVersion3)
pStaticGroupExtV3 = GET_FIRST_STATIC_GROUP_V3(pConfigMib);
else
pStaticGroupExt = GET_FIRST_IGMP_STATIC_GROUP(pConfigMib);
pHead = &pConfig->ListOfStaticGroups;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pStaticGroup = CONTAINING_RECORD(ple, IF_STATIC_GROUP, Link);
if (bVersion3) {
memcpy(pStaticGroupExtV3,
(PCHAR)pStaticGroup+FIELD_OFFSET(IF_STATIC_GROUP,GroupAddr),
sizeof(STATIC_GROUP_V3)+pStaticGroup->NumSources*sizeof(IPADDR)
);
pStaticGroupExtV3 = GET_NEXT_STATIC_GROUP_V3(pStaticGroupExtV3);
}
else {
pStaticGroupExt->GroupAddr = pStaticGroup->GroupAddr;
pStaticGroupExt->Mode = pStaticGroup->Mode;
pStaticGroupExt++;
}
}
}
return;
}
//------------------------------------------------------------------------------
// _ValidateIfConfig
//
// Corrects some values, and returns error for some others.
// Return: ERROR_INVALID_DATA, NO_ERROR
//------------------------------------------------------------------------------
DWORD
ValidateIfConfig (
PIGMP_MIB_IF_CONFIG pConfigExt,
DWORD IfIndex,
DWORD IfType,
ULONG ulStructureVersion,
ULONG ulStructureSize
)
{
DWORD Error = NO_ERROR, i, Size;
BOOL bVersion3;
//
// verify config size
//
/*kslksl
if (ulStructureSize<sizeof(IGMP_MIB_IF_CONFIG)) {
Trace2(ERR, "IGMP config size %d very small. Expected:%d", ulStructureSize,
sizeof(IGMP_MIB_IF_CONFIG));
return ERROR_INVALID_DATA;
}
*/
bVersion3 = IS_IGMP_VERSION_3(pConfigExt->Version);
{
if (!bVersion3) {
Size = sizeof(IGMP_MIB_IF_CONFIG)
+ pConfigExt->NumStaticGroups*sizeof(IGMP_STATIC_GROUP);
}
else {
PSTATIC_GROUP_V3 pStaticGroupV3 = GET_FIRST_STATIC_GROUP_V3(pConfigExt);
Size = sizeof(IGMP_MIB_IF_CONFIG)
+sizeof(STATIC_GROUP_V3)*pConfigExt->NumStaticGroups;
for (i=0; i<pConfigExt->NumStaticGroups; i++) {
Size += pStaticGroupV3->NumSources*sizeof(IPADDR);
if (ulStructureSize<Size)
break;
pStaticGroupV3 = GET_NEXT_STATIC_GROUP_V3(pStaticGroupV3);
}
}
/*kslksl
if (ulStructureSize!=Size) {
Trace0(ERR, "Invalid IGMP structure size");
return ERROR_INVALID_DATA;
}
*/
}
// DebugPrintIfConfig
DebugPrintIfConfig(pConfigExt, IfIndex);
// check version
if (pConfigExt->Version >= IGMP_VERSION_3_5) {
Trace1(ERR, "Invalid version in interface config.\n"
"Create the Igmp configuration again", pConfigExt->Version);
IgmpAssertOnError(FALSE);
Logerr0(INVALID_VERSION, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
//
// check the proxy/router common fields, and then check the router fields
//
//
// check the protocolType
//
switch (pConfigExt->IgmpProtocolType) {
case IGMP_ROUTER_V1 :
case IGMP_ROUTER_V2 :
{
if ( (pConfigExt->Version<IGMP_VERSION_1_2)
||(pConfigExt->Version>=IGMP_VERSION_1_2_5) )
{
Trace1(ERR, "IGMP v1/v2 should have version %0x", IGMP_VERSION_1_2);
IgmpAssertOnError(FALSE);
return ERROR_INVALID_DATA;
}
break;
}
case IGMP_ROUTER_V3:
{
if (pConfigExt->Version<IGMP_VERSION_3 || pConfigExt->Version>=IGMP_VERSION_3_5) {
Trace1(ERR, "IGMP v3 should have version %0x", IGMP_VERSION_3);
IgmpAssertOnError(FALSE);
return ERROR_INVALID_DATA;
}
break;
}
case IGMP_PROXY :
case IGMP_PROXY_V3 :
break;
// if none of above, then return error
default : {
Trace2(ERR,
"Error: IGMP protocol type(%d) for interface(%0x) invalid",
pConfigExt->IgmpProtocolType, IfIndex);
IgmpAssertOnError(FALSE);
Logerr2(INVALID_PROTOTYPE, "%d%d", pConfigExt->IgmpProtocolType,
IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
}
// cannot configure a proxy on a ras server interface
if (IS_RAS_SERVER_IF(IfType) && IS_CONFIG_IGMPPROXY(pConfigExt)) {
Trace1(ERR,
"Error: Cannot configure Proxy on RAS server interface:%0x",
IfIndex);
IgmpAssertOnError(FALSE);
Logerr1(PROXY_ON_RAS_SERVER, "%d",IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
//
// check for static joins
//
if (pConfigExt->NumStaticGroups>0) {
DWORD i;
PIGMP_STATIC_GROUP pStaticGroup = GET_FIRST_IGMP_STATIC_GROUP(pConfigExt);
PSTATIC_GROUP_V3 pStaticGroupV3
= GET_FIRST_STATIC_GROUP_V3(pConfigExt);
for (i=0; i<pConfigExt->NumStaticGroups; i++) {
//
// make sure that the static group is a multicast address
//
if (!IS_MCAST_ADDR(pStaticGroup->GroupAddr)) {
Trace2(ERR,
"Error: Static group:%d.%d.%d.%d on IF:%0x not a multicast address",
PRINT_IPADDR(pStaticGroup->GroupAddr), IfIndex);
IgmpAssertOnError(FALSE);
Logerr2(INVALID_STATIC_GROUP, "%I%d", pStaticGroup->GroupAddr,
IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
//
// make sure that the mode of the static group is correct
//
if ( (pStaticGroup->Mode!=IGMP_HOST_JOIN
&& pStaticGroup->Mode!=IGMPRTR_JOIN_MGM_ONLY)
||(IS_CONFIG_IGMPPROXY(pConfigExt)
&& pStaticGroup->Mode!=IGMP_HOST_JOIN) )
{
Trace2(ERR,
"Error: Invalid mode for static group:%d.%d.%d.%d on IF:%0x",
PRINT_IPADDR(pStaticGroup->GroupAddr), IfIndex);
IgmpAssertOnError(FALSE);
Logerr2(INVALID_STATIC_MODE, "%I%d", pStaticGroup->GroupAddr,
IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
if (bVersion3) {
DWORD EntrySize = sizeof(STATIC_GROUP_V3)
+ pStaticGroupV3->NumSources*sizeof(IPADDR);
// check filter mode
if ( (pStaticGroupV3->FilterType!=INCLUSION)
&& (pStaticGroupV3->FilterType!=EXCLUSION))
{
Trace2(ERR,
"Error: Invalid filter type for static group:%d.%d.%d.%d on IF:%0x",
PRINT_IPADDR(pStaticGroup->GroupAddr), IfIndex);
IgmpAssertOnError(FALSE);
Logerr2(INVALID_STATIC_FILTER, "%I%d", pStaticGroup->GroupAddr,
IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
// not checking source addresses
pStaticGroupV3 = (PSTATIC_GROUP_V3)
((PCHAR)pStaticGroupV3 + EntrySize);
pStaticGroup = (PIGMP_STATIC_GROUP)pStaticGroupV3;
}
else {
pStaticGroup ++;
}
}
}
//
// if it is a proxy interface, then none of the config variables other than
// static group is used. I return no_error
//
if (IS_CONFIG_IGMPPROXY(pConfigExt))
return NO_ERROR;
// robustness variable must be greater than 0
if (pConfigExt->RobustnessVariable<=0) {
Trace1(ERR, "Error RobustnessVariable for Interface(%d) cannot be 0.",
IfIndex);
Logerr2(INVALID_ROBUSTNESS, "%d%d", pConfigExt->RobustnessVariable,
IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
// if robustness variable == 1, then log a warning
if (pConfigExt->RobustnessVariable==1) {
Trace1(ERR,
"Warning: Robustness variable for interface (%d) being set to 1",
IfIndex);
Logwarn0(ROBUSTNESS_VARIABLE_EQUAL_1, NO_ERROR);
}
// if robustness variable > 7, then I correct it to 7 and log a warning
if (pConfigExt->RobustnessVariable>7) {
Trace2(ERR, "RobustnessVariable for Interface(%0x) too high(%d)."
"Being set to 7", IfIndex, pConfigExt->RobustnessVariable);
Logwarn2(INVALID_ROBUSTNESS, "%d%d", pConfigExt->RobustnessVariable,
IfIndex, NO_ERROR);
pConfigExt->RobustnessVariable = 7;
}
// default value of GenQueryInterval is 125 sec. I force a minimum
// value of 10 secs to prevent trashing the network.
// max of 31744 as possible by exp value
if (pConfigExt->GenQueryInterval<10) {
Trace2(ERR, "GetQueryInterval for Interface(%0x) too low(%d)."
"Being set to 10", IfIndex, pConfigExt->GenQueryInterval);
pConfigExt->GenQueryInterval = 10;
}
if (pConfigExt->GenQueryInterval>31744) {
Trace2(ERR, "GetQueryInterval for Interface(%0x) too high(%d)."
"Being set to 31744", IfIndex, pConfigExt->GenQueryInterval);
pConfigExt->GenQueryInterval = 31744;
}
//
// StartupQueryInterval: default is 1/4 of GenQueryInterval
// I enforce a minimum of 1 sec and a max of GenQueryInterval
//
if (pConfigExt->StartupQueryInterval<1) {
Trace2(ERR, "StartupQueryInterval for Interface(%0x) too low(%d)."
"Being set to 1 sec", IfIndex, pConfigExt->StartupQueryInterval);
pConfigExt->StartupQueryInterval = 1;
}
if (pConfigExt->StartupQueryInterval>pConfigExt->GenQueryInterval) {
Trace3(ERR, "StartupQueryInterval(%d) for Interface(%0x) "
"higher than GenQueryInterval(%d). StartupQueryInterval set "
"to GenQueryInterval", pConfigExt->StartupQueryInterval, IfIndex,
pConfigExt->GenQueryInterval
);
pConfigExt->StartupQueryInterval = pConfigExt->GenQueryInterval;
}
//
// StartupQueryCount: default is Robustness variable
// I enforce a max of 7. (I am allowing someone to set it to 0??)
//
if (pConfigExt->StartupQueryCount>7) {
Trace2(ERR, "StartupQueryCount for IF(%0x) too high(%d). "
"Being set to 7.", IfIndex, pConfigExt->StartupQueryCount);
Logerr2(INVALID_STARTUPQUERYCOUNT, "%d%d",
pConfigExt->StartupQueryCount, IfIndex, ERROR_INVALID_DATA);
pConfigExt->StartupQueryCount = 7;
}
if ((int)pConfigExt->StartupQueryCount<0) {
Trace2(ERR,
"Error: StartupQueryCount(%d) for IF(%0x) cannot be < than 0.",
pConfigExt->StartupQueryCount, IfIndex);
Logerr2(INVALID_STARTUPQUERYCOUNT, "%d%d",
pConfigExt->StartupQueryCount, IfIndex, ERROR_INVALID_DATA);
return ERROR_INVALID_DATA;
}
//
// GenQueryMaxResponseTime: default is 10.
// Absurd if value is greater than GenQueryInterval.
// I correct the values, if required
//
if (pConfigExt->GenQueryMaxResponseTime > pConfigExt->GenQueryInterval) {
Trace3(ERR, "GenQueryMaxResponseTime(%d) for IF(%0x) "
"higher than GenQueryInterval(%d). GenQueryMaxResponseTime "
"set to GenQueryInterval", pConfigExt->GenQueryMaxResponseTime,
IfIndex, pConfigExt->GenQueryInterval);
pConfigExt->GenQueryMaxResponseTime = pConfigExt->GenQueryInterval;
}
if (pConfigExt->GenQueryMaxResponseTime > 3174) {
Trace2(ERR, "GenQueryMaxResponseTime(%d) for IF(%0x) "
"higher than 3174 "
"set to 1sec", pConfigExt->GenQueryMaxResponseTime,
IfIndex);
pConfigExt->GenQueryMaxResponseTime = 1;
}
if (pConfigExt->GenQueryMaxResponseTime <= 0) {
Trace2(ERR, "Error. GenQueryMaxResponseTime(%d) for Interface(%0x) "
"should be greater than 0.", pConfigExt->GenQueryMaxResponseTime,
IfIndex);
return ERROR_INVALID_DATA;
}
//
// check LastMemQueryCount and LastMemQueryInterval only if
// protocol type is not IGMP-Router-ver1 and it is not a ras server interface
//
if ( (pConfigExt->IgmpProtocolType!=IGMP_ROUTER_V1) && (!IS_RAS_SERVER_IF(IfType)) ) {
// LastMemQueryCount can be 0
// set max LastMemQueryCount to 7
if (pConfigExt->LastMemQueryCount>7) {
Trace2(ERR, "Warning. LastMemQueryCount(%d) for IF(%0x) "
"is too high. Resetting it to 10.", pConfigExt->LastMemQueryCount,
IfIndex);
pConfigExt->LastMemQueryCount = 10;
}
// limit LastMemQueryInterval(in ms) to GroupMembershipTimeout(in sec)
if (pConfigExt->LastMemQueryInterval>pConfigExt->GroupMembershipTimeout*1000) {
Trace3(ERR,
"Warning. LastMemberQueryInterval(%d) for IF(%0x) "
"is too high. Resetting it to GroupMembershipTimeout(%d ms).",
pConfigExt->LastMemQueryCount, IfIndex,
pConfigExt->GroupMembershipTimeout*1000
);
pConfigExt->LastMemQueryInterval = pConfigExt->GroupMembershipTimeout*1000;
}
// limit LastMemQueryInterval(in ms) to 3174(in sec)
if (pConfigExt->LastMemQueryInterval>3174*1000) {
Trace2(ERR,
"Warning. LastMemberQueryInterval(%d) for IF(%0x) "
"is too high. Resetting it to 1000ms).",
pConfigExt->LastMemQueryCount, IfIndex
);
pConfigExt->LastMemQueryInterval = 1000;
}
}
// check the value of OtherQuerierPresentInterval
if (pConfigExt->OtherQuerierPresentInterval !=
pConfigExt->RobustnessVariable*pConfigExt->GenQueryInterval
+ (pConfigExt->GenQueryMaxResponseTime)/2
)
{
pConfigExt->OtherQuerierPresentInterval =
pConfigExt->RobustnessVariable*pConfigExt->GenQueryInterval
+ (pConfigExt->GenQueryMaxResponseTime)/2;
Trace0(ERR, "Warning: OtherQuerierPresentInterval's value should be "
"RobustnessVariable*GenQueryInterval + (GenQueryMaxResponseTime)/2");
}
// check the value of GroupMembershipTimeout
if (pConfigExt->GroupMembershipTimeout !=
(pConfigExt->RobustnessVariable*pConfigExt->GenQueryInterval
+ pConfigExt->GenQueryMaxResponseTime) )
{
pConfigExt->GroupMembershipTimeout =
pConfigExt->RobustnessVariable*pConfigExt->GenQueryInterval
+ pConfigExt->GenQueryMaxResponseTime;
Trace0(ERR, "Warning: GroupMembershipTimeout's value should be "
"RobustnessVariable*GenQueryInterval + GenQueryMaxResponseTime");
}
return Error;
} // _ValidateIfConfig
//------------------------------------------------------------------------------
// InitializeIfTable
// Creates the Interface table. The interface table size is dynamic
//------------------------------------------------------------------------------
DWORD
InitializeIfTable(
)
{
DWORD Error = NO_ERROR;
PIGMP_IF_TABLE pTable;
DWORD NumBuckets, i;
BEGIN_BREAKOUT_BLOCK1 {
// set the initial size of the interface table to IF_HASHTABLE_SZ1
NumBuckets = IF_HASHTABLE_SZ1;
//
// allocate memory for the interface table
//
g_pIfTable = IGMP_ALLOC(sizeof(IGMP_IF_TABLE), 0x400000,0);
PROCESS_ALLOC_FAILURE2(g_pIfTable,
"error %d allocating %d bytes for interface table",
Error, sizeof(IGMP_IF_TABLE),
GOTO_END_BLOCK1);
pTable = g_pIfTable;
// initialize NumBuckets and NumInterfaces
pTable->NumBuckets = NumBuckets;
pTable->NumInterfaces = 0;
//
// Initialize the IfTable lists
//
InitializeListHead(&pTable->ListByIndex);
InitializeListHead(&pTable->ListByAddr);
//
// Initialize the list CS and proxyAlertCS
//
try {
InitializeCriticalSection(&pTable->IfLists_CS);
InitializeCriticalSection(&g_ProxyAlertCS);
}
except (EXCEPTION_EXECUTE_HANDLER) {
Error = GetExceptionCode();
Trace1(ANY,
"exception %d initializing critical section in InitIfTable",
Error);
Logerr0(INIT_CRITSEC_FAILED, Error);
GOTO_END_BLOCK1;
}
//
// allocate memory for the different buckets
//
pTable->HashTableByIndex = IGMP_ALLOC(sizeof(LIST_ENTRY)*NumBuckets,
0x800000,0);
PROCESS_ALLOC_FAILURE2(pTable->HashTableByIndex,
"error %d allocating %d bytes for interface table",
Error, sizeof(LIST_ENTRY)*NumBuckets,
GOTO_END_BLOCK1);
//
// allocate memory for the array of pointers to dynamic RWLs
//
pTable->aIfBucketDRWL
= IGMP_ALLOC(sizeof(PDYNAMIC_RW_LOCK)*NumBuckets, 0x800001,0);
PROCESS_ALLOC_FAILURE2(pTable->aIfBucketDRWL,
"error %d allocating %d bytes for interface table",
Error, sizeof(PDYNAMIC_RW_LOCK)*NumBuckets,
GOTO_END_BLOCK1);
//
// allocate memory for the array of pointers to dynamic CSs
//
pTable->aIfBucketDCS
= IGMP_ALLOC(sizeof(PDYNAMIC_CS_LOCK)*NumBuckets, 0x800002,0);
PROCESS_ALLOC_FAILURE2(pTable->aIfBucketDCS,
"error %d allocating %d bytes for interface table",
Error, sizeof(PDYNAMIC_CS_LOCK)*NumBuckets,
GOTO_END_BLOCK1);
//
// init locks to NULL, implying that the dynamic locks have not been
// allocated. and initialize the list heads.
//
for (i=0; i<NumBuckets; i++) {
InitializeListHead(&pTable->HashTableByIndex[i]);
pTable->aIfBucketDRWL[i] = NULL;
pTable->aIfBucketDCS[i] = NULL;
}
pTable->Status = 0;
} END_BREAKOUT_BLOCK1;
return Error;
} //end _InitializeIfTable
//------------------------------------------------------------------------------
// _DeInitializeIfTable
//------------------------------------------------------------------------------
VOID
DeInitializeIfTable(
)
{
PIGMP_IF_TABLE pTable = g_pIfTable;
PLIST_ENTRY pHead, ple;
PIF_TABLE_ENTRY pite;
DWORD i, dwRetval;
if (pTable==NULL)
return;
//
// for each active interface call deregister MGM.
//
// go through the list of active interfaces ordered by IpAddr
pHead = &g_pIfTable->ListByAddr;
for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) {
pite = CONTAINING_RECORD(ple, IF_TABLE_ENTRY, LinkByAddr);
// if not activated then continue
if (!IS_IF_ACTIVATED(pite))
continue;
// deregister all interfaces, ras clients and proxy protocol from mgm
DeActivationDeregisterFromMgm(pite);
}
// delete the IfLists CS
DeleteCriticalSection(&pTable->IfLists_CS);
IGMP_FREE_NOT_NULL(pTable->aIfBucketDCS);
IGMP_FREE_NOT_NULL(pTable->aIfBucketDRWL);
IGMP_FREE_NOT_NULL(pTable->HashTableByIndex);
IGMP_FREE_NOT_NULL(g_pIfTable);
// I dont delete the different dynamic locks. They should have been deleted
// by now
return;
}
//------------------------------------------------------------------------------
// _InitializeGroupTable //
//------------------------------------------------------------------------------
DWORD
InitializeGroupTable (
)
{
BOOL bErr = TRUE;
DWORD Error = NO_ERROR;
PGROUP_TABLE pGroupTable;
DWORD i;
BEGIN_BREAKOUT_BLOCK1 {
//
// allocate space for the group table
//
g_pGroupTable = IGMP_ALLOC(sizeof(GROUP_TABLE), 0x800004,0);
PROCESS_ALLOC_FAILURE2(g_pGroupTable,
"error %d allocating %d bytes for Group table",
Error, sizeof(GROUP_TABLE),
GOTO_END_BLOCK1);
pGroupTable = g_pGroupTable;
//
// initialize group tables' dynamically locked lists
//
for (i=0; i<GROUP_HASH_TABLE_SZ; i++) {
InitDynamicCSLockedList(&pGroupTable->HashTableByGroup[i]);
}
//
// initialize list of all groups
//
try {
CREATE_LOCKED_LIST(&pGroupTable->ListByGroup);
}
except (EXCEPTION_EXECUTE_HANDLER) {
Error = GetExceptionCode();
Trace1(ERR, "Exception %d creating locked list for Group Table",
Error);
Logerr0(INIT_CRITSEC_FAILED, Error);
GOTO_END_BLOCK1;
}
//
// initialize the list of new groups
//
InitializeListHead(&pGroupTable->ListByGroupNew);
pGroupTable->NumGroupsInNewList = 0;
pGroupTable->Status = 0;
bErr = FALSE;
} END_BREAKOUT_BLOCK1;
if (!bErr) {
return Error==NO_ERROR ? ERROR_CAN_NOT_COMPLETE: Error;
}
else {
return Error;
}
} //end _InitializeGroupTable
//------------------------------------------------------------------------------
// DeInitializeGroupTable //
// Just delete the critical sections //
//------------------------------------------------------------------------------
VOID
DeInitializeGroupTable (
)
{
PGROUP_TABLE pGroupTable = g_pGroupTable;
DWORD i;
if (pGroupTable==NULL)
return;
//
// I dont try to delete the dynamically allocated locks as they should
// have all been deleted by the last thread executing in that lock
//
DeleteCriticalSection(&pGroupTable->ListByGroup.Lock);
IGMP_FREE_NOT_NULL(pGroupTable);
}
//------------------------------------------------------------------------------
// _InitializeRasTable
// creates ras table and initializes the fields.
// called by _DeActivateInterfaceInitial() _AddIfEntry()
// The interface table is created during _AddIfEntry, as _ConnectRasClients can
// be called even when the ras server interface is not activated
//------------------------------------------------------------------------------
DWORD
InitializeRasTable(
DWORD IfIndex,
PIF_TABLE_ENTRY pite
)
{
DWORD Error = NO_ERROR, i;
PRAS_TABLE prt;
//
// allocate Ras table
//
prt = IGMP_ALLOC(sizeof(RAS_TABLE), 0x800008,IfIndex);
PROCESS_ALLOC_FAILURE2(prt, "error %d allocating %d bytes for Ras Table",
Error, sizeof(RAS_TABLE),
return Error);
//set the ras table entry in pite
pite->pRasTable = prt;
// initialize list pointing to Ras Clients ordered by IpAddr
InitializeListHead(&prt->ListByAddr);
// initialize hash table containing lists pointing to Ras Clients
// hashed on IpAddr
for (i=0; i<RAS_HASH_TABLE_SZ; i++)
InitializeListHead(&prt->HashTableByAddr[i]);
// set backpointer to the interface table entry
prt->pIfTable = pite;
// set RefCount and Status
prt->RefCount = 1;
prt->Status = IF_CREATED_FLAG;
return NO_ERROR;
} //end _InitializeRasTable
//todo:remove
//------------------------------------------------------------------------------
// DeInitializeRasTable
//------------------------------------------------------------------------------
VOID
DeInitializeRasTable (
PIF_TABLE_ENTRY pite,
BOOL bFullCleanup
)
{
PRAS_TABLE prt = pite->pRasTable;
PRAS_TABLE_ENTRY prte;
PLIST_ENTRY pHeadRas, pleRas;
pHeadRas = &prt->ListByAddr;
for (pleRas=pHeadRas->Flink; pleRas!=pHeadRas; pleRas=pleRas->Flink) {
prte = CONTAINING_RECORD(pleRas, RAS_TABLE_ENTRY, LinkByAddr);
MgmReleaseInterfaceOwnership(g_MgmIgmprtrHandle, pite->IfIndex,
prte->NHAddr);
}
return;
}
//------------------------------------------------------------------------------
// _MergeIfGroupsLists
//
// Merges the new GI list with the main GI list.
// Locks: Assumes the IF-GI list to be locked.
//------------------------------------------------------------------------------
VOID
MergeIfGroupsLists(
PIF_TABLE_ENTRY pite
)
{
// sentinel is set at the end of the Main list so that all entries is inserted
// before it. its group value is set to all 1's.
GROUP_TABLE_ENTRY pgeSentinel;
GI_ENTRY giSentinel;
PGI_ENTRY giNew, giMain;
PLIST_ENTRY pHeadNew, pHeadMain, pleMain, pleNew;
Trace1(ENTER1, "Entering _MergeIfGroupLists(): IfIndex:%0x", pite->IfIndex);
pHeadNew = &pite->ListOfSameIfGroupsNew;
pHeadMain = &pite->ListOfSameIfGroups;
//
// if main list is empty, then just move the new list to main list
// and I am done
//
if (IsListEmpty(pHeadMain)) {
// insert pHeadMain into new list
InsertHeadList(pHeadNew, pHeadMain);
// remove new list header
RemoveEntryList(pHeadNew);
InitializeListHead(pHeadNew);
return;
}
//
// insert the sentinel at the end of the main list
//
pgeSentinel.GroupLittleEndian = ~0;
giSentinel.pGroupTableEntry = &pgeSentinel;
InsertTailList(pHeadMain, &giSentinel.LinkBySameIfGroups);
pleMain = pHeadMain->Flink;
giMain = CONTAINING_RECORD(pleMain, GI_ENTRY, LinkBySameIfGroups);
// merge the lists by inserting the entries from new list into main list.
for (pleNew=pHeadNew->Flink; pleNew!=pHeadNew; ) {
giNew = CONTAINING_RECORD(pleNew, GI_ENTRY, LinkBySameIfGroups);
pleNew=pleNew->Flink;
while (giNew->pGroupTableEntry->GroupLittleEndian >
giMain->pGroupTableEntry->GroupLittleEndian)
{
pleMain = pleMain->Flink;
giMain = CONTAINING_RECORD(pleMain, GI_ENTRY, LinkBySameIfGroups);
}
InsertTailList(pleMain, &giNew->LinkBySameIfGroups);
}
//
// reinitialize the New list
//
pite->NumGIEntriesInNewList = 0;
InitializeListHead(&pite->ListOfSameIfGroupsNew);
// remove the sentinel entry from the main list
RemoveEntryList(&giSentinel.LinkBySameIfGroups);
//DebugPrintIfGroups(pite, 0); //deldel
Trace0(LEAVE1, "Leaving _MergeIfGroupsLists");
return;
} //end _MergeIfGroupsLists
//------------------------------------------------------------------------------
// _MergeProxyLists
//
// Merges the new GI list with the main GI list.
// Locks: Assumes the IF-GI list to be locked.
//------------------------------------------------------------------------------
VOID
MergeProxyLists(
PIF_TABLE_ENTRY pite
)
{
// sentinel is set at the end of the Main list so that all entries is inserted
// before it. its group value is set to all 1's.
PROXY_GROUP_ENTRY ProxySentinel, *pProxyNew, *pProxyMain;
PLIST_ENTRY pHeadNew, pHeadMain, pleMain, pleNew;
Trace1(ENTER1, "Entering MergeProxyLists(): IfIndex:%0x", pite->IfIndex);
pHeadNew = &pite->ListOfSameIfGroupsNew;
pHeadMain = &pite->ListOfSameIfGroups;
//
// if main list is empty, then just move the new list to main list
// and I am done
//
if (IsListEmpty(pHeadMain)) {
CONCATENATE_LISTS(pite->ListOfSameIfGroups, pite->ListOfSameIfGroupsNew);
pite->NumGIEntriesInNewList = 0;
return;
}
//
// insert the sentinel at the end of the main list
//
ProxySentinel.GroupLittleEndian = ~0;
InsertTailList(pHeadMain, &ProxySentinel.LinkBySameIfGroups);
pleMain = pHeadMain->Flink;
pProxyMain = CONTAINING_RECORD(pleMain, PROXY_GROUP_ENTRY,
LinkBySameIfGroups);
// merge the lists by inserting the entries from new list into main list.
for (pleNew=pHeadNew->Flink; pleNew!=pHeadNew; ) {
pProxyNew = CONTAINING_RECORD(pleNew, PROXY_GROUP_ENTRY,
LinkBySameIfGroups);
pleNew=pleNew->Flink;
while (pProxyNew->GroupLittleEndian > pProxyMain->GroupLittleEndian)
{
pleMain = pleMain->Flink;
pProxyMain = CONTAINING_RECORD(pleMain, PROXY_GROUP_ENTRY,
LinkBySameIfGroups);
}
InsertTailList(pleMain, &pProxyNew->LinkBySameIfGroups);
}
//
// reinitialize the New list
//
pite->NumGIEntriesInNewList = 0;
InitializeListHead(&pite->ListOfSameIfGroupsNew);
// remove the sentinel entry from the main list
RemoveEntryList(&ProxySentinel.LinkBySameIfGroups);
Trace0(LEAVE1, "Leaving _MergeProxyLists");
return;
} //end _MergeProxyLists
//------------------------------------------------------------------------------
// _MergeGroupLists
//
// Merges the new group list with the main group list.
//
// Locks: Assumes the group list to be locked.
// Called by: MibGetInternalGroupIfsInfo() or InsertInGroupsList()
//------------------------------------------------------------------------------
VOID
MergeGroupLists(
)
{
// sentinel is set at the end of the Main list so that all entries is inserted
// before it. its group value is set to all 1's.
GROUP_TABLE_ENTRY pgeSentinel;
PGROUP_TABLE_ENTRY pgeNew, pgeMain;
PLIST_ENTRY pHeadNew, pHeadMain, pleMain, pleNew;
Trace0(ENTER1, "Entering _MergeGroupLists()");
#if DBG
DebugPrintGroupsList(1);
#endif
pHeadNew = &g_pGroupTable->ListByGroupNew;
pHeadMain = &g_pGroupTable->ListByGroup.Link;
//
// if main list is empty, then just move the new list to main list
// and I am done
//
if (IsListEmpty(pHeadMain)) {
// insert pHeadMain into new list
InsertHeadList(pHeadNew, pHeadMain);
// remove new list header
RemoveEntryList(pHeadNew);
InitializeListHead(pHeadNew);
return;
}
//
// insert the sentinel at the end of the main list
//
pgeSentinel.GroupLittleEndian = ~0;
InsertTailList(pHeadMain, &pgeSentinel.LinkByGroup);
pleMain = pHeadMain->Flink;
pgeMain = CONTAINING_RECORD(pleMain, GROUP_TABLE_ENTRY, LinkByGroup);
// merge the lists by inserting the entries from new list into main list.
for (pleNew=pHeadNew->Flink; pleNew!=pHeadNew; ) {
pgeNew = CONTAINING_RECORD(pleNew, GROUP_TABLE_ENTRY, LinkByGroup);
pleNew=pleNew->Flink;
while (pgeNew->GroupLittleEndian > pgeMain->GroupLittleEndian) {
pleMain = pleMain->Flink;
pgeMain = CONTAINING_RECORD(pleMain, GROUP_TABLE_ENTRY,
LinkByGroup);
}
InsertTailList(pleMain, &pgeNew->LinkByGroup);
}
//
// reinitialize the New list
//
g_pGroupTable->NumGroupsInNewList = 0;
InitializeListHead(&g_pGroupTable->ListByGroupNew);
// remove the sentinel entry from the main list
RemoveEntryList(&pgeSentinel.LinkByGroup);
return;
} //end _MergeGroupLists
Reference in a new issue View git blame Copy permalink