inet::Igmpv2 Class Reference

#include <Igmpv2.h>

Inheritance diagram for inet::Igmpv2:

Classes
struct	HostGroupData
struct	HostInterfaceData
struct	IgmpHostTimerContext
struct	IgmpRouterTimerContext
struct	RouterGroupData
struct	RouterInterfaceData

Public Member Functions
void	insertCrc (const Ptr< IgmpMessage > &igmpMsg, Packet *payload)
bool	verifyCrc (const Packet *packet)
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override

Static Public Member Functions
static const std::string	getRouterStateString (RouterState rs)
static const std::string	getRouterGroupStateString (RouterGroupState rgs)
static const std::string	getHostGroupStateString (HostGroupState hgs)
static void	insertCrc (CrcMode crcMode, const Ptr< IgmpMessage > &igmpMsg, Packet *payload)

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	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual	~Igmpv2 ()
void	addWatches ()
virtual void	multicastGroupJoined (NetworkInterface *ie, const Ipv4Address &groupAddr)
virtual void	multicastGroupLeft (NetworkInterface *ie, const Ipv4Address &groupAddr)
virtual void	configureInterface (NetworkInterface *ie)
virtual void	deleteHostInterfaceData (int interfaceId)
virtual void	deleteRouterInterfaceData (int interfaceId)
virtual void	processQueryTimer (cMessage *msg)
virtual void	processHostGroupTimer (cMessage *msg)
virtual void	processLeaveTimer (cMessage *msg)
virtual void	processRexmtTimer (cMessage *msg)
virtual void	startTimer (cMessage *timer, double interval)
virtual void	startHostTimer (NetworkInterface *ie, HostGroupData *group, double maxRespTime)
virtual void	processIgmpMessage (Packet *packet)
virtual void	processQuery (NetworkInterface *ie, Packet *packet)
virtual void	processGroupQuery (NetworkInterface *ie, HostGroupData *group, simtime_t maxRespTime)
virtual void	processV2Report (NetworkInterface *ie, Packet *packet)
virtual void	processLeave (NetworkInterface *ie, Packet *packet)
virtual void	sendQuery (NetworkInterface *ie, const Ipv4Address &groupAddr, double maxRespTime)
virtual void	sendReport (NetworkInterface *ie, HostGroupData *group)
virtual void	sendLeave (NetworkInterface *ie, HostGroupData *group)
virtual void	sendToIP (Packet *msg, NetworkInterface *ie, const Ipv4Address &dest)
virtual RouterGroupData *	createRouterGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual HostGroupData *	createHostGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual RouterGroupData *	getRouterGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual HostGroupData *	getHostGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual void	deleteRouterGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual void	deleteHostGroupData (NetworkInterface *ie, const Ipv4Address &group)
virtual RouterInterfaceData *	getRouterInterfaceData (NetworkInterface *ie)
virtual RouterInterfaceData *	createRouterInterfaceData ()
virtual HostInterfaceData *	getHostInterfaceData (NetworkInterface *ie)
virtual HostInterfaceData *	createHostInterfaceData ()

Protected Attributes
ModuleRefByPar< IIpv4RoutingTable >	rt
ModuleRefByPar< IInterfaceTable >	ift
bool	enabled
bool	externalRouter
int	robustness
double	queryInterval
double	queryResponseInterval
double	groupMembershipInterval
double	otherQuerierPresentInterval
double	startupQueryInterval
int	startupQueryCount
double	lastMemberQueryInterval
int	lastMemberQueryCount
double	unsolicitedReportInterval
int	numGroups = 0
int	numHostGroups = 0
int	numRouterGroups = 0
int	numQueriesSent = 0
int	numQueriesRecv = 0
int	numGeneralQueriesSent = 0
int	numGeneralQueriesRecv = 0
int	numGroupSpecificQueriesSent = 0
int	numGroupSpecificQueriesRecv = 0
int	numReportsSent = 0
int	numReportsRecv = 0
int	numLeavesSent = 0
int	numLeavesRecv = 0
CrcMode	crcMode = CRC_MODE_UNDEFINED
InterfaceToHostDataMap	hostData
InterfaceToRouterDataMap	routerData

Member Typedef Documentation

GroupToHostDataMap

typedef std::map<Ipv4Address, HostGroupData *> inet::Igmpv2::GroupToHostDataMap

protected

GroupToRouterDataMap

typedef std::map<Ipv4Address, RouterGroupData *> inet::Igmpv2::GroupToRouterDataMap

protected

InterfaceToHostDataMap

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

protected

InterfaceToRouterDataMap

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

protected

Member Enumeration Documentation

HostGroupState

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,
    };

IgmpTimerKind

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
    };

RouterGroupState

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,
    };

RouterState

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

~Igmpv2()

inet::Igmpv2::~Igmpv2 ( )

protectedvirtual

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

Member Function Documentation

addWatches()

void inet::Igmpv2::addWatches ( )

protected

{
    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);
 
    WATCH_PTRMAP(hostData);
    WATCH_PTRMAP(routerData);
}

Referenced by initialize().

configureInterface()

void inet::Igmpv2::configureInterface ( NetworkInterface *  ie )

protectedvirtual

{
    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);
    }
}

Referenced by initialize(), and receiveSignal().

createHostGroupData()

Igmpv2::HostGroupData * inet::Igmpv2::createHostGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

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

Referenced by multicastGroupJoined().

createHostInterfaceData()

Igmpv2::HostInterfaceData * inet::Igmpv2::createHostInterfaceData ( )

protectedvirtual

{
    return new HostInterfaceData(this);
}

Referenced by getHostInterfaceData().

createRouterGroupData()

Igmpv2::RouterGroupData * inet::Igmpv2::createRouterGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

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

Referenced by processV2Report().

createRouterInterfaceData()

Igmpv2::RouterInterfaceData * inet::Igmpv2::createRouterInterfaceData ( )

protectedvirtual

{
    return new RouterInterfaceData(this);
}

Referenced by getRouterInterfaceData().

deleteHostGroupData()

void inet::Igmpv2::deleteHostGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

{
    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;
    }
}

Referenced by multicastGroupLeft().

deleteHostInterfaceData()

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

protectedvirtual

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

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

deleteRouterGroupData()

void inet::Igmpv2::deleteRouterGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

{
    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;
    }
}

Referenced by processLeaveTimer().

deleteRouterInterfaceData()

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

protectedvirtual

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

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

getHostGroupData()

Igmpv2::HostGroupData * inet::Igmpv2::getHostGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

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

Referenced by multicastGroupLeft(), and processV2Report().

getHostGroupStateString()

const std::string inet::Igmpv2::getHostGroupStateString ( Igmpv2::HostGroupState  hgs )

static

{
    if (hgs == IGMP_HGS_NON_MEMBER)
        return "NON_MEMBER";
    else if (hgs == IGMP_HGS_DELAYING_MEMBER)
        return "DELAYING_MEMBER";
    else if (hgs == IGMP_HGS_IDLE_MEMBER)
        return "IDLE_MEMBER";
 
    return "UNKNOWN";
}

getHostInterfaceData()

Igmpv2::HostInterfaceData * inet::Igmpv2::getHostInterfaceData ( NetworkInterface *  ie )

protectedvirtual

{
    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;
}

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

getRouterGroupData()

Igmpv2::RouterGroupData * inet::Igmpv2::getRouterGroupData ( NetworkInterface *  ie, const Ipv4Address &  group  )

protectedvirtual

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

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

getRouterGroupStateString()

const std::string inet::Igmpv2::getRouterGroupStateString ( Igmpv2::RouterGroupState  rgs )

static

{
    if (rgs == IGMP_RGS_NO_MEMBERS_PRESENT)
        return "NO_MEMBERS_PRESENT";
    else if (rgs == IGMP_RGS_MEMBERS_PRESENT)
        return "MEMBERS_PRESENT";
    else if (rgs == IGMP_RGS_V1_MEMBERS_PRESENT)
        return "V1_MEMBERS_PRESENT";
    else if (rgs == IGMP_RGS_CHECKING_MEMBERSHIP)
        return "CHECKING_MEMBERSHIP";
 
    return "UNKNOWN";
}

getRouterInterfaceData()

Igmpv2::RouterInterfaceData * inet::Igmpv2::getRouterInterfaceData ( NetworkInterface *  ie )

protectedvirtual

{
    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;
}

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

getRouterStateString()

const std::string inet::Igmpv2::getRouterStateString ( Igmpv2::RouterState  rs )

static

{
    if (rs == IGMP_RS_INITIAL)
        return "INITIAL";
    else if (rs == IGMP_RS_QUERIER)
        return "QUERIER";
    else if (rs == IGMP_RS_NON_QUERIER)
        return "NON_QUERIER";
 
    return "UNKNOWN";
}

handleMessage()

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 {
        auto packet = check_and_cast<Packet *>(msg);
        processIgmpMessage(packet);
    }
}

handleRegisterProtocol()

void inet::Igmpv2::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
}

handleRegisterService()

void inet::Igmpv2::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
    if (protocol == Protocol::igmp && servicePrimitive == SP_INDICATION)
        externalRouter = true;
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
 
        externalRouter = false;
        enabled = par("enabled");
        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");
        const char *crcModeString = par("crcMode");
        crcMode = parseCrcMode(crcModeString, false);
 
        addWatches();
    }
    // TODO INITSTAGE
    else if (stage == INITSTAGE_NETWORK_LAYER_PROTOCOLS) {
        cModule *host = getContainingNode(this);
        registerProtocol(Protocol::igmp, gate("ipOut"), gate("ipIn"));
        for (int i = 0; i < ift->getNumInterfaces(); ++i) {
            NetworkInterface *ie = ift->getInterface(i);
            if (ie->isMulticast()) {
                if (auto ipv4interfaceData = ie->findProtocolData<Ipv4InterfaceData>()) {
                    int n = ipv4interfaceData->getNumOfJoinedMulticastGroups();
                    for (int j = 0; j < n; j++) {
                        auto groupAddress = ipv4interfaceData->getJoinedMulticastGroup(j);
                        multicastGroupJoined(ie, groupAddress);
                    }
                }
            }
        }
 
        for (int i = 0; i < ift->getNumInterfaces(); ++i) {
            NetworkInterface *ie = ift->getInterface(i);
            if (ie->isMulticast())
                configureInterface(ie);
        }
 
        host->subscribe(interfaceCreatedSignal, this);
        host->subscribe(interfaceDeletedSignal, this);
        host->subscribe(ipv4MulticastGroupJoinedSignal, this);
        host->subscribe(ipv4MulticastGroupLeftSignal, this);
    }
}

insertCrc() [1/2]

void inet::Igmpv2::insertCrc ( const Ptr< IgmpMessage > &  igmpMsg, Packet *  payload  )

inline

{ insertCrc(crcMode, igmpMsg, payload); }

Referenced by insertCrc().

insertCrc() [2/2]

void inet::Igmpv2::insertCrc ( CrcMode  crcMode, const Ptr< IgmpMessage > &  igmpMsg, Packet *  payload  )

static

{
    igmpMsg->setCrcMode(crcMode);
    switch (crcMode) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then set the CRC to an easily recognizable value
            igmpMsg->setCrc(0xC00D);
            break;
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then set the CRC to an easily recognizable value
            igmpMsg->setCrc(0xBAAD);
            break;
        case CRC_COMPUTED: {
            // if the CRC mode is computed, then compute the CRC and set it
            igmpMsg->setCrc(0x0000); // make sure that the CRC is 0 in the header before computing the CRC
            MemoryOutputStream igmpStream;
            Chunk::serialize(igmpStream, igmpMsg);
            Chunk::serialize(igmpStream, packet->peekData(Chunk::PF_ALLOW_EMPTY));
            uint16_t crc = TcpIpChecksum::checksum(igmpStream.getData());
            igmpMsg->setCrc(crc);
            break;
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
}

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

multicastGroupJoined()

void inet::Igmpv2::multicastGroupJoined ( NetworkInterface *  ie, const Ipv4Address &  groupAddr  )

protectedvirtual

{
    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;
    }
}

Referenced by initialize(), and receiveSignal().

multicastGroupLeft()

void inet::Igmpv2::multicastGroupLeft ( NetworkInterface *  ie, const Ipv4Address &  groupAddr  )

protectedvirtual

{
    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--;
    }
}

Referenced by receiveSignal().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processGroupQuery()

void inet::Igmpv2::processGroupQuery ( NetworkInterface *  ie, HostGroupData *  group, simtime_t  maxRespTime  )

protectedvirtual

{
    double maxRespTimeSecs = maxRespTime.dbl(); // FIXME use simtime_t !!!
 
    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
    }
}

Referenced by processQuery().

processHostGroupTimer()

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

protectedvirtual

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

Referenced by handleMessage().

processIgmpMessage()

void inet::Igmpv2::processIgmpMessage ( Packet *  packet )

protectedvirtual

{
    if (!verifyCrc(packet)) {
        EV_WARN << "incoming IGMP packet has wrong CRC, dropped\n";
        // drop packet
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    const auto& igmp = packet->peekAtFront<IgmpMessage>();
    NetworkInterface *ie = ift->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
    switch (igmp->getType()) {
        case IGMP_MEMBERSHIP_QUERY:
            processQuery(ie, packet);
            break;
 
        //case IGMPV1_MEMBERSHIP_REPORT:
//           processV1Report(ie, msg);
//           delete msg;
//           break;
        case IGMPV2_MEMBERSHIP_REPORT:
            processV2Report(ie, packet);
            break;
 
        case IGMPV2_LEAVE_GROUP:
            processLeave(ie, packet);
            break;
 
        default:
            if (externalRouter)
                send(packet, "routerOut");
            else {
//                delete msg;
                throw cRuntimeError("Igmpv2: Unhandled message type (%d) in packet %s", igmp->getType(), packet->getName());
            }
            break;
    }
}

Referenced by handleMessage().

processLeave()

void inet::Igmpv2::processLeave ( NetworkInterface *  ie, Packet *  packet  )

protectedvirtual

{
    ASSERT(ie->isMulticast());
 
    const auto& msg = packet->peekAtFront<Igmpv2Leave>();
 
    EV_INFO << "Igmpv2: received Leave Group for group=" << msg->getGroupAddress() << " iface=" << ie->getInterfaceName() << "\n";
 
    numLeavesRecv++;
 
    if (rt->isMulticastForwardingEnabled()) {
        if (externalRouter) {
            send(packet, "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 packet;
}

Referenced by processIgmpMessage().

processLeaveTimer()

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

protectedvirtual

{
    IgmpRouterTimerContext *ctx = (IgmpRouterTimerContext *)msg->getContextPointer();
    EV_DEBUG << "Igmpv2: Leave Timer expired, deleting " << ctx->routerGroup->groupAddr << " from listener list of '" << ctx->ie->getInterfaceName() << "'\n";
 
    // notify Ipv4InterfaceData to update its listener list
    ctx->ie->getProtocolDataForUpdate<Ipv4InterfaceData>()->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--;
}

Referenced by handleMessage().

processQuery()

void inet::Igmpv2::processQuery ( NetworkInterface *  ie, Packet *  packet  )

protectedvirtual

{
    ASSERT(ie->isMulticast());
 
    Ipv4Address sender = packet->getTag<L3AddressInd>()->getSrcAddress().toIpv4();
    HostInterfaceData *interfaceData = getHostInterfaceData(ie);
    const auto& igmpQry = packet->peekAtFront<IgmpQuery>(b(packet->getBitLength())); // peek entire igmp packet
 
    numQueriesRecv++;
 
    Ipv4Address groupAddr = igmpQry->getGroupAddress();
    const Ptr<const Igmpv2Query>& v2Query = dynamicPtrCast<const Igmpv2Query>(igmpQry);
    simtime_t maxRespTime = SimTime(v2Query ? v2Query->getMaxRespTimeCode() : 100, (SimTimeUnit) - 1);
 
    if (groupAddr.isUnspecified()) {
        // general query
        EV_INFO << "Igmpv2: received General Membership Query on iface=" << ie->getInterfaceName() << "\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->getInterfaceName() << "\n";
        numGroupSpecificQueriesRecv++;
        auto it = interfaceData->groups.find(groupAddr);
        if (it != interfaceData->groups.end())
            processGroupQuery(ie, it->second, maxRespTime);
    }
 
    if (rt->isMulticastForwardingEnabled()) {
        if (externalRouter) {
            send(packet, "routerOut");
            return;
        }
 
        RouterInterfaceData *routerInterfaceData = getRouterInterfaceData(ie);
        if (sender < ie->getProtocolData<Ipv4InterfaceData>()->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) {
                startTimer(groupData->timer, maxRespTime.dbl() * lastMemberQueryCount);
                groupData->state = IGMP_RGS_CHECKING_MEMBERSHIP;
            }
        }
    }
    else
        EV_INFO << "Igmpv2: multicast forwarding is not enabled on this node. \n";
 
    delete packet;
}

Referenced by processIgmpMessage().

processQueryTimer()

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

protectedvirtual

{
    NetworkInterface *ie = (NetworkInterface *)msg->getContextPointer();
    ASSERT(ie);
    EV_DEBUG << "Igmpv2: General Query timer expired, iface=" << ie->getInterfaceName() << "\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);
    }
}

Referenced by handleMessage().

processRexmtTimer()

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

protectedvirtual

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

Referenced by handleMessage().

processV2Report()

void inet::Igmpv2::processV2Report ( NetworkInterface *  ie, Packet *  packet  )

protectedvirtual

{
    ASSERT(ie->isMulticast());
 
    const auto& msg = packet->peekAtFront<Igmpv2Report>();
 
    Ipv4Address groupAddr = msg->getGroupAddress();
 
    EV_INFO << "Igmpv2: received V2 Membership Report for group=" << groupAddr << " iface=" << ie->getInterfaceName() << "\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(packet, "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->getProtocolDataForUpdate<Ipv4InterfaceData>()->addMulticastListener(groupAddr);
            numRouterGroups++;
        }
        else if (routerGroupData->state == IGMP_RGS_CHECKING_MEMBERSHIP)
            cancelEvent(routerGroupData->rexmtTimer);
 
        startTimer(routerGroupData->timer, groupMembershipInterval);
        routerGroupData->state = IGMP_RGS_MEMBERS_PRESENT;
    }
    else
        EV_INFO << "Igmpv2: multicast forwarding is not enabled on this node. \n";
 
    delete packet;
}

Referenced by processIgmpMessage().

receiveSignal()

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

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    NetworkInterface *ie;
    int interfaceId;
    const Ipv4MulticastGroupInfo *info;
 
    if (signalID == ipv4MulticastGroupJoinedSignal) {
        info = check_and_cast<const Ipv4MulticastGroupInfo *>(obj);
        multicastGroupJoined(info->ie, info->groupAddress);
    }
    else if (signalID == ipv4MulticastGroupLeftSignal) {
        info = check_and_cast<const Ipv4MulticastGroupInfo *>(obj);
        multicastGroupLeft(info->ie, info->groupAddress);
    }
    else if (signalID == interfaceCreatedSignal) {
        ie = check_and_cast<NetworkInterface *>(obj);
        if (ie->isMulticast())
            configureInterface(ie);
    }
    else if (signalID == interfaceDeletedSignal) {
        ie = check_and_cast<NetworkInterface *>(obj);
        if (ie->isMulticast()) {
            interfaceId = ie->getInterfaceId();
            deleteHostInterfaceData(interfaceId);
            deleteRouterInterfaceData(interfaceId);
        }
    }
}

sendLeave()

void inet::Igmpv2::sendLeave ( NetworkInterface *  ie, HostGroupData *  group  )

protectedvirtual

{
    ASSERT(group->groupAddr.isMulticast() && !group->groupAddr.isLinkLocalMulticast());
 
    EV_INFO << "Igmpv2: sending Leave Group for group=" << group->groupAddr << " on iface=" << ie->getInterfaceName() << "\n";
    Packet *packet = new Packet("Igmpv2 leave");
    const auto& msg = makeShared<Igmpv2Leave>();
    msg->setGroupAddress(group->groupAddr);
    msg->setChunkLength(B(8));
    insertCrc(msg, packet);
    packet->insertAtFront(msg);
    // TODO fill Router Alert option
    auto raOption = new Ipv4OptionRouterAlert();
    packet->addTag<Ipv4OptionsReq>()->appendOption(raOption);
    sendToIP(packet, ie, Ipv4Address::ALL_ROUTERS_MCAST);
    numLeavesSent++;
}

Referenced by multicastGroupLeft().

sendQuery()

void inet::Igmpv2::sendQuery ( NetworkInterface *  ie, const Ipv4Address &  groupAddr, double  maxRespTime  )

protectedvirtual

{
    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->getInterfaceName() << "\n";
        else
            EV_INFO << "Igmpv2: sending Membership Query for group=" << groupAddr << " on iface=" << ie->getInterfaceName() << "\n";
 
        Packet *packet = new Packet("Igmpv2 query");
        const auto& msg = makeShared<Igmpv2Query>();
        msg->setType(IGMP_MEMBERSHIP_QUERY);
        msg->setGroupAddress(groupAddr);
        msg->setMaxRespTimeCode(SimTime(maxRespTime).inUnit((SimTimeUnit) - 1));
        msg->setChunkLength(B(8));
        insertCrc(msg, packet);
        packet->insertAtFront(msg);
        sendToIP(packet, ie, groupAddr.isUnspecified() ? Ipv4Address::ALL_HOSTS_MCAST : groupAddr);
 
        numQueriesSent++;
        if (groupAddr.isUnspecified())
            numGeneralQueriesSent++;
        else
            numGroupSpecificQueriesSent++;
    }
}

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

sendReport()

void inet::Igmpv2::sendReport ( NetworkInterface *  ie, HostGroupData *  group  )

protectedvirtual

{
    ASSERT(group->groupAddr.isMulticast() && !group->groupAddr.isLinkLocalMulticast());
 
    EV_INFO << "Igmpv2: sending Membership Report for group=" << group->groupAddr << " on iface=" << ie->getInterfaceName() << "\n";
    Packet *packet = new Packet("Igmpv2 report");
    const auto& msg = makeShared<Igmpv2Report>();
    msg->setGroupAddress(group->groupAddr);
    msg->setChunkLength(B(8));
    insertCrc(msg, packet);
    packet->insertAtFront(msg);
    // TODO fill Router Alert option
    auto raOption = new Ipv4OptionRouterAlert();
    packet->addTag<Ipv4OptionsReq>()->appendOption(raOption);
    sendToIP(packet, ie, group->groupAddr);
    numReportsSent++;
}

Referenced by multicastGroupJoined(), and processHostGroupTimer().

sendToIP()

void inet::Igmpv2::sendToIP ( Packet *  msg, NetworkInterface *  ie, const Ipv4Address &  dest  )

protectedvirtual

{
    ASSERT(ie->isMulticast());
 
    msg->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::igmp);
    msg->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::igmp);
    msg->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
    msg->addTagIfAbsent<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
    msg->addTagIfAbsent<L3AddressReq>()->setDestAddress(dest);
    msg->addTagIfAbsent<HopLimitReq>()->setHopLimit(1);
 
    send(msg, "ipOut");
}

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

startHostTimer()

void inet::Igmpv2::startHostTimer ( NetworkInterface *  ie, HostGroupData *  group, double  maxRespTime  )

protectedvirtual

{
    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->getInterfaceName() << " and group " << group->groupAddr.str() << " to " << delay << "\n";
    startTimer(group->timer, delay);
}

Referenced by multicastGroupJoined(), and processGroupQuery().

startTimer()

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

protectedvirtual

{
    ASSERT(timer);
    rescheduleAfter(interval, timer);
}

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

verifyCrc()

bool inet::Igmpv2::verifyCrc

(

const Packet *

packet

)

{
    const auto& igmpMsg = packet->peekAtFront<IgmpMessage>(b(-1), Chunk::PF_ALLOW_INCORRECT);
    switch (igmpMsg->getCrcMode()) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then the check passes if and only if the chunks are correct
            return igmpMsg->isCorrect();
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then the check fails
            return false;
        case CRC_COMPUTED: {
            // otherwise compute the CRC, the check passes if the result is 0xFFFF (includes the received CRC)
            auto dataBytes = packet->peekDataAsBytes(Chunk::PF_ALLOW_INCORRECT);
            uint16_t crc = TcpIpChecksum::checksum(dataBytes->getBytes());
            // TODO delete these isCorrect calls, rely on CRC only
            return crc == 0 && igmpMsg->isCorrect();
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
}

Referenced by processIgmpMessage().

Member Data Documentation

crcMode

CrcMode inet::Igmpv2::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by initialize(), and insertCrc().

enabled

bool inet::Igmpv2::enabled

protected

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

externalRouter

bool inet::Igmpv2::externalRouter

protected

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

groupMembershipInterval

double inet::Igmpv2::groupMembershipInterval

protected

Referenced by initialize(), and processV2Report().

hostData

InterfaceToHostDataMap inet::Igmpv2::hostData

protected

Referenced by addWatches(), deleteHostInterfaceData(), getHostInterfaceData(), and ~Igmpv2().

ift

ModuleRefByPar<IInterfaceTable> inet::Igmpv2::ift

protected

Referenced by initialize(), and processIgmpMessage().

lastMemberQueryCount

int inet::Igmpv2::lastMemberQueryCount

protected

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

lastMemberQueryInterval

double inet::Igmpv2::lastMemberQueryInterval

protected

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

numGeneralQueriesRecv

int inet::Igmpv2::numGeneralQueriesRecv = 0

protected

Referenced by addWatches(), and processQuery().

numGeneralQueriesSent

int inet::Igmpv2::numGeneralQueriesSent = 0

protected

Referenced by addWatches(), and sendQuery().

numGroups

int inet::Igmpv2::numGroups = 0

protected

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

numGroupSpecificQueriesRecv

int inet::Igmpv2::numGroupSpecificQueriesRecv = 0

protected

Referenced by addWatches(), and processQuery().

numGroupSpecificQueriesSent

int inet::Igmpv2::numGroupSpecificQueriesSent = 0

protected

Referenced by addWatches(), and sendQuery().

numHostGroups

int inet::Igmpv2::numHostGroups = 0

protected

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

numLeavesRecv

int inet::Igmpv2::numLeavesRecv = 0

protected

Referenced by addWatches(), and processLeave().

numLeavesSent

int inet::Igmpv2::numLeavesSent = 0

protected

Referenced by addWatches(), and sendLeave().

numQueriesRecv

int inet::Igmpv2::numQueriesRecv = 0

protected

Referenced by addWatches(), and processQuery().

numQueriesSent

int inet::Igmpv2::numQueriesSent = 0

protected

Referenced by addWatches(), and sendQuery().

numReportsRecv

int inet::Igmpv2::numReportsRecv = 0

protected

Referenced by addWatches(), and processV2Report().

numReportsSent

int inet::Igmpv2::numReportsSent = 0

protected

Referenced by addWatches(), and sendReport().

numRouterGroups

int inet::Igmpv2::numRouterGroups = 0

protected

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

otherQuerierPresentInterval

double inet::Igmpv2::otherQuerierPresentInterval

protected

Referenced by initialize(), and processQuery().

queryInterval

double inet::Igmpv2::queryInterval

protected

Referenced by initialize(), and processQueryTimer().

queryResponseInterval

double inet::Igmpv2::queryResponseInterval

protected

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

robustness

int inet::Igmpv2::robustness

protected

Referenced by initialize().

routerData

InterfaceToRouterDataMap inet::Igmpv2::routerData

protected

Referenced by addWatches(), configureInterface(), deleteRouterInterfaceData(), getRouterInterfaceData(), and ~Igmpv2().

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Igmpv2::rt

protected

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

startupQueryCount

int inet::Igmpv2::startupQueryCount

protected

Referenced by initialize().

startupQueryInterval

double inet::Igmpv2::startupQueryInterval

protected

Referenced by configureInterface(), and initialize().

unsolicitedReportInterval

double inet::Igmpv2::unsolicitedReportInterval

protected

Referenced by initialize(), and multicastGroupJoined().

---

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

• Igmpv2.h
• Igmpv2.cc