#include <IGMPv2.h>

Inheritance diagram for inet::IGMPv2:

Classes
struct	HostGroupData

struct	HostInterfaceData

struct	IGMPHostTimerContext

struct	IGMPRouterTimerContext

struct	RouterGroupData

struct	RouterInterfaceData

Protected Types
enum	RouterState { IGMP_RS_INITIAL, IGMP_RS_QUERIER, IGMP_RS_NON_QUERIER }

enum	RouterGroupState { IGMP_RGS_NO_MEMBERS_PRESENT, IGMP_RGS_MEMBERS_PRESENT, IGMP_RGS_V1_MEMBERS_PRESENT, IGMP_RGS_CHECKING_MEMBERSHIP }

enum	HostGroupState { IGMP_HGS_NON_MEMBER, IGMP_HGS_DELAYING_MEMBER, IGMP_HGS_IDLE_MEMBER }

enum	IGMPTimerKind { IGMP_QUERY_TIMER, IGMP_HOSTGROUP_TIMER, IGMP_LEAVE_TIMER, IGMP_REXMT_TIMER }

typedef std::map< IPv4Address, HostGroupData * >	GroupToHostDataMap

typedef std::map< IPv4Address, RouterGroupData * >	GroupToRouterDataMap

typedef std::map< int, HostInterfaceData * >	InterfaceToHostDataMap

typedef std::map< int, RouterInterfaceData * >	InterfaceToRouterDataMap

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

virtual void	receiveSignal (cComponent source, simsignal_t signalID, cObject obj, cObject *details) override

virtual	~IGMPv2 ()

virtual HostInterfaceData *	createHostInterfaceData ()

virtual RouterInterfaceData *	createRouterInterfaceData ()

virtual HostGroupData *	createHostGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual RouterGroupData *	createRouterGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual HostInterfaceData *	getHostInterfaceData (InterfaceEntry *ie)

virtual RouterInterfaceData *	getRouterInterfaceData (InterfaceEntry *ie)

virtual HostGroupData *	getHostGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual RouterGroupData *	getRouterGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual void	deleteHostInterfaceData (int interfaceId)

virtual void	deleteRouterInterfaceData (int interfaceId)

virtual void	deleteHostGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual void	deleteRouterGroupData (InterfaceEntry *ie, const IPv4Address &group)

virtual void	configureInterface (InterfaceEntry *ie)

virtual void	multicastGroupJoined (InterfaceEntry *ie, const IPv4Address &groupAddr)

virtual void	multicastGroupLeft (InterfaceEntry *ie, const IPv4Address &groupAddr)

virtual void	startTimer (cMessage *timer, double interval)

virtual void	startHostTimer (InterfaceEntry ie, HostGroupData group, double maxRespTime)

virtual void	sendQuery (InterfaceEntry *ie, const IPv4Address &groupAddr, double maxRespTime)

virtual void	sendReport (InterfaceEntry ie, HostGroupData group)

virtual void	sendLeave (InterfaceEntry ie, HostGroupData group)

virtual void	sendToIP (IGMPMessage msg, InterfaceEntry ie, const IPv4Address &dest)

virtual void	processQueryTimer (cMessage *msg)

virtual void	processHostGroupTimer (cMessage *msg)

virtual void	processLeaveTimer (cMessage *msg)

virtual void	processRexmtTimer (cMessage *msg)

virtual void	processIgmpMessage (IGMPMessage *msg)

virtual void	processQuery (InterfaceEntry ie, const IPv4Address &sender, IGMPQuery msg)

virtual void	processGroupQuery (InterfaceEntry ie, HostGroupData group, int maxRespTime)

virtual void	processV2Report (InterfaceEntry ie, IGMPv2Report msg)

virtual void	processLeave (InterfaceEntry ie, IGMPv2Leave msg)

Protected Attributes
IIPv4RoutingTable *	rt

IInterfaceTable *	ift

bool	enabled

bool	externalRouter

int	robustness

double	queryInterval

double	queryResponseInterval

double	groupMembershipInterval

double	otherQuerierPresentInterval

double	startupQueryInterval

double	startupQueryCount

double	lastMemberQueryInterval

double	lastMemberQueryCount

double	unsolicitedReportInterval

InterfaceToHostDataMap	hostData

InterfaceToRouterDataMap	routerData

int	numGroups

int	numHostGroups

int	numRouterGroups

int	numQueriesSent

int	numQueriesRecv

int	numGeneralQueriesSent

int	numGeneralQueriesRecv

int	numGroupSpecificQueriesSent

int	numGroupSpecificQueriesRecv

int	numReportsSent

int	numReportsRecv

int	numLeavesSent

int	numLeavesRecv

Member Typedef Documentation

typedef std::map<IPv4Address, HostGroupData *> inet::IGMPv2::GroupToHostDataMap

protected

typedef std::map<IPv4Address, RouterGroupData *> inet::IGMPv2::GroupToRouterDataMap

protected

typedef std::map<int, HostInterfaceData *> inet::IGMPv2::InterfaceToHostDataMap

protected

typedef std::map<int, RouterInterfaceData *> inet::IGMPv2::InterfaceToRouterDataMap

protected

Member Enumeration Documentation

enum inet::IGMPv2::HostGroupState

protected

Enumerator
IGMP_HGS_NON_MEMBER
IGMP_HGS_DELAYING_MEMBER
IGMP_HGS_IDLE_MEMBER

                         {
         IGMP_HGS_NON_MEMBER,
         IGMP_HGS_DELAYING_MEMBER,
         IGMP_HGS_IDLE_MEMBER,
     };

enum inet::IGMPv2::IGMPTimerKind

protected

Enumerator
IGMP_QUERY_TIMER
IGMP_HOSTGROUP_TIMER
IGMP_LEAVE_TIMER
IGMP_REXMT_TIMER

                        {
         IGMP_QUERY_TIMER,
         IGMP_HOSTGROUP_TIMER,
         IGMP_LEAVE_TIMER,
         IGMP_REXMT_TIMER
     };

enum inet::IGMPv2::RouterGroupState

protected

Enumerator
IGMP_RGS_NO_MEMBERS_PRESENT
IGMP_RGS_MEMBERS_PRESENT
IGMP_RGS_V1_MEMBERS_PRESENT
IGMP_RGS_CHECKING_MEMBERSHIP

                           {
         IGMP_RGS_NO_MEMBERS_PRESENT,
         IGMP_RGS_MEMBERS_PRESENT,
         IGMP_RGS_V1_MEMBERS_PRESENT,
         IGMP_RGS_CHECKING_MEMBERSHIP,
     };

enum inet::IGMPv2::RouterState

protected

Enumerator
IGMP_RS_INITIAL
IGMP_RS_QUERIER
IGMP_RS_NON_QUERIER

                      {
         IGMP_RS_INITIAL,
         IGMP_RS_QUERIER,
         IGMP_RS_NON_QUERIER,
     };

Constructor & Destructor Documentation

inet::IGMPv2::~IGMPv2 ( )

protectedvirtual

 {
     while (!hostData.empty())
         deleteHostInterfaceData(hostData.begin()->first);
     while (!routerData.empty())
         deleteRouterInterfaceData(routerData.begin()->first);
 }

Member Function Documentation

void inet::IGMPv2::configureInterface ( InterfaceEntry * ie )

protectedvirtual

Referenced by initialize(), and receiveSignal().

 {
     if (enabled && rt->isMulticastForwardingEnabled() && !externalRouter) {
         // start querier on this interface
         cMessage *timer = new cMessage("IGMPv2 query timer", IGMP_QUERY_TIMER);
         timer->setContextPointer(ie);
         RouterInterfaceData *routerData = getRouterInterfaceData(ie);
         routerData->igmpQueryTimer = timer;
         routerData->igmpRouterState = IGMP_RS_QUERIER;
         sendQuery(ie, IPv4Address(), queryResponseInterval);    // general query
         startTimer(timer, startupQueryInterval);
     }
 }

IGMPv2::HostGroupData * inet::IGMPv2::createHostGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by multicastGroupJoined().

 {
     HostInterfaceData *interfaceData = getHostInterfaceData(ie);
     ASSERT(interfaceData->groups.find(group) == interfaceData->groups.end());
     HostGroupData *data = new HostGroupData(this, group);
     interfaceData->groups[group] = data;
     return data;
 }

IGMPv2::HostInterfaceData * inet::IGMPv2::createHostInterfaceData ( )

protectedvirtual

Referenced by getHostInterfaceData().

 {
     return new HostInterfaceData(this);
 }

IGMPv2::RouterGroupData * inet::IGMPv2::createRouterGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by processV2Report().

 {
     RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
     ASSERT(interfaceData->groups.find(group) == interfaceData->groups.end());
     RouterGroupData *data = new RouterGroupData(this, group);
     interfaceData->groups[group] = data;
     return data;
 }

IGMPv2::RouterInterfaceData * inet::IGMPv2::createRouterInterfaceData ( )

protectedvirtual

Referenced by getRouterInterfaceData().

 {
     return new RouterInterfaceData(this);
 }

void inet::IGMPv2::deleteHostGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by multicastGroupLeft().

 {
     HostInterfaceData *interfaceData = getHostInterfaceData(ie);
     auto it = interfaceData->groups.find(group);
     if (it != interfaceData->groups.end()) {
         HostGroupData *data = it->second;
         interfaceData->groups.erase(it);
         delete data;
     }
 }

void inet::IGMPv2::deleteHostInterfaceData ( int interfaceId )

protectedvirtual

Referenced by receiveSignal(), and ~IGMPv2().

 {
     auto interfaceIt = hostData.find(interfaceId);
     if (interfaceIt != hostData.end()) {
         HostInterfaceData *interface = interfaceIt->second;
         hostData.erase(interfaceIt);
         delete interface;
     }
 }

void inet::IGMPv2::deleteRouterGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by processLeaveTimer().

 {
     RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
     auto it = interfaceData->groups.find(group);
     if (it != interfaceData->groups.end()) {
         RouterGroupData *data = it->second;
         interfaceData->groups.erase(it);
         delete data;
     }
 }

void inet::IGMPv2::deleteRouterInterfaceData ( int interfaceId )

protectedvirtual

Referenced by receiveSignal(), and ~IGMPv2().

 {
     auto interfaceIt = routerData.find(interfaceId);
     if (interfaceIt != routerData.end()) {
         RouterInterfaceData *interface = interfaceIt->second;
         routerData.erase(interfaceIt);
         delete interface;
     }
 }

IGMPv2::HostGroupData * inet::IGMPv2::getHostGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by multicastGroupLeft(), and processV2Report().

 {
     HostInterfaceData *interfaceData = getHostInterfaceData(ie);
     auto it = interfaceData->groups.find(group);
     return it != interfaceData->groups.end() ? it->second : nullptr;
 }

IGMPv2::HostInterfaceData * inet::IGMPv2::getHostInterfaceData ( InterfaceEntry * ie )

protectedvirtual

Referenced by createHostGroupData(), deleteHostGroupData(), getHostGroupData(), and processQuery().

 {
     int interfaceId = ie->getInterfaceId();
     auto it = hostData.find(interfaceId);
     if (it != hostData.end())
         return it->second;
 
     // create one
     HostInterfaceData *data = createHostInterfaceData();
     hostData[interfaceId] = data;
     return data;
 }

IGMPv2::RouterGroupData * inet::IGMPv2::getRouterGroupData	(	InterfaceEntry *	ie,
		const IPv4Address &	group
	)

protectedvirtual

Referenced by processLeave(), processQuery(), and processV2Report().

 {
     RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
     auto it = interfaceData->groups.find(group);
     return it != interfaceData->groups.end() ? it->second : nullptr;
 }

IGMPv2::RouterInterfaceData * inet::IGMPv2::getRouterInterfaceData ( InterfaceEntry * ie )

protectedvirtual

Referenced by configureInterface(), createRouterGroupData(), deleteRouterGroupData(), getRouterGroupData(), processLeave(), processQuery(), processQueryTimer(), and sendQuery().

 {
     int interfaceId = ie->getInterfaceId();
     auto it = routerData.find(interfaceId);
     if (it != routerData.end())
         return it->second;
 
     // create one
     RouterInterfaceData *data = createRouterInterfaceData();
     routerData[interfaceId] = data;
     return data;
 }

void inet::IGMPv2::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (!enabled) {
         if (!msg->isSelfMessage()) {
             EV_ERROR << "IGMPv2 disabled, dropping packet.\n";
             delete msg;
         }
         return;
     }
 
     if (msg->isSelfMessage()) {
         switch (msg->getKind()) {
             case IGMP_QUERY_TIMER:
                 processQueryTimer(msg);
                 break;
 
             case IGMP_HOSTGROUP_TIMER:
                 processHostGroupTimer(msg);
                 break;
 
             case IGMP_LEAVE_TIMER:
                 processLeaveTimer(msg);
                 break;
 
             case IGMP_REXMT_TIMER:
                 processRexmtTimer(msg);
                 break;
 
             default:
                 ASSERT(false);
                 break;
         }
     }
     else if (!strcmp(msg->getArrivalGate()->getName(), "routerIn"))
         send(msg, "ipOut");
     else if (dynamic_cast<IGMPMessage *>(msg))
         processIgmpMessage((IGMPMessage *)msg);
     else
         ASSERT(false);
 }

void inet::IGMPv2::initialize ( int stage )

overrideprotectedvirtual

 {
     cSimpleModule::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
 
         cModule *host = getContainingNode(this);
         host->subscribe(NF_INTERFACE_DELETED, this);
         host->subscribe(NF_IPv4_MCAST_JOIN, this);
         host->subscribe(NF_IPv4_MCAST_LEAVE, this);
 
         enabled = par("enabled");
         externalRouter = gate("routerIn")->isPathOK() && gate("routerOut")->isPathOK();
         robustness = par("robustnessVariable");
         queryInterval = par("queryInterval");
         queryResponseInterval = par("queryResponseInterval");
         groupMembershipInterval = par("groupMembershipInterval");
         otherQuerierPresentInterval = par("otherQuerierPresentInterval");
         startupQueryInterval = par("startupQueryInterval");
         startupQueryCount = par("startupQueryCount");
         lastMemberQueryInterval = par("lastMemberQueryInterval");
         lastMemberQueryCount = par("lastMemberQueryCount");
         unsolicitedReportInterval = par("unsolicitedReportInterval");
         //version1RouterPresentInterval = par("version1RouterPresentInterval");
 
         numGroups = 0;
         numHostGroups = 0;
         numRouterGroups = 0;
 
         numQueriesSent = 0;
         numQueriesRecv = 0;
         numGeneralQueriesSent = 0;
         numGeneralQueriesRecv = 0;
         numGroupSpecificQueriesSent = 0;
         numGroupSpecificQueriesRecv = 0;
         numReportsSent = 0;
         numReportsRecv = 0;
         numLeavesSent = 0;
         numLeavesRecv = 0;
 
         WATCH(numGroups);
         WATCH(numHostGroups);
         WATCH(numRouterGroups);
 
         WATCH(numQueriesSent);
         WATCH(numQueriesRecv);
         WATCH(numGeneralQueriesSent);
         WATCH(numGeneralQueriesRecv);
         WATCH(numGroupSpecificQueriesSent);
         WATCH(numGroupSpecificQueriesRecv);
         WATCH(numReportsSent);
         WATCH(numReportsRecv);
         WATCH(numLeavesSent);
         WATCH(numLeavesRecv);
     }
     else if (stage == INITSTAGE_NETWORK_LAYER) {
         for (int i = 0; i < (int)ift->getNumInterfaces(); ++i) {
             InterfaceEntry *ie = ift->getInterface(i);
             if (ie->isMulticast())
                 configureInterface(ie);
         }
         cModule *host = getContainingNode(this);
         host->subscribe(NF_INTERFACE_CREATED, this);
     }
     else if (stage == INITSTAGE_NETWORK_LAYER_2) {
         IPSocket ipSocket(gate("ipOut"));
         ipSocket.registerProtocol(IP_PROT_IGMP);
     }
 }

void inet::IGMPv2::multicastGroupJoined	(	InterfaceEntry *	ie,
		const IPv4Address &	groupAddr
	)

protectedvirtual

Referenced by receiveSignal().

 {
     ASSERT(ie && ie->isMulticast());
     ASSERT(groupAddr.isMulticast());
 
     if (enabled && !groupAddr.isLinkLocalMulticast()) {
         HostGroupData *groupData = createHostGroupData(ie, groupAddr);
         numGroups++;
         numHostGroups++;
 
         sendReport(ie, groupData);
         groupData->flag = true;
         startHostTimer(ie, groupData, unsolicitedReportInterval);
         groupData->state = IGMP_HGS_DELAYING_MEMBER;
     }
 }

void inet::IGMPv2::multicastGroupLeft	(	InterfaceEntry *	ie,
		const IPv4Address &	groupAddr
	)

protectedvirtual

Referenced by receiveSignal().

 {
     ASSERT(ie && ie->isMulticast());
     ASSERT(groupAddr.isMulticast());
 
     if (enabled && !groupAddr.isLinkLocalMulticast()) {
         HostGroupData *groupData = getHostGroupData(ie, groupAddr);
         if (groupData) {
             if (groupData->state == IGMP_HGS_DELAYING_MEMBER)
                 cancelEvent(groupData->timer);
 
             if (groupData->flag)
                 sendLeave(ie, groupData);
         }
 
         deleteHostGroupData(ie, groupAddr);
         numHostGroups--;
         numGroups--;
     }
 }

virtual int inet::IGMPv2::numInitStages ( ) const

inlineoverrideprotectedvirtual

167 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::IGMPv2::processGroupQuery	(	InterfaceEntry *	ie,
		HostGroupData *	group,
		int	maxRespTime
	)

protectedvirtual

Referenced by processQuery().

 {
     double maxRespTimeSecs = (double)maxRespTime / 10.0;
 
     if (group->state == IGMP_HGS_DELAYING_MEMBER) {
         cMessage *timer = group->timer;
         simtime_t maxAbsoluteRespTime = simTime() + maxRespTimeSecs;
         if (timer->isScheduled() && maxAbsoluteRespTime < timer->getArrivalTime())
             startHostTimer(ie, group, maxRespTimeSecs);
     }
     else if (group->state == IGMP_HGS_IDLE_MEMBER) {
         startHostTimer(ie, group, maxRespTimeSecs);
         group->state = IGMP_HGS_DELAYING_MEMBER;
     }
     else {
         // ignored
     }
 }

void inet::IGMPv2::processHostGroupTimer ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     IGMPHostTimerContext *ctx = (IGMPHostTimerContext *)msg->getContextPointer();
     EV_DEBUG << "IGMPv2: Host Timer expired for group=" << ctx->hostGroup->groupAddr << " iface=" << ctx->ie->getName() << "\n";
     sendReport(ctx->ie, ctx->hostGroup);
     ctx->hostGroup->flag = true;
     ctx->hostGroup->state = IGMP_HGS_IDLE_MEMBER;
 }

void inet::IGMPv2::processIgmpMessage ( IGMPMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     IPv4ControlInfo *controlInfo = (IPv4ControlInfo *)msg->getControlInfo();
     InterfaceEntry *ie = ift->getInterfaceById(controlInfo->getInterfaceId());
     switch (msg->getType()) {
         case IGMP_MEMBERSHIP_QUERY:
             processQuery(ie, controlInfo->getSrcAddr(), check_and_cast<IGMPQuery *>(msg));
             break;
 
         //case IGMPV1_MEMBERSHIP_REPORT:
         //    processV1Report(ie, msg);
         //    delete msg;
         //    break;
         case IGMPV2_MEMBERSHIP_REPORT:
             processV2Report(ie, check_and_cast<IGMPv2Report *>(msg));
             break;
 
         case IGMPV2_LEAVE_GROUP:
             processLeave(ie, check_and_cast<IGMPv2Leave *>(msg));
             break;
 
         default:
             if (externalRouter)
                 send(msg, "routerOut");
             else {
                 //delete msg;
                 throw cRuntimeError("IGMPv2: Unhandled message type (%dq)", msg->getType());
             }
             break;
     }
 }

void inet::IGMPv2::processLeave	(	InterfaceEntry *	ie,
		IGMPv2Leave *	msg
	)

protectedvirtual

Referenced by processIgmpMessage().

 {
     ASSERT(ie->isMulticast());
 
     EV_INFO << "IGMPv2: received Leave Group for group=" << msg->getGroupAddress() << " iface=" << ie->getName() << "\n";
 
     numLeavesRecv++;
 
     if (rt->isMulticastForwardingEnabled()) {
         if (externalRouter) {
             send(msg, "routerOut");
             return;
         }
 
         IPv4Address& groupAddr = msg->getGroupAddress();
         RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
         RouterGroupData *groupData = getRouterGroupData(ie, groupAddr);
         if (groupData) {
             if (groupData->state == IGMP_RGS_MEMBERS_PRESENT && interfaceData->igmpRouterState == IGMP_RS_QUERIER) {
                 startTimer(groupData->timer, lastMemberQueryInterval * lastMemberQueryCount);
                 startTimer(groupData->rexmtTimer, lastMemberQueryInterval);
                 sendQuery(ie, groupAddr, lastMemberQueryInterval);
                 groupData->state = IGMP_RGS_CHECKING_MEMBERSHIP;
             }
         }
     }
 
     delete msg;
 }

void inet::IGMPv2::processLeaveTimer ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     IGMPRouterTimerContext *ctx = (IGMPRouterTimerContext *)msg->getContextPointer();
     EV_DEBUG << "IGMPv2: Leave Timer expired, deleting " << ctx->routerGroup->groupAddr << " from listener list of '" << ctx->ie->getName() << "'\n";
 
     // notify IPv4InterfaceData to update its listener list
     ctx->ie->ipv4Data()->removeMulticastListener(ctx->routerGroup->groupAddr);
     numRouterGroups--;
 
     if (ctx->routerGroup->state == IGMP_RGS_CHECKING_MEMBERSHIP)
         cancelEvent(ctx->routerGroup->rexmtTimer);
 
     ctx->routerGroup->state = IGMP_RGS_NO_MEMBERS_PRESENT;
     deleteRouterGroupData(ctx->ie, ctx->routerGroup->groupAddr);
     numGroups--;
 }

void inet::IGMPv2::processQuery	(	InterfaceEntry *	ie,
		const IPv4Address &	sender,
		IGMPQuery *	msg
	)

protectedvirtual

Referenced by processIgmpMessage().

 {
     ASSERT(ie->isMulticast());
 
     HostInterfaceData *interfaceData = getHostInterfaceData(ie);
 
     numQueriesRecv++;
 
     IPv4Address& groupAddr = msg->getGroupAddress();
     IGMPv2Query *v2Query = dynamic_cast<IGMPv2Query *>(msg);
     int maxRespTime = v2Query ? v2Query->getMaxRespTime() : 100;
 
     if (groupAddr.isUnspecified()) {
         // general query
         EV_INFO << "IGMPv2: received General Membership Query on iface=" << ie->getName() << "\n";
         numGeneralQueriesRecv++;
         for (auto & elem : interfaceData->groups)
             processGroupQuery(ie, elem.second, maxRespTime);
     }
     else {
         // group-specific query
         EV_INFO << "IGMPv2: received Membership Query for group=" << groupAddr << " iface=" << ie->getName() << "\n";
         numGroupSpecificQueriesRecv++;
         auto it = interfaceData->groups.find(groupAddr);
         if (it != interfaceData->groups.end())
             processGroupQuery(ie, it->second, maxRespTime);
     }
 
     if (rt->isMulticastForwardingEnabled()) {
         if (externalRouter) {
             send(msg, "routerOut");
             return;
         }
 
         RouterInterfaceData *routerInterfaceData = getRouterInterfaceData(ie);
         if (sender < ie->ipv4Data()->getIPAddress()) {
             startTimer(routerInterfaceData->igmpQueryTimer, otherQuerierPresentInterval);
             routerInterfaceData->igmpRouterState = IGMP_RS_NON_QUERIER;
         }
 
         if (!groupAddr.isUnspecified() && routerInterfaceData->igmpRouterState == IGMP_RS_NON_QUERIER) {    // group specific query
             RouterGroupData *groupData = getRouterGroupData(ie, groupAddr);
             if (groupData->state == IGMP_RGS_MEMBERS_PRESENT) {
                 double maxResponseTime = (double)maxRespTime / 10.0;
                 startTimer(groupData->timer, maxResponseTime * lastMemberQueryCount);
                 groupData->state = IGMP_RGS_CHECKING_MEMBERSHIP;
             }
         }
     }
 
     delete msg;
 }

void inet::IGMPv2::processQueryTimer ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     InterfaceEntry *ie = (InterfaceEntry *)msg->getContextPointer();
     ASSERT(ie);
     EV_DEBUG << "IGMPv2: General Query timer expired, iface=" << ie->getName() << "\n";
     RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
     RouterState state = interfaceData->igmpRouterState;
     if (state == IGMP_RS_QUERIER || state == IGMP_RS_NON_QUERIER) {
         interfaceData->igmpRouterState = IGMP_RS_QUERIER;
         sendQuery(ie, IPv4Address(), queryResponseInterval);    // general query
         startTimer(msg, queryInterval);
     }
 }

void inet::IGMPv2::processRexmtTimer ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     IGMPRouterTimerContext *ctx = (IGMPRouterTimerContext *)msg->getContextPointer();
     EV_DEBUG << "IGMPv2: Rexmt Timer expired for group=" << ctx->routerGroup->groupAddr << " iface=" << ctx->ie->getName() << "\n";
     sendQuery(ctx->ie, ctx->routerGroup->groupAddr, lastMemberQueryInterval);
     startTimer(ctx->routerGroup->rexmtTimer, lastMemberQueryInterval);
     ctx->routerGroup->state = IGMP_RGS_CHECKING_MEMBERSHIP;
 }

void inet::IGMPv2::processV2Report	(	InterfaceEntry *	ie,
		IGMPv2Report *	msg
	)

protectedvirtual

Referenced by processIgmpMessage().

 {
     ASSERT(ie->isMulticast());
 
     IPv4Address& groupAddr = msg->getGroupAddress();
 
     EV_INFO << "IGMPv2: received V2 Membership Report for group=" << groupAddr << " iface=" << ie->getName() << "\n";
 
     numReportsRecv++;
 
     HostGroupData *hostGroupData = getHostGroupData(ie, groupAddr);
     if (hostGroupData) {
         if (hostGroupData && hostGroupData->state == IGMP_HGS_DELAYING_MEMBER) {
             cancelEvent(hostGroupData->timer);
             hostGroupData->flag = false;
             hostGroupData->state = IGMP_HGS_IDLE_MEMBER;
         }
     }
 
     if (rt->isMulticastForwardingEnabled()) {
         if (externalRouter) {
             send(msg, "routerOut");
             return;
         }
 
         RouterGroupData *routerGroupData = getRouterGroupData(ie, groupAddr);
         if (!routerGroupData) {
             routerGroupData = createRouterGroupData(ie, groupAddr);
             numGroups++;
         }
 
         if (!routerGroupData->timer) {
             routerGroupData->timer = new cMessage("IGMPv2 leave timer", IGMP_LEAVE_TIMER);
             routerGroupData->timer->setContextPointer(new IGMPRouterTimerContext(ie, routerGroupData));
         }
         if (!routerGroupData->rexmtTimer) {
             routerGroupData->rexmtTimer = new cMessage("IGMPv2 rexmt timer", IGMP_REXMT_TIMER);
             routerGroupData->rexmtTimer->setContextPointer(new IGMPRouterTimerContext(ie, routerGroupData));
         }
 
         if (routerGroupData->state == IGMP_RGS_NO_MEMBERS_PRESENT) {
             // notify IPv4InterfaceData to update its listener list
             ie->ipv4Data()->addMulticastListener(groupAddr);
             numRouterGroups++;
         }
         else if (routerGroupData->state == IGMP_RGS_CHECKING_MEMBERSHIP)
             cancelEvent(routerGroupData->rexmtTimer);
 
         startTimer(routerGroupData->timer, groupMembershipInterval);
         routerGroupData->state = IGMP_RGS_MEMBERS_PRESENT;
     }
 
     delete msg;
 }

void inet::IGMPv2::receiveSignal	(	cComponent *	source,
		simsignal_t	signalID,
		cObject *	obj,
		cObject *	details
	)

overrideprotectedvirtual

 {
     Enter_Method_Silent();
 
     InterfaceEntry *ie;
     int interfaceId;
     const IPv4MulticastGroupInfo *info;
 
     if (signalID == NF_INTERFACE_CREATED) {
         ie = check_and_cast<InterfaceEntry *>(obj);
         if (ie->isMulticast())
             configureInterface(ie);
     }
     else if (signalID == NF_INTERFACE_DELETED) {
         ie = check_and_cast<InterfaceEntry *>(obj);
         if (ie->isMulticast()) {
             interfaceId = ie->getInterfaceId();
             deleteHostInterfaceData(interfaceId);
             deleteRouterInterfaceData(interfaceId);
         }
     }
     else if (signalID == NF_IPv4_MCAST_JOIN) {
         info = check_and_cast<const IPv4MulticastGroupInfo *>(obj);
         multicastGroupJoined(info->ie, info->groupAddress);
     }
     else if (signalID == NF_IPv4_MCAST_LEAVE) {
         info = check_and_cast<const IPv4MulticastGroupInfo *>(obj);
         multicastGroupLeft(info->ie, info->groupAddress);
     }
 }

void inet::IGMPv2::sendLeave	(	InterfaceEntry *	ie,
		HostGroupData *	group
	)

protectedvirtual

Referenced by multicastGroupLeft().

 {
     ASSERT(group->groupAddr.isMulticast() && !group->groupAddr.isLinkLocalMulticast());
 
     EV_INFO << "IGMPv2: sending Leave Group for group=" << group->groupAddr << " on iface=" << ie->getName() << "\n";
     IGMPv2Leave *msg = new IGMPv2Leave("IGMPv2 leave");
     msg->setGroupAddress(group->groupAddr);
     msg->setByteLength(8);
     sendToIP(msg, ie, IPv4Address::ALL_ROUTERS_MCAST);
     numLeavesSent++;
 }

void inet::IGMPv2::sendQuery	(	InterfaceEntry *	ie,
		const IPv4Address &	groupAddr,
		double	maxRespTime
	)

protectedvirtual

Referenced by configureInterface(), processLeave(), processQueryTimer(), and processRexmtTimer().

 {
     ASSERT(groupAddr.isUnspecified() || (groupAddr.isMulticast() && !groupAddr.isLinkLocalMulticast()));
 
     RouterInterfaceData *interfaceData = getRouterInterfaceData(ie);
 
     if (interfaceData->igmpRouterState == IGMP_RS_QUERIER) {
         if (groupAddr.isUnspecified())
             EV_INFO << "IGMPv2: sending General Membership Query on iface=" << ie->getName() << "\n";
         else
             EV_INFO << "IGMPv2: sending Membership Query for group=" << groupAddr << " on iface=" << ie->getName() << "\n";
 
         IGMPv2Query *msg = new IGMPv2Query("IGMPv2 query");
         msg->setType(IGMP_MEMBERSHIP_QUERY);
         msg->setGroupAddress(groupAddr);
         msg->setMaxRespTime((int)(maxRespTime * 10.0));
         msg->setByteLength(8);
         sendToIP(msg, ie, groupAddr.isUnspecified() ? IPv4Address::ALL_HOSTS_MCAST : groupAddr);
 
         numQueriesSent++;
         if (groupAddr.isUnspecified())
             numGeneralQueriesSent++;
         else
             numGroupSpecificQueriesSent++;
     }
 }

void inet::IGMPv2::sendReport	(	InterfaceEntry *	ie,
		HostGroupData *	group
	)

protectedvirtual

Referenced by multicastGroupJoined(), and processHostGroupTimer().

 {
     ASSERT(group->groupAddr.isMulticast() && !group->groupAddr.isLinkLocalMulticast());
 
     EV_INFO << "IGMPv2: sending Membership Report for group=" << group->groupAddr << " on iface=" << ie->getName() << "\n";
     IGMPv2Report *msg = new IGMPv2Report("IGMPv2 report");
     msg->setGroupAddress(group->groupAddr);
     msg->setByteLength(8);
     sendToIP(msg, ie, group->groupAddr);
     numReportsSent++;
 }

void inet::IGMPv2::sendToIP	(	IGMPMessage *	msg,
		InterfaceEntry *	ie,
		const IPv4Address &	dest
	)

protectedvirtual

Referenced by sendLeave(), sendQuery(), and sendReport().

 {
     ASSERT(ie->isMulticast());
 
     IPv4ControlInfo *controlInfo = new IPv4ControlInfo();
     controlInfo->setProtocol(IP_PROT_IGMP);
     controlInfo->setInterfaceId(ie->getInterfaceId());
     controlInfo->setTimeToLive(1);
     controlInfo->setDestAddr(dest);
     msg->setControlInfo(controlInfo);
 
     send(msg, "ipOut");
 }

void inet::IGMPv2::startHostTimer	(	InterfaceEntry *	ie,
		HostGroupData *	group,
		double	maxRespTime
	)

protectedvirtual

Referenced by multicastGroupJoined(), and processGroupQuery().

 {
     if (!group->timer) {
         group->timer = new cMessage("IGMPv2 group timer", IGMP_HOSTGROUP_TIMER);
         group->timer->setContextPointer(new IGMPHostTimerContext(ie, group));
     }
 
     double delay = uniform(0.0, maxRespTime);
     EV_DEBUG << "setting host timer for " << ie->getName() << " and group " << group->groupAddr.str() << " to " << delay << "\n";
     startTimer(group->timer, delay);
 }

void inet::IGMPv2::startTimer	(	cMessage *	timer,
		double	interval
	)

protectedvirtual

Referenced by configureInterface(), processLeave(), processQuery(), processQueryTimer(), processRexmtTimer(), processV2Report(), and startHostTimer().

 {
     ASSERT(timer);
     cancelEvent(timer);
     scheduleAt(simTime() + interval, timer);
 }

Member Data Documentation

bool inet::IGMPv2::enabled

protected

Referenced by configureInterface(), handleMessage(), initialize(), multicastGroupJoined(), and multicastGroupLeft().

bool inet::IGMPv2::externalRouter

protected

Referenced by configureInterface(), initialize(), processIgmpMessage(), processLeave(), processQuery(), and processV2Report().

double inet::IGMPv2::groupMembershipInterval

protected

Referenced by initialize(), and processV2Report().

InterfaceToHostDataMap inet::IGMPv2::hostData

protected

Referenced by deleteHostInterfaceData(), getHostInterfaceData(), and ~IGMPv2().

IInterfaceTable* inet::IGMPv2::ift

protected

Referenced by initialize(), and processIgmpMessage().

double inet::IGMPv2::lastMemberQueryCount

protected

Referenced by initialize(), processLeave(), and processQuery().

double inet::IGMPv2::lastMemberQueryInterval

protected

Referenced by initialize(), processLeave(), and processRexmtTimer().

int inet::IGMPv2::numGeneralQueriesRecv

protected

Referenced by initialize(), and processQuery().

int inet::IGMPv2::numGeneralQueriesSent

protected

Referenced by initialize(), and sendQuery().

int inet::IGMPv2::numGroups

protected

Referenced by initialize(), multicastGroupJoined(), multicastGroupLeft(), processLeaveTimer(), and processV2Report().

int inet::IGMPv2::numGroupSpecificQueriesRecv

protected

Referenced by initialize(), and processQuery().

int inet::IGMPv2::numGroupSpecificQueriesSent

protected

Referenced by initialize(), and sendQuery().

int inet::IGMPv2::numHostGroups

protected

Referenced by initialize(), multicastGroupJoined(), and multicastGroupLeft().

int inet::IGMPv2::numLeavesRecv

protected

Referenced by initialize(), and processLeave().

int inet::IGMPv2::numLeavesSent

protected

Referenced by initialize(), and sendLeave().

int inet::IGMPv2::numQueriesRecv

protected

Referenced by initialize(), and processQuery().

int inet::IGMPv2::numQueriesSent

protected

Referenced by initialize(), and sendQuery().

int inet::IGMPv2::numReportsRecv

protected

Referenced by initialize(), and processV2Report().

int inet::IGMPv2::numReportsSent

protected

Referenced by initialize(), and sendReport().

int inet::IGMPv2::numRouterGroups

protected

Referenced by initialize(), processLeaveTimer(), and processV2Report().

double inet::IGMPv2::otherQuerierPresentInterval

protected

Referenced by initialize(), and processQuery().

double inet::IGMPv2::queryInterval

protected

Referenced by initialize(), and processQueryTimer().

double inet::IGMPv2::queryResponseInterval

protected

Referenced by configureInterface(), initialize(), and processQueryTimer().

int inet::IGMPv2::robustness

protected

Referenced by initialize().

InterfaceToRouterDataMap inet::IGMPv2::routerData

protected

Referenced by configureInterface(), deleteRouterInterfaceData(), getRouterInterfaceData(), and ~IGMPv2().

IIPv4RoutingTable* inet::IGMPv2::rt

protected

Referenced by configureInterface(), initialize(), processLeave(), processQuery(), and processV2Report().

double inet::IGMPv2::startupQueryCount

protected

Referenced by initialize().

double inet::IGMPv2::startupQueryInterval

protected

Referenced by configureInterface(), and initialize().

double inet::IGMPv2::unsolicitedReportInterval

protected

Referenced by initialize(), and multicastGroupJoined().

The documentation for this class was generated from the following files:

Classes

Protected Types

Protected Member Functions

Protected Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation