inet::PimSm Class Reference

Implementation of PIM-SM protocol (RFC 4601). More...

#include <PimSm.h>

Inheritance diagram for inet::PimSm:

Classes
struct	DownstreamInterface
struct	PimsmInterface
class	PimSmOutInterface
struct	Route
struct	UpstreamInterface

Public Member Functions
	PimSm ()
virtual	~PimSm ()
Public Member Functions inherited from inet::PimBase
	PimBase (PimInterface::PimMode mode)
virtual	~PimBase ()
Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	stopPIMRouting ()
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
Protected Member Functions inherited from inet::PimBase
void	sendHelloPackets ()
void	sendHelloPacket (PimInterface *pimInterface)
void	processHelloTimer (cMessage *timer)
void	processHelloPacket (Packet *pk)
Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Private Types
enum	RouteType { RP, G, SG, SGrpt }
typedef std::vector< DownstreamInterface * >	DownstreamInterfaceVector
typedef std::map< SourceAndGroup, Route * >	RoutingTable

Private Member Functions
void	processJoinPrunePacket (Packet *pk)
void	processRegisterPacket (Packet *pk)
	The method is used for processing PIM Register message sent from source DR. More...
void	processRegisterStopPacket (Packet *pk)
	The method is used for processing PIM Register-Stop message sent from RP. More...
void	processAssertPacket (Packet *pk)
void	processJoinG (Ipv4Address group, Ipv4Address rp, Ipv4Address upstreamNeighborField, int holdTime, NetworkInterface *inInterface)
void	processJoinSG (Ipv4Address origin, Ipv4Address group, Ipv4Address upstreamNeighborField, int holdTime, NetworkInterface *inInterface)
void	processJoinSGrpt (Ipv4Address origin, Ipv4Address group, Ipv4Address upstreamNeighborField, int holdTime, NetworkInterface *inInterface)
void	processPruneG (Ipv4Address multGroup, Ipv4Address upstreamNeighborField, NetworkInterface *inInterface)
void	processPruneSG (Ipv4Address source, Ipv4Address group, Ipv4Address upstreamNeighborField, NetworkInterface *inInterface)
void	processPruneSGrpt (Ipv4Address source, Ipv4Address group, Ipv4Address upstreamNeighborField, NetworkInterface *inInterface)
void	processAssertSG (PimsmInterface *interface, const AssertMetric &receivedMetric)
void	processAssertG (PimsmInterface *interface, const AssertMetric &receivedMetric)
void	processKeepAliveTimer (cMessage *timer)
void	processRegisterStopTimer (cMessage *timer)
void	processExpiryTimer (cMessage *timer)
	The method is used to process PIM Expiry Timer. More...
void	processJoinTimer (cMessage *timer)
void	processPrunePendingTimer (cMessage *timer)
	Prune Pending Timer is used for delaying of Prune message sending (for possible overriding Join from another PIM neighbor) More...
void	processAssertTimer (cMessage *timer)
void	unroutableMulticastPacketArrived (Ipv4Address srcAddr, Ipv4Address destAddr)
void	multicastPacketArrivedOnRpfInterface (Route *route)
	The method process notification about data which appears on RPF interface. More...
void	multicastPacketArrivedOnNonRpfInterface (Route *route, int interfaceId)
void	multicastPacketForwarded (Packet *pk)
void	multicastReceiverAdded (NetworkInterface *ie, Ipv4Address group)
void	multicastReceiverRemoved (NetworkInterface *ie, Ipv4Address group)
void	joinDesiredChanged (Route *route)
void	designatedRouterAddressHasChanged (NetworkInterface *ie)
void	iAmDRHasChanged (NetworkInterface *ie, bool iAmDR)
void	sendPIMRegister (Packet *pk, Ipv4Address dest, int outInterfaceId)
void	sendPIMRegisterStop (Ipv4Address source, Ipv4Address dest, Ipv4Address multGroup, Ipv4Address multSource)
void	sendPIMRegisterNull (Ipv4Address multSource, Ipv4Address multDest)
void	sendPIMJoin (Ipv4Address group, Ipv4Address source, Ipv4Address upstreamNeighbor, RouteType JPtype)
void	sendPIMPrune (Ipv4Address group, Ipv4Address source, Ipv4Address upstreamNeighbor, RouteType JPtype)
void	sendPIMAssert (Ipv4Address source, Ipv4Address group, AssertMetric metric, NetworkInterface *ie, bool rptBit)
void	sendToIP (Packet *packet, Ipv4Address source, Ipv4Address dest, int outInterfaceId, short ttl)
void	forwardMulticastData (Packet *pk, int outInterfaceId)
	The method is used as abstraction for encapsulation multicast data to Register packet. More...
double	joinPruneHoldTime ()
double	effectivePropagationDelay ()
double	effectiveOverrideInterval ()
double	joinPruneOverrideInterval ()
void	updateJoinDesired (Route *route)
void	updateDesignatedRouterAddress (NetworkInterface *ie)
void	updateCouldAssert (DownstreamInterface *interface)
void	updateAssertTrackingDesired (PimsmInterface *interface)
bool	IamRP (Ipv4Address rpAddr)
bool	IamDR (NetworkInterface *ie)
PimInterface *	getIncomingInterface (NetworkInterface *fromIE)
bool	deleteMulticastRoute (Route *route)
void	clearRoutes ()
void	cancelAndDeleteTimer (cMessage *&timer)
void	restartTimer (cMessage *timer, double interval)
void	restartExpiryTimer (Route *route, NetworkInterface *originIntf, int holdTime)
	The method is used to restart ET. More...
bool	removeRoute (Route *route)
Route *	findRouteG (Ipv4Address group)
Route *	findRouteSG (Ipv4Address source, Ipv4Address group)
Route *	addNewRouteG (Ipv4Address group, int flags)
Route *	addNewRouteSG (Ipv4Address source, Ipv4Address group, int flags)
Ipv4MulticastRoute *	createIpv4Route (Route *route)
Ipv4MulticastRoute *	findIpv4Route (Ipv4Address source, Ipv4Address group)

Private Attributes
Ipv4Address	rpAddr
double	joinPrunePeriod = 0
double	defaultOverrideInterval = 0
double	defaultPropagationDelay = 0
double	keepAlivePeriod = 0
double	rpKeepAlivePeriod = 0
double	registerSuppressionTime = 0
double	registerProbeTime = 0
double	assertTime = 0
double	assertOverrideInterval = 0
RoutingTable	gRoutes
RoutingTable	sgRoutes

Static Private Attributes
static simsignal_t	sentRegisterPkSignal = registerSignal("sentRegisterPk")
static simsignal_t	rcvdRegisterPkSignal = registerSignal("rcvdRegisterPk")
static simsignal_t	sentRegisterStopPkSignal = registerSignal("sentRegisterStopPk")
static simsignal_t	rcvdRegisterStopPkSignal = registerSignal("rcvdRegisterStopPk")
static simsignal_t	sentJoinPrunePkSignal = registerSignal("sentJoinPrunePk")
static simsignal_t	rcvdJoinPrunePkSignal = registerSignal("rcvdJoinPrunePk")
static simsignal_t	sentAssertPkSignal = registerSignal("sentAssertPk")
static simsignal_t	rcvdAssertPkSignal = registerSignal("rcvdAssertPk")

Friends
std::ostream &	operator<< (std::ostream &out, const PimSm::Route &sourceGroup)

Additional Inherited Members
Protected Types inherited from inet::PimBase
enum	PimTimerKind {   HelloTimer = 1, TriggeredHelloDelay, AssertTimer, PruneTimer,   PrunePendingTimer, GraftRetryTimer, UpstreamOverrideTimer, PruneLimitTimer,   SourceActiveTimer, StateRefreshTimer, KeepAliveTimer, RegisterStopTimer,   ExpiryTimer, JoinTimer }
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Attributes inherited from inet::PimBase
ModuleRefByPar< IIpv4RoutingTable >	rt
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< PimInterfaceTable >	pimIft
ModuleRefByPar< PimNeighborTable >	pimNbt
opp_component_ptr< Pim >	pimModule
bool	isUp = false
bool	isEnabled = false
const char *	hostname = nullptr
double	helloPeriod = 0
double	holdTime = 0
int	designatedRouterPriority = 0
PimInterface::PimMode	mode = static_cast<PimInterface::PimMode>(0)
uint32_t	generationID = 0
cMessage *	helloTimer = nullptr
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer
Static Protected Attributes inherited from inet::PimBase
static const Ipv4Address	ALL_PIM_ROUTERS_MCAST
static simsignal_t	sentHelloPkSignal = registerSignal("sentHelloPk")
static simsignal_t	rcvdHelloPkSignal = registerSignal("rcvdHelloPk")

Detailed Description

Implementation of PIM-SM protocol (RFC 4601).

Protocol state is stored in two tables:

• gRoutes table contains (*,G) state
• sgRoutes table contains (S,G) state Note that (*,*,RP) and (S,G,rpt) state is currently missing.

The routes stored in the tables are not the same as the routes of the Ipv4RoutingTable. The RFC defines the terms "Tree Information Base" (TIB) and "Multicast Forwaring Information Base" (MFIB). According to this division, TIB is the state of this module, while MFIB is stored by Ipv4RoutingTable.

Incoming packets, notifications, and timer events may cause a change of the TIB, and of the MFIB (if the forwarding rules change).

Member Typedef Documentation

DownstreamInterfaceVector

typedef std::vector<DownstreamInterface *> inet::PimSm::DownstreamInterfaceVector

private

RoutingTable

typedef std::map<SourceAndGroup, Route *> inet::PimSm::RoutingTable

private

Member Enumeration Documentation

RouteType

enum inet::PimSm::RouteType

private

Enumerator
RP
G
SG
SGrpt

                   {
        RP, // (*,*,RP)
        G, // (*,G)
        SG, // (S,G)
        SGrpt // (S,G,rpt)
    };

Constructor & Destructor Documentation

PimSm()

inet::PimSm::PimSm ( )

inline

: PimBase(PimInterface::SparseMode) {}

~PimSm()

inet::PimSm::~PimSm ( )

virtual

{
    for (auto& elem : gRoutes)
        delete elem.second;
    for (auto& elem : sgRoutes)
        delete elem.second;
    // TODO rt contains references to the deleted route entries
}

Member Function Documentation

addNewRouteG()

PimSm::Route * inet::PimSm::addNewRouteG ( Ipv4Address  group, int  flags  )

private

{
    Route *newRouteG = new Route(this, G, Ipv4Address::UNSPECIFIED_ADDRESS, group);
    newRouteG->setFlags(flags);
    newRouteG->rpAddr = rpAddr;
 
    // set upstream interface toward RP and set metric
    if (!IamRP(rpAddr)) {
        Ipv4Route *routeToRP = rt->findBestMatchingRoute(rpAddr);
        if (routeToRP) {
            NetworkInterface *ieTowardRP = routeToRP->getInterface();
            Ipv4Address rpfNeighbor = routeToRP->getGateway();
            if (!pimNbt->findNeighbor(ieTowardRP->getInterfaceId(), rpfNeighbor) &&
                pimNbt->getNumNeighbors(ieTowardRP->getInterfaceId()) > 0)
            {
                PimNeighbor *neighbor = pimNbt->getNeighbor(ieTowardRP->getInterfaceId(), 0);
                if (neighbor)
                    rpfNeighbor = neighbor->getAddress();
            }
            newRouteG->upstreamInterface = new UpstreamInterface(newRouteG, ieTowardRP, rpfNeighbor);
            newRouteG->metric = AssertMetric(true, routeToRP->getAdminDist(), routeToRP->getMetric());
        }
    }
 
    // add downstream interfaces
    for (int i = 0; i < pimIft->getNumInterfaces(); i++) {
        PimInterface *pimInterface = pimIft->getInterface(i);
        if (pimInterface->getMode() == PimInterface::SparseMode &&
            (!newRouteG->upstreamInterface || pimInterface->getInterfacePtr() != newRouteG->upstreamInterface->ie))
        {
            DownstreamInterface *downstream = new DownstreamInterface(newRouteG, pimInterface->getInterfacePtr(), DownstreamInterface::NO_INFO);
            newRouteG->addDownstreamInterface(downstream);
        }
    }
 
    SourceAndGroup sg(Ipv4Address::UNSPECIFIED_ADDRESS, group);
    gRoutes[sg] = newRouteG;
    rt->addMulticastRoute(createIpv4Route(newRouteG));
 
    // set (*,G) route in (S,G) and (S,G,rpt) routes
    for (auto& elem : sgRoutes) {
        if (elem.first.group == group) {
            Route *sgRoute = elem.second;
            sgRoute->gRoute = newRouteG;
        }
    }
 
    return newRouteG;
}

Referenced by multicastReceiverAdded(), processJoinG(), processRegisterPacket(), and unroutableMulticastPacketArrived().

addNewRouteSG()

PimSm::Route * inet::PimSm::addNewRouteSG ( Ipv4Address  source, Ipv4Address  group, int  flags  )

private

{
    ASSERT(!source.isUnspecified());
    ASSERT(group.isMulticast() && !group.isLinkLocalMulticast());
 
    Route *newRouteSG = new Route(this, SG, source, group);
    newRouteSG->setFlags(flags);
    newRouteSG->rpAddr = rpAddr;
 
    // set upstream interface toward source and set metric
    Ipv4Route *routeToSource = rt->findBestMatchingRoute(source);
    if (routeToSource) {
        NetworkInterface *ieTowardSource = routeToSource->getInterface();
        Ipv4Address rpfNeighbor = routeToSource->getGateway();
 
        if (rpfNeighbor.isUnspecified())
            newRouteSG->setFlag(Route::SOURCE_DIRECTLY_CONNECTED, true);
        else {
            if (!pimNbt->findNeighbor(ieTowardSource->getInterfaceId(), rpfNeighbor) &&
                pimNbt->getNumNeighbors(ieTowardSource->getInterfaceId()) > 0)
            {
                PimNeighbor *neighbor = pimNbt->getNeighbor(ieTowardSource->getInterfaceId(), 0);
                if (neighbor)
                    rpfNeighbor = neighbor->getAddress();
            }
        }
        newRouteSG->upstreamInterface = new UpstreamInterface(newRouteSG, ieTowardSource, rpfNeighbor);
        newRouteSG->metric = AssertMetric(false, routeToSource->getAdminDist(), routeToSource->getMetric());
    }
 
    // add downstream interfaces
    for (int i = 0; i < pimIft->getNumInterfaces(); i++) {
        PimInterface *pimInterface = pimIft->getInterface(i);
        if (pimInterface->getMode() == PimInterface::SparseMode && pimInterface->getInterfacePtr() != newRouteSG->upstreamInterface->ie) {
            DownstreamInterface *downstream = new DownstreamInterface(newRouteSG, pimInterface->getInterfacePtr(), DownstreamInterface::NO_INFO);
            newRouteSG->addDownstreamInterface(downstream);
        }
    }
 
    SourceAndGroup sg(source, group);
    sgRoutes[sg] = newRouteSG;
    rt->addMulticastRoute(createIpv4Route(newRouteSG));
 
    // set (*,G) route if exists
    newRouteSG->gRoute = findRouteG(group);
 
    // set (S,G,rpt) route if exists
    Route *sgrptRoute = nullptr; // TODO
    newRouteSG->sgrptRoute = sgrptRoute;
 
    // set (S,G) route in (S,G,rpt) route
    if (sgrptRoute) {
//        sgrptRoute->sgRoute = newRouteSG;
    }
 
    return newRouteSG;
}

Referenced by processJoinSG(), processRegisterPacket(), and unroutableMulticastPacketArrived().

cancelAndDeleteTimer()

void inet::PimSm::cancelAndDeleteTimer ( cMessage *&  timer )

private

{
    cancelAndDelete(timer);
    timer = nullptr;
}

Referenced by joinDesiredChanged(), processExpiryTimer(), processJoinG(), processJoinSG(), processPrunePendingTimer(), and processRegisterStopPacket().

clearRoutes()

void inet::PimSm::clearRoutes ( )

private

{
    // delete Ipv4 routes
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < rt->getNumMulticastRoutes(); i++) {
            Ipv4MulticastRoute *ipv4Route = rt->getMulticastRoute(i);
            if (ipv4Route->getSource() == this) {
                rt->deleteMulticastRoute(ipv4Route);
                changed = true;
                break;
            }
        }
    }
 
    // clear local tables
    for (auto& elem : gRoutes)
        delete elem.second;
    gRoutes.clear();
 
    for (auto& elem : sgRoutes)
        delete elem.second;
    sgRoutes.clear();
}

Referenced by stopPIMRouting().

createIpv4Route()

Ipv4MulticastRoute * inet::PimSm::createIpv4Route ( Route *  route )

private

{
    Ipv4MulticastRoute *newRoute = new Ipv4MulticastRoute();
    newRoute->setOrigin(route->source);
    newRoute->setOriginNetmask(route->source.isUnspecified() ? Ipv4Address::UNSPECIFIED_ADDRESS : Ipv4Address::ALLONES_ADDRESS);
    newRoute->setMulticastGroup(route->group);
    newRoute->setSourceType(IMulticastRoute::PIM_SM);
    newRoute->setSource(this);
    if (route->upstreamInterface)
        newRoute->setInInterface(new IMulticastRoute::InInterface(route->upstreamInterface->ie));
    unsigned int numOutInterfaces = route->downstreamInterfaces.size();
    for (unsigned int i = 0; i < numOutInterfaces; ++i) {
        DownstreamInterface *downstream = route->downstreamInterfaces[i];
        newRoute->addOutInterface(new PimSmOutInterface(downstream));
    }
    return newRoute;
}

Referenced by addNewRouteG(), and addNewRouteSG().

deleteMulticastRoute()

bool inet::PimSm::deleteMulticastRoute ( Route *  route )

private

{
    if (removeRoute(route)) {
        // remove route from Ipv4 routing table
        Ipv4MulticastRoute *ipv4Route = findIpv4Route(route->source, route->group);
        if (ipv4Route)
            rt->deleteMulticastRoute(ipv4Route);
 
        // unlink
        if (route->type == G) {
            for (auto& elem : sgRoutes)
                if (elem.second->gRoute == route)
                    elem.second->gRoute = nullptr;
 
        }
 
        delete route;
        return true;
    }
    return false;
}

Referenced by processExpiryTimer(), and processKeepAliveTimer().

designatedRouterAddressHasChanged()

void inet::PimSm::designatedRouterAddressHasChanged ( NetworkInterface *  ie )

private

{
    // TODO
}

Referenced by updateDesignatedRouterAddress().

effectiveOverrideInterval()

double inet::PimSm::effectiveOverrideInterval ( )

inlineprivate

{ return defaultOverrideInterval; }

effectivePropagationDelay()

double inet::PimSm::effectivePropagationDelay ( )

inlineprivate

{ return defaultPropagationDelay; }

findIpv4Route()

Ipv4MulticastRoute * inet::PimSm::findIpv4Route ( Ipv4Address  source, Ipv4Address  group  )

private

{
    unsigned int numMulticastRoutes = rt->getNumMulticastRoutes();
    for (unsigned int i = 0; i < numMulticastRoutes; ++i) {
        Ipv4MulticastRoute *ipv4Route = rt->getMulticastRoute(i);
        if (ipv4Route->getSource() == this && ipv4Route->getOrigin() == source && ipv4Route->getMulticastGroup() == group)
            return ipv4Route;
    }
    return nullptr;
}

Referenced by deleteMulticastRoute().

findRouteG()

PimSm::Route * inet::PimSm::findRouteG ( Ipv4Address  group )

private

{
    SourceAndGroup sg(Ipv4Address::UNSPECIFIED_ADDRESS, group);
    auto it = gRoutes.find(sg);
    return it != gRoutes.end() ? it->second : nullptr;
}

Referenced by addNewRouteSG(), multicastPacketArrivedOnNonRpfInterface(), multicastReceiverAdded(), multicastReceiverRemoved(), processAssertPacket(), processJoinG(), processPruneG(), processRegisterPacket(), receiveSignal(), and sendPIMRegisterNull().

findRouteSG()

PimSm::Route * inet::PimSm::findRouteSG ( Ipv4Address  source, Ipv4Address  group  )

private

{
    ASSERT(!source.isUnspecified());
    SourceAndGroup sg(source, group);
    auto it = sgRoutes.find(sg);
    return it != sgRoutes.end() ? it->second : nullptr;
}

Referenced by multicastPacketForwarded(), processAssertPacket(), processJoinSG(), processPruneSG(), processRegisterPacket(), processRegisterStopPacket(), and receiveSignal().

forwardMulticastData()

void inet::PimSm::forwardMulticastData ( Packet *  data, int  outInterfaceId  )

private

The method is used as abstraction for encapsulation multicast data to Register packet.

The method create message MultData with multicast source address and multicast group address and send the message from RP to RPT.

{
    EV << "pimSM::forwardMulticastData" << endl;
 
    //
    // Note: we should inject the datagram somehow into the normal Ipv4 forwarding path.
    //
    const auto& ipv4Header = data->popAtFront<Ipv4Header>();
 
    // set control info
    data->addTagIfAbsent<PacketProtocolTag>()->setProtocol(ipv4Header->getProtocol());
    data->addTagIfAbsent<InterfaceReq>()->setInterfaceId(outInterfaceId);
    auto addrTag = data->addTagIfAbsent<L3AddressReq>();
    addrTag->setSrcAddress(ipv4Header->getSrcAddress());
    addrTag->setNonLocalSrcAddress(true);
    addrTag->setDestAddress(ipv4Header->getDestAddress());
    data->addTagIfAbsent<HopLimitReq>()->setHopLimit(MAX_TTL - 2); // one minus for source DR router and one for RP router // TODO specification???
    data->trim();
    send(data, "ipOut");
}

Referenced by processRegisterPacket().

getIncomingInterface()

PimInterface * inet::PimSm::getIncomingInterface ( NetworkInterface *  fromIE )

private

{
    if (fromIE)
        return pimIft->getInterfaceById(fromIE->getInterfaceId());
    return nullptr;
}

Referenced by receiveSignal().

handleCrashOperation()

void inet::PimSm::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::PimBase.

{
    stopPIMRouting();
    PimBase::handleCrashOperation(operation);
}

handleMessageWhenUp()

void inet::PimSm::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage()) {
        switch (msg->getKind()) {
            case HelloTimer:
                processHelloTimer(msg);
                break;
 
            case JoinTimer:
                processJoinTimer(msg);
                break;
 
            case PrunePendingTimer:
                processPrunePendingTimer(msg);
                break;
 
            case ExpiryTimer:
                processExpiryTimer(msg);
                break;
 
            case KeepAliveTimer:
                processKeepAliveTimer(msg);
                break;
 
            case RegisterStopTimer:
                processRegisterStopTimer(msg);
                break;
 
            case AssertTimer:
                processAssertTimer(msg);
                break;
 
            default:
                throw cRuntimeError("PimSm: unknown self message: %s (%s)", msg->getName(), msg->getClassName());
        }
    }
    else {
        Packet *pk = check_and_cast<Packet *>(msg);
        const auto& pkt = pk->peekAtFront<PimPacket>();
        if (pkt == nullptr)
            throw cRuntimeError("PIM-SM: received unknown message: %s (%s).", msg->getName(), msg->getClassName());
        if (!isEnabled) {
            EV_DETAIL << "PIM-SM is disabled, dropping packet.\n";
            delete msg;
            return;
        }
 
        switch (pkt->getType()) {
            case Hello:
                processHelloPacket(pk);
                break;
 
            case JoinPrune:
                processJoinPrunePacket(pk);
                break;
 
            case Register:
                processRegisterPacket(pk);
                break;
 
            case RegisterStop:
                processRegisterStopPacket(pk);
                break;
 
            case Assert:
                processAssertPacket(pk);
                break;
 
            case Graft:
                EV_WARN << "Ignoring PIM-DM Graft packet.\n";
                delete pk;
                break;
 
            case GraftAck:
                EV_WARN << "Ignoring PIM-DM GraftAck packet.\n";
                delete pk;
                break;
 
            case StateRefresh:
                EV_WARN << "Ignoring PIM-DM StateRefresh packet.\n";
                delete pk;
                break;
 
            case Bootstrap:
                delete pk;
                break;
 
            case CandidateRPAdvertisement:
                delete pk;
                break;
 
            default:
                throw cRuntimeError("PimSm: received unknown PIM packet: %s (%s)", pk->getName(), pk->getClassName());
        }
    }
}

handleStartOperation()

void inet::PimSm::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::PimBase.

{
    PimBase::handleStartOperation(operation);
 
    if (isEnabled) {
        if (rpAddr.isUnspecified())
            throw cRuntimeError("PimSm: missing RP address parameter.");
 
        // subscribe for notifications
        cModule *host = findContainingNode(this);
        if (!host)
            throw cRuntimeError("PimDm: containing node not found.");
        host->subscribe(ipv4NewMulticastSignal, this);
        host->subscribe(ipv4MdataRegisterSignal, this);
        host->subscribe(ipv4DataOnRpfSignal, this);
        host->subscribe(ipv4DataOnNonrpfSignal, this);
        host->subscribe(ipv4MulticastGroupRegisteredSignal, this);
        host->subscribe(ipv4MulticastGroupUnregisteredSignal, this);
        host->subscribe(pimNeighborAddedSignal, this);
        host->subscribe(pimNeighborDeletedSignal, this);
        host->subscribe(pimNeighborChangedSignal, this);
 
        WATCH_PTRMAP(gRoutes);
        WATCH_PTRMAP(sgRoutes);
    }
}

handleStopOperation()

void inet::PimSm::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Reimplemented from inet::PimBase.

{
    // TODO send PIM Hellos to neighbors with 0 HoldTime
    stopPIMRouting();
    PimBase::handleStopOperation(operation);
}

IamDR()

bool inet::PimSm::IamDR ( NetworkInterface *  ie )

private

{
    PimInterface *pimInterface = pimIft->getInterfaceById(ie->getInterfaceId());
    ASSERT(pimInterface);
    Ipv4Address drAddress = pimInterface->getDRAddress();
    return drAddress.isUnspecified() || drAddress == ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
}

iAmDRHasChanged()

void inet::PimSm::iAmDRHasChanged ( NetworkInterface *  ie, bool  iAmDR  )

private

{
    // TODO
}

Referenced by updateDesignatedRouterAddress().

IamRP()

bool inet::PimSm::IamRP ( Ipv4Address  rpAddr )

inlineprivate

{ return rt->isLocalAddress(rpAddr); }

Referenced by addNewRouteG(), and processExpiryTimer().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::PimBase.

{
    PimBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        const char *rp = par("RP");
        if (rp && *rp)
            rpAddr = Ipv4Address(rp);
 
        joinPrunePeriod = par("joinPrunePeriod");
        defaultOverrideInterval = par("defaultOverrideInterval");
        defaultPropagationDelay = par("defaultPropagationDelay");
        keepAlivePeriod = par("keepAlivePeriod");
        rpKeepAlivePeriod = par("rpKeepAlivePeriod");
        registerSuppressionTime = par("registerSuppressionTime");
        registerProbeTime = par("registerProbeTime");
        assertTime = par("assertTime");
        assertOverrideInterval = par("assertOverrideInterval");
    }
}

joinDesiredChanged()

void inet::PimSm::joinDesiredChanged ( Route *  route )

private

{
    if (route->type == G) {
        Route *routeG = route;
 
        if (routeG->isFlagSet(Route::PRUNED) && routeG->joinDesired()) {
            //
            // Upstream (*,G) State Machine; event: JoinDesired(S,G) -> TRUE
            //
            routeG->clearFlag(Route::PRUNED);
            if (routeG->upstreamInterface) {
                sendPIMJoin(routeG->group, routeG->rpAddr, routeG->upstreamInterface->rpfNeighbor(), G);
                routeG->startJoinTimer(joinPrunePeriod);
            }
        }
        else if (!routeG->isFlagSet(Route::PRUNED) && !routeG->joinDesired()) {
            //
            // Upstream (*,G) State Machine; event: JoinDesired(S,G) -> FALSE
            //
            routeG->setFlags(Route::PRUNED);
            cancelAndDeleteTimer(routeG->joinTimer);
            if (routeG->upstreamInterface)
                sendPIMPrune(routeG->group, routeG->rpAddr, routeG->upstreamInterface->rpfNeighbor(), G);
        }
    }
    else if (route->type == SG) {
        Route *routeSG = route;
 
        if (routeSG->isFlagSet(Route::PRUNED) && routeSG->joinDesired()) {
            //
            // Upstream (S,G) State Machine; event: JoinDesired(S,G) -> TRUE
            //
            routeSG->clearFlag(Route::PRUNED);
            if (!routeSG->isSourceDirectlyConnected()) {
                sendPIMJoin(routeSG->group, routeSG->source, routeSG->upstreamInterface->rpfNeighbor(), SG);
                routeSG->startJoinTimer(joinPrunePeriod);
            }
        }
        else if (!routeSG->isFlagSet(Route::PRUNED) && !route->joinDesired()) {
            //
            // Upstream (S,G) State Machine; event: JoinDesired(S,G) -> FALSE
            //
 
            // The upstream (S,G) state machine transitions to NotJoined
            // state.  Send Prune(S,G) to the appropriate upstream neighbor,
            // which is RPF'(S,G).  Cancel the Join Timer (JT), and set
            // SPTbit(S,G) to FALSE.
            routeSG->setFlags(Route::PRUNED);
            routeSG->clearFlag(Route::SPT_BIT);
            cancelAndDeleteTimer(routeSG->joinTimer);
            if (!routeSG->isSourceDirectlyConnected())
                sendPIMPrune(routeSG->group, routeSG->source, routeSG->upstreamInterface->rpfNeighbor(), SG);
        }
    }
}

Referenced by updateJoinDesired().

joinPruneHoldTime()

double inet::PimSm::joinPruneHoldTime ( )

inlineprivate

{ return 3.5 * joinPrunePeriod; } // Holdtime in Join/Prune messages

Referenced by sendPIMJoin(), and sendPIMPrune().

joinPruneOverrideInterval()

double inet::PimSm::joinPruneOverrideInterval ( )

inlineprivate

{ return effectivePropagationDelay() + effectiveOverrideInterval(); }

Referenced by processPruneG(), processPruneSG(), and inet::PimSm::DownstreamInterface::startPrunePendingTimer().

multicastPacketArrivedOnNonRpfInterface()

void inet::PimSm::multicastPacketArrivedOnNonRpfInterface ( Route *  route, int  interfaceId  )

private

{
    if (route->type == G || route->type == SG) {
        //
        // (S,G) Assert State Machine; event: An (S,G) data packet arrives on interface I
        // OR
        // (*,G) Assert State Machine; event: A data packet destined for G arrives on interface I
        //
        DownstreamInterface *downstream = route->findDownstreamInterfaceByInterfaceId(interfaceId);
        if (downstream && downstream->couldAssert() && downstream->assertState == Interface::NO_ASSERT_INFO) {
            // An (S,G) data packet arrived on an downstream interface that
            // is in our (S,G) or (*,G) outgoing interface list.  We optimistically
            // assume that we will be the assert winner for this (S,G) or (*,G), and
            // so we transition to the "I am Assert Winner" state and perform
            // Actions A1 (below), which will initiate the assert negotiation
            // for (S,G) or (*,G).
            downstream->assertState = Interface::I_WON_ASSERT;
            downstream->winnerMetric = route->metric.setAddress(downstream->ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
            sendPIMAssert(route->source, route->group, downstream->winnerMetric, downstream->ie, route->type == G);
            downstream->startAssertTimer(assertTime - assertOverrideInterval);
        }
        else if (route->type == SG && (!downstream || downstream->assertState == Interface::NO_ASSERT_INFO)) {
            // When in NO_ASSERT_INFO state before and after consideration of the received message,
            // then call (*,G) assert processing.
            Route *routeG = findRouteG(route->group);
            if (routeG)
                multicastPacketArrivedOnNonRpfInterface(routeG, interfaceId);
        }
    }
}

Referenced by receiveSignal().

multicastPacketArrivedOnRpfInterface()

void inet::PimSm::multicastPacketArrivedOnRpfInterface ( Route *  route )

private

The method process notification about data which appears on RPF interface.

It means that source is still active. The result is resetting of Keep Alive Timer. Also if first data packet arrive to last hop router in RPT, switchover to SPT has to be considered.

{
    if (route->type == SG) { // (S,G) route
        // set KeepAlive timer
        if ( /*DirectlyConnected(route->source) ||*/
            (!route->isFlagSet(Route::PRUNED) && !route->isInheritedOlistNull()))
        {
            EV_DETAIL << "Data arrived on RPF interface, restarting KAT(" << route->source << ", " << route->group << ") timer.\n";
 
            if (!route->keepAliveTimer)
                route->startKeepAliveTimer(keepAlivePeriod);
            else
                restartTimer(route->keepAliveTimer, keepAlivePeriod);
        }
 
        // Update SPT bit
 
        /* TODO
             void
             Update_SPTbit(S,G,iif) {
               if ( iif == RPF_interface(S)
                     AND JoinDesired(S,G) == TRUE
                     AND ( DirectlyConnected(S) == TRUE
                           OR RPF_interface(S) != RPF_interface(RP(G))
                           OR inherited_olist(S,G,rpt) == nullptr
                           OR ( ( RPF'(S,G) == RPF'(*,G) ) AND
                                ( RPF'(S,G) != nullptr ) )
                           OR ( I_Am_Assert_Loser(S,G,iif) ) {
                  Set SPTbit(S,G) to TRUE
               }
             }
         */
        route->setFlags(Route::SPT_BIT);
    }
 
    // check switch from RP tree to the SPT
    if (route->isFlagSet(Route::SPT_BIT)) {
        /*
             void
             CheckSwitchToSpt(S,G) {
               if ( ( pim_include(*,G) (-) pim_exclude(S,G)
                      (+) pim_include(S,G) != nullptr )
                    AND SwitchToSptDesired(S,G) ) {
         # Note: Restarting the KAT will result in the SPT switch
                      set KeepaliveTimer(S,G) to Keepalive_Period
               }
             }
         */
    }
}

Referenced by receiveSignal().

multicastPacketForwarded()

void inet::PimSm::multicastPacketForwarded ( Packet *  pk )

private

{
    const auto& ipv4Header = pk->peekAtFront<Ipv4Header>();
    Ipv4Address source = ipv4Header->getSrcAddress();
    Ipv4Address group = ipv4Header->getDestAddress();
 
    Route *routeSG = findRouteSG(source, group);
    if (!routeSG || !routeSG->isFlagSet(Route::REGISTER) || !routeSG->isFlagSet(Route::PRUNED))
        return;
 
    // send Register message to RP
 
    if (routeSG->registerState == Route::RS_JOIN) {
        // refresh KAT timer
        if (routeSG->keepAliveTimer) {
            EV << " (S,G) KAT timer refresh" << endl;
            restartTimer(routeSG->keepAliveTimer, KAT);
        }
 
        NetworkInterface *interfaceTowardRP = rt->getInterfaceForDestAddr(routeSG->rpAddr);
        ASSERT(interfaceTowardRP != nullptr);
        sendPIMRegister(pk, routeSG->rpAddr, interfaceTowardRP->getInterfaceId());
    }
}

Referenced by receiveSignal().

multicastReceiverAdded()

void inet::PimSm::multicastReceiverAdded ( NetworkInterface *  ie, Ipv4Address  group  )

private

{
    EV_DETAIL << "Multicast receiver added for group " << group << " on interface '" << ie->getInterfaceName() << "'.\n";
 
    Route *routeG = findRouteG(group);
    if (!routeG)
        routeG = addNewRouteG(group, Route::PRUNED);
 
    DownstreamInterface *downstream = routeG->getDownstreamInterfaceByInterfaceId(ie->getInterfaceId());
    downstream->setLocalReceiverInclude(true);
 
    updateJoinDesired(routeG);
}

Referenced by receiveSignal().

multicastReceiverRemoved()

void inet::PimSm::multicastReceiverRemoved ( NetworkInterface *  ie, Ipv4Address  group  )

private

{
    EV_DETAIL << "No more receiver for group " << group << " on interface '" << ie->getInterfaceName() << "'.\n";
 
    Route *routeG = findRouteG(group);
    if (routeG) {
        DownstreamInterface *downstream = routeG->getDownstreamInterfaceByInterfaceId(ie->getInterfaceId());
        downstream->setLocalReceiverInclude(false);
        updateJoinDesired(routeG);
    }
}

Referenced by receiveSignal().

numInitStages()

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

inlineoverrideprotectedvirtual

Reimplemented from inet::PimBase.

{ return NUM_INIT_STAGES; }

processAssertG()

void inet::PimSm::processAssertG ( PimsmInterface *  interface, const AssertMetric &  receivedMetric  )

private

{
    Route *routeG = interface->route();
    AssertMetric myMetric = interface->couldAssert() ?
        routeG->metric.setAddress(interface->ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress()) :
        AssertMetric::PIM_INFINITE;
 
    // A "preferred assert" is one with a better metric than the current winner.
    bool isPreferredAssert = receivedMetric < interface->winnerMetric;
 
    // An "acceptable assert" is one that has a better metric than my_assert_metric(S,G,I).
    // An assert is never considered acceptable if its metric is infinite.
    bool isAcceptableAssert = receivedMetric < myMetric;
 
    // An "inferior assert" is one with a worse metric than my_assert_metric(S,G,I).
    // An assert is never considered inferior if my_assert_metric(S,G,I) is infinite.
    bool isInferiorAssert = myMetric < receivedMetric;
 
    if (interface->assertState == Interface::NO_ASSERT_INFO) {
        if (isInferiorAssert && receivedMetric.rptBit && interface->couldAssert()) {
            // An Inferior (*,G) assert is received for G on Interface I.  If
            // CouldAssert(*,G,I) is TRUE, then I is our downstream
            // interface, and we have (*,G) forwarding state on this
            // interface, so we should be the assert winner.  We transition
            // to the "I am Assert Winner" state and perform Actions:
            interface->assertState = Interface::I_WON_ASSERT;
            sendPIMAssert(Ipv4Address::UNSPECIFIED_ADDRESS, routeG->group, myMetric, interface->ie, true);
            interface->startAssertTimer(assertTime - assertOverrideInterval);
            interface->winnerMetric = myMetric;
        }
        else if (isAcceptableAssert && receivedMetric.rptBit && interface->assertTrackingDesired()) {
            // We're interested in (*,G) Asserts, either because I is a
            // downstream interface for which we have (*,G) forwarding state,
            // or because I is the upstream interface for RP(G) and we have
            // (*,G) forwarding state.  We get a (*,G) Assert that has a
            // better metric than our own, so we do not win the Assert.  We
            // transition to "I am Assert Loser" and perform Actions:
            interface->assertState = Interface::I_LOST_ASSERT;
            interface->winnerMetric = receivedMetric;
            interface->startAssertTimer(assertTime);
        }
    }
    else if (interface->assertState == Interface::I_WON_ASSERT) {
        if (isInferiorAssert) {
            // We receive a (*,G) assert that has a worse metric than our
            // own.  Whoever sent the assert has lost, and so we resend a
            // (*,G) Assert and restart the Assert Timer (Actions A3 below).
            sendPIMAssert(Ipv4Address::UNSPECIFIED_ADDRESS, routeG->group, myMetric, interface->ie, true);
            restartTimer(interface->assertTimer, assertTime - assertOverrideInterval);
        }
        else if (isPreferredAssert) {
            // We receive a (*,G) assert that has a better metric than our
            // own.  We transition to "I am Assert Loser" state and perform
            // Actions A2 (below).
            interface->assertState = Interface::I_LOST_ASSERT;
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
    }
    else if (interface->assertState == Interface::I_LOST_ASSERT) {
        if (isPreferredAssert && receivedMetric.rptBit) {
            // We receive a (*,G) assert that is better than that of the
            // current assert winner.  We stay in Loser state and perform
            // Actions A2 below.
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
        else if (isAcceptableAssert && receivedMetric.address == interface->winnerMetric.address && receivedMetric.rptBit) {
            // We receive a (*,G) assert from the current assert winner that
            // is better than our own metric for this group (although the
            // metric may be worse than the winner's previous metric).  We
            // stay in Loser state and perform Actions A2 below.
            // interface->winnerAddress = ...;
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
        else if (isInferiorAssert /*or AssertCancel*/ && receivedMetric.address == interface->winnerMetric.address) {
            // We receive an assert from the current assert winner that is
            // worse than our own metric for this group (typically because
            // the winner's metric became worse or is now an assert cancel).
            // We transition to NoInfo state, delete this (*,G) assert state
            // (Actions A5), and allow the normal PIM Join/Prune mechanisms
            // to operate.  Usually, we will eventually re-assert and win
            // when data packets for G have started flowing again.
            interface->deleteAssertInfo();
        }
    }
}

Referenced by processAssertPacket().

processAssertPacket()

void inet::PimSm::processAssertPacket ( Packet *  pk )

private

{
    const auto& pkt = pk->peekAtFront<PimAssert>();
    int incomingInterfaceId = pk->getTag<InterfaceInd>()->getInterfaceId();
    Ipv4Address source = pkt->getSourceAddress().unicastAddress.toIpv4();
    Ipv4Address group = pkt->getGroupAddress().groupAddress.toIpv4();
    AssertMetric receivedMetric = AssertMetric(pkt->getR(), pkt->getMetricPreference(), pkt->getMetric(), pk->getTag<L3AddressInd>()->getSrcAddress().toIpv4());
 
    EV_INFO << "Received Assert(" << (source.isUnspecified() ? "*" : source.str()) << ", " << group << ")"
            << " packet on interface '" << ift->getInterfaceById(incomingInterfaceId)->getInterfaceName() << "'.\n";
 
    emit(rcvdAssertPkSignal, pk);
 
    if (!source.isUnspecified() && !receivedMetric.rptBit) {
        Route *routeSG = findRouteSG(source, group);
        if (routeSG) {
            PimsmInterface *incomingInterface = routeSG->upstreamInterface->getInterfaceId() == incomingInterfaceId ?
                static_cast<PimsmInterface *>(routeSG->upstreamInterface) :
                static_cast<PimsmInterface *>(routeSG->getDownstreamInterfaceByInterfaceId(incomingInterfaceId));
            ASSERT(incomingInterface);
 
            Interface::AssertState stateBefore = incomingInterface->assertState;
            processAssertSG(incomingInterface, receivedMetric);
 
            if (stateBefore != Interface::NO_ASSERT_INFO || incomingInterface->assertState != Interface::NO_ASSERT_INFO) {
                // processed by SG
                delete pk;
                return;
            }
        }
    }
 
    // process (*,G) asserts and (S,G) asserts for which there is no assert state in (S,G) routes
    Route *routeG = findRouteG(group);
    if (routeG) {
        PimsmInterface *incomingInterface = routeG->upstreamInterface->getInterfaceId() == incomingInterfaceId ?
            static_cast<PimsmInterface *>(routeG->upstreamInterface) :
            static_cast<PimsmInterface *>(routeG->getDownstreamInterfaceByInterfaceId(incomingInterfaceId));
        ASSERT(incomingInterface);
        processAssertG(incomingInterface, receivedMetric);
    }
 
    delete pk;
}

Referenced by handleMessageWhenUp().

processAssertSG()

void inet::PimSm::processAssertSG ( PimsmInterface *  interface, const AssertMetric &  receivedMetric  )

private

{
    Route *routeSG = interface->route();
    AssertMetric myMetric = interface->couldAssert() ? // TODO check routeG metric too
        routeSG->metric.setAddress(interface->ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress()) :
        AssertMetric::PIM_INFINITE;
 
    // A "preferred assert" is one with a better metric than the current winner.
    bool isPreferredAssert = receivedMetric < interface->winnerMetric;
 
    // An "acceptable assert" is one that has a better metric than my_assert_metric(S,G,I).
    // An assert is never considered acceptable if its metric is infinite.
    bool isAcceptableAssert = receivedMetric < myMetric;
 
    // An "inferior assert" is one with a worse metric than my_assert_metric(S,G,I).
    // An assert is never considered inferior if my_assert_metric(S,G,I) is infinite.
    bool isInferiorAssert = myMetric < receivedMetric;
 
    if (interface->assertState == Interface::NO_ASSERT_INFO) {
        if (isInferiorAssert && !receivedMetric.rptBit && interface->couldAssert()) {
            // An assert is received for (S,G) with the RPT bit cleared that
            // is inferior to our own assert metric.  The RPT bit cleared
            // indicates that the sender of the assert had (S,G) forwarding
            // state on this interface.  If the assert is inferior to our
            // metric, then we must also have (S,G) forwarding state (i.e.,
            // CouldAssert(S,G,I)==TRUE) as (S,G) asserts beat (*,G) asserts,
            // and so we should be the assert winner.  We transition to the
            // "I am Assert Winner" state and perform Actions A1 (below).
            interface->assertState = Interface::I_WON_ASSERT;
            interface->winnerMetric = myMetric;
            sendPIMAssert(routeSG->source, routeSG->group, myMetric, interface->ie, false);
            interface->startAssertTimer(assertTime - assertOverrideInterval);
        }
        else if (receivedMetric.rptBit && interface->couldAssert()) {
            // An assert is received for (S,G) on I with the RPT bit set
            // (it's a (*,G) assert).  CouldAssert(S,G,I) is TRUE only if we
            // have (S,G) forwarding state on this interface, so we should be
            // the assert winner.  We transition to the "I am Assert Winner"
            // state and perform Actions A1 (below).
            interface->assertState = Interface::I_WON_ASSERT;
            interface->winnerMetric = myMetric;
            sendPIMAssert(routeSG->source, routeSG->group, myMetric, interface->ie, false);
            interface->startAssertTimer(assertTime - assertOverrideInterval);
        }
        else if (isAcceptableAssert && !receivedMetric.rptBit && interface->assertTrackingDesired()) {
            // We're interested in (S,G) Asserts, either because I is a
            // downstream interface for which we have (S,G) or (*,G)
            // forwarding state, or because I is the upstream interface for S
            // and we have (S,G) forwarding state.  The received assert has a
            // better metric than our own, so we do not win the Assert.  We
            // transition to "I am Assert Loser" and perform Actions A6
            // (below).
            interface->assertState = Interface::I_LOST_ASSERT;
            interface->winnerMetric = receivedMetric;
            interface->startAssertTimer(assertTime);
            // TODO If (I is RPF_interface(S)) AND (UpstreamJPState(S,G) == true)
            //      set SPTbit(S,G) to TRUE.
        }
    }
    else if (interface->assertState == Interface::I_WON_ASSERT) {
        if (isInferiorAssert) {
            // We receive an (S,G) assert or (*,G) assert mentioning S that
            // has a worse metric than our own.  Whoever sent the assert is
            // in error, and so we resend an (S,G) Assert and restart the
            // Assert Timer (Actions A3 below).
            sendPIMAssert(routeSG->source, routeSG->group, myMetric, interface->ie, false);
            restartTimer(interface->assertTimer, assertTime - assertOverrideInterval);
        }
        else if (isPreferredAssert) {
            // We receive an (S,G) assert that has a better metric than our
            // own.  We transition to "I am Assert Loser" state and perform
            // Actions A2 (below).  Note that this may affect the value of
            // JoinDesired(S,G) and PruneDesired(S,G,rpt), which could cause
            // transitions in the upstream (S,G) or (S,G,rpt) state machines.
            interface->assertState = Interface::I_LOST_ASSERT;
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
    }
    else if (interface->assertState == Interface::I_LOST_ASSERT) {
        if (isPreferredAssert) {
            // We receive an assert that is better than that of the current
            // assert winner.  We stay in Loser state and perform Actions A2
            // below.
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
        else if (isAcceptableAssert && !receivedMetric.rptBit && receivedMetric.address == interface->winnerMetric.address) {
            // We receive an assert from the current assert winner that is
            // better than our own metric for this (S,G) (although the metric
            // may be worse than the winner's previous metric).  We stay in
            // Loser state and perform Actions A2 below.
            interface->winnerMetric = receivedMetric;
            restartTimer(interface->assertTimer, assertTime);
        }
        else if (isInferiorAssert /* or AssertCancel */ && receivedMetric.address == interface->winnerMetric.address) {
            // We receive an assert from the current assert winner that is
            // worse than our own metric for this group (typically, because
            // the winner's metric became worse or because it is an assert
            // cancel).  We transition to NoInfo state, deleting the (S,G)
            // assert information and allowing the normal PIM Join/Prune
            // mechanisms to operate.  Usually, we will eventually re-assert
            // and win when data packets from S have started flowing again.
            interface->deleteAssertInfo();
        }
    }
}

Referenced by processAssertPacket().

processAssertTimer()

void inet::PimSm::processAssertTimer ( cMessage *  timer )

private

{
    PimsmInterface *interfaceData = static_cast<PimsmInterface *>(timer->getContextPointer());
    ASSERT(timer == interfaceData->assertTimer);
    ASSERT(interfaceData->assertState != Interface::NO_ASSERT_INFO);
 
    Route *route = interfaceData->route();
    if (route->type == SG || route->type == G) {
        //
        // (S,G) Assert State Machine; event: AT(S,G,I) expires OR
        // (*,G) Assert State Machine; event: AT(*,G,I) expires
        //
        EV_DETAIL << "AssertTimer(" << (route->type == G ? "*" : route->source.str()) << ", "
                  << route->group << ", " << interfaceData->ie->getInterfaceName() << ") has expired.\n";
 
        if (interfaceData->assertState == Interface::I_WON_ASSERT) {
            // The (S,G) or (*,G) Assert Timer expires.  As we're in the Winner state,
            // we must still have (S,G) or (*,G) forwarding state that is actively
            // being kept alive.  We resend the (S,G) or (*,G) Assert and restart the
            // Assert Timer.  Note that the assert
            // winner's Assert Timer is engineered to expire shortly before
            // timers on assert losers; this prevents unnecessary thrashing
            // of the forwarder and periodic flooding of duplicate packets.
            sendPIMAssert(route->source, route->group, route->metric, interfaceData->ie, route->type == G);
            restartTimer(interfaceData->assertTimer, assertTime - assertOverrideInterval);
            return;
        }
        else if (interfaceData->assertState == Interface::I_LOST_ASSERT) {
            // The (S,G) or (*,G) Assert Timer expires.  We transition to NoInfo
            // state, deleting the (S,G) or (*,G) assert information.
            EV_DEBUG << "Going into NO_ASSERT_INFO state.\n";
            interfaceData->deleteAssertInfo(); // deleted timer
            return;
        }
    }
 
    delete timer;
}

Referenced by handleMessageWhenUp().

processExpiryTimer()

void inet::PimSm::processExpiryTimer ( cMessage *  timer )

private

The method is used to process PIM Expiry Timer.

It is timer for (S,G) and (*,G). When Expiry timer expires,route is removed from multicast routing table.

{
    EV << "pimSM::processExpiryTimer: " << endl;
 
    PimsmInterface *interface = static_cast<PimsmInterface *>(timer->getContextPointer());
    Route *route = interface->route();
 
    if (interface != route->upstreamInterface) {
        //
        // Downstream Join/Prune State Machine; event: ET expires
        //
        DownstreamInterface *downstream = check_and_cast<DownstreamInterface *>(interface);
        downstream->joinPruneState = DownstreamInterface::NO_INFO;
        cancelAndDeleteTimer(downstream->prunePendingTimer);
        downstream->expiryTimer = nullptr;
        delete timer;
 
        // upstream state machine
        if (route->isInheritedOlistNull()) {
            route->setFlags(Route::PRUNED);
            if (route->type == G && !IamRP(route->rpAddr))
                sendPIMPrune(route->group, route->rpAddr, route->upstreamInterface->rpfNeighbor(), G);
            else if (route->type == SG)
                sendPIMPrune(route->group, route->source, route->upstreamInterface->rpfNeighbor(), SG);
 
            cancelAndDeleteTimer(route->joinTimer);
        }
    }
    if (route->upstreamInterface->expiryTimer && interface == route->upstreamInterface) {
        for (unsigned i = 0; i < route->downstreamInterfaces.size();) {
            if (route->downstreamInterfaces[i]->expiryTimer)
                route->removeDownstreamInterface(i);
            else
                i++;
        }
        if (IamRP(rpAddr) && route->type == G) {
            EV << "ET for (*,G) route on RP expires - go to stopped" << endl;
            cancelAndDeleteTimer(route->upstreamInterface->expiryTimer);
        }
        else
            deleteMulticastRoute(route);
    }
}

Referenced by handleMessageWhenUp().

processJoinG()

void inet::PimSm::processJoinG ( Ipv4Address  group, Ipv4Address  rp, Ipv4Address  upstreamNeighborField, int  holdTime, NetworkInterface *  inInterface  )

private

{
    EV_DETAIL << "Processing Join(*," << group << ") received on interface '" << inInterface->getInterfaceName() << "'.\n";
 
    // TODO RP check
 
    //
    // Downstream per-interface (*,G) state machine; event = Receive Join(*,G)
    //
 
    // check UpstreamNeighbor field
    if (upstreamNeighborField != inInterface->getProtocolData<Ipv4InterfaceData>()->getIPAddress())
        return;
 
    bool newRoute = false;
    Route *routeG = findRouteG(group);
    if (!routeG) {
        routeG = addNewRouteG(group, Route::PRUNED);
        newRoute = true;
    }
 
    DownstreamInterface *downstream = routeG->findDownstreamInterfaceByInterfaceId(inInterface->getInterfaceId());
 
    if (downstream) {
        // A Join(*,G) is received on interface I with its Upstream
        // Neighbor Address set to the router's primary IP address on I.
        if (downstream->joinPruneState == DownstreamInterface::NO_INFO) {
            // The (*,G) downstream state machine on interface I transitions
            // to the Join state.  The Expiry Timer (ET) is started and set
            // to the HoldTime from the triggering Join/Prune message.
            downstream->joinPruneState = DownstreamInterface::JOIN;
            downstream->startExpiryTimer(holdTime);
        }
        else if (downstream->joinPruneState == DownstreamInterface::JOIN) {
            // The (*,G) downstream state machine on interface I remains in
            // Join state, and the Expiry Timer (ET) is restarted, set to
            // maximum of its current value and the HoldTime from the
            // triggering Join/Prune message.
            if (simTime() + holdTime > downstream->expiryTimer->getArrivalTime())
                restartTimer(downstream->expiryTimer, holdTime);
        }
        else if (downstream->joinPruneState == DownstreamInterface::PRUNE_PENDING) {
            // The (*,G) downstream state machine on interface I transitions
            // to the Join state.  The Prune-Pending Timer is canceled
            // (without triggering an expiry event).  The Expiry Timer is
            // restarted, set to maximum of its current value and the
            // HoldTime from the triggering Join/Prune message.
            cancelAndDeleteTimer(downstream->prunePendingTimer);
            if (simTime() + holdTime > downstream->expiryTimer->getArrivalTime())
                restartTimer(downstream->expiryTimer, holdTime);
        }
    }
 
    // TODO Join(*,G) messages can affect (S,G,rpt) downstream state machines too
 
    // check upstream state transition
    updateJoinDesired(routeG);
 
    if (!newRoute && !routeG->upstreamInterface) { // I am RP
        routeG->clearFlag(Route::REGISTER);
    }
}

Referenced by processJoinPrunePacket().

processJoinPrunePacket()

void inet::PimSm::processJoinPrunePacket ( Packet *  pk )

private

{
    const auto& pkt = pk->peekAtFront<PimJoinPrune>();
    EV_INFO << "Received JoinPrune packet.\n";
 
    emit(rcvdJoinPrunePkSignal, pk);
 
    NetworkInterface *inInterface = ift->getInterfaceById(pk->getTag<InterfaceInd>()->getInterfaceId());
 
    int holdTime = pkt->getHoldTime();
    Ipv4Address upstreamNeighbor = pkt->getUpstreamNeighborAddress().unicastAddress.toIpv4();
 
    for (unsigned int i = 0; i < pkt->getJoinPruneGroupsArraySize(); i++) {
        JoinPruneGroup group = pkt->getJoinPruneGroups(i);
        Ipv4Address groupAddr = group.getGroupAddress().groupAddress.toIpv4();
 
        // go through list of joined sources
        for (unsigned int j = 0; j < group.getJoinedSourceAddressArraySize(); j++) {
            const auto& source = group.getJoinedSourceAddress(j);
            if (source.S) {
                if (source.W) // (*,G) Join
                    processJoinG(groupAddr, source.sourceAddress.toIpv4(), upstreamNeighbor, holdTime, inInterface);
                else if (source.R) // (S,G,rpt) Join
                    processJoinSGrpt(source.sourceAddress.toIpv4(), groupAddr, upstreamNeighbor, holdTime, inInterface);
                else // (S,G) Join
                    processJoinSG(source.sourceAddress.toIpv4(), groupAddr, upstreamNeighbor, holdTime, inInterface);
            }
        }
 
        // go through list of pruned sources
        for (unsigned int j = 0; j < group.getPrunedSourceAddressArraySize(); j++) {
            const auto& source = group.getPrunedSourceAddress(j);
            if (source.S) {
                if (source.W) // (*,G) Prune
                    processPruneG(groupAddr, upstreamNeighbor, inInterface);
                else if (source.R) // (S,G,rpt) Prune
                    processPruneSGrpt(source.sourceAddress.toIpv4(), groupAddr, upstreamNeighbor, inInterface);
                else // (S,G) Prune
                    processPruneSG(source.sourceAddress.toIpv4(), groupAddr, upstreamNeighbor, inInterface);
            }
        }
    }
 
    delete pk;
}

Referenced by handleMessageWhenUp().

processJoinSG()

void inet::PimSm::processJoinSG ( Ipv4Address  origin, Ipv4Address  group, Ipv4Address  upstreamNeighborField, int  holdTime, NetworkInterface *  inInterface  )

private

{
    EV_DETAIL << "Processing Join(" << source << ", " << group << ") received on interface '" << inInterface->getInterfaceName() << "'.'n";
 
    //
    // Downstream per-interface (S,G) state machine; event = Receive Join(S,G)
    //
 
    // check UpstreamNeighbor field
    if (upstreamNeighborField != inInterface->getProtocolData<Ipv4InterfaceData>()->getIPAddress())
        return;
 
    Route *routeSG = findRouteSG(source, group);
    if (!routeSG) { // create (S,G) route between RP and source DR
        routeSG = addNewRouteSG(source, group, Route::PRUNED);
        routeSG->startKeepAliveTimer(keepAlivePeriod);
    }
 
    DownstreamInterface *downstream = routeSG->findDownstreamInterfaceByInterfaceId(inInterface->getInterfaceId());
 
    if (downstream) {
        // A Join(S,G) is received on interface I with its Upstream
        // Neighbor Address set to the router's primary IP address on I.
        if (downstream->joinPruneState == DownstreamInterface::NO_INFO) {
            // The (S,G) downstream state machine on interface I transitions
            // to the Join state.  The Expiry Timer (ET) is started and set
            // to the HoldTime from the triggering Join/Prune message.
            downstream->joinPruneState = DownstreamInterface::JOIN;
            downstream->startExpiryTimer(holdTime);
        }
        else if (downstream->joinPruneState == DownstreamInterface::JOIN) {
            // The (S,G) downstream state machine on interface I remains in
            // Join state, and the Expiry Timer (ET) is restarted, set to
            // maximum of its current value and the HoldTime from the
            // triggering Join/Prune message.
            if (simTime() + holdTime > downstream->expiryTimer->getArrivalTime())
                restartTimer(downstream->expiryTimer, holdTime);
        }
        else if (downstream->joinPruneState == DownstreamInterface::PRUNE_PENDING) {
            // The (S,G) downstream state machine on interface I transitions
            // to the Join state.  The Prune-Pending Timer is canceled
            // (without triggering an expiry event).  The Expiry Timer is
            // restarted, set to maximum of its current value and the
            // HoldTime from the triggering Join/Prune message.
            cancelAndDeleteTimer(downstream->prunePendingTimer);
            if (simTime() + holdTime > downstream->expiryTimer->getArrivalTime())
                restartTimer(downstream->expiryTimer, holdTime);
        }
    }
 
    // check upstream state transition
    updateJoinDesired(routeSG);
}

Referenced by processJoinPrunePacket().

processJoinSGrpt()

void inet::PimSm::processJoinSGrpt ( Ipv4Address  origin, Ipv4Address  group, Ipv4Address  upstreamNeighborField, int  holdTime, NetworkInterface *  inInterface  )

private

{
    // TODO
}

Referenced by processJoinPrunePacket().

processJoinTimer()

void inet::PimSm::processJoinTimer ( cMessage *  timer )

private

{
    EV << "pimSM::processJoinTimer:" << endl;
 
    Route *route = static_cast<Route *>(timer->getContextPointer());
    ASSERT(timer == route->joinTimer);
    Ipv4Address joinAddr = route->type == G ? route->rpAddr : route->source;
 
    if (!route->isInheritedOlistNull()) {
        sendPIMJoin(route->group, joinAddr, route->upstreamInterface->nextHop, route->type);
        restartTimer(route->joinTimer, joinPrunePeriod);
    }
    else {
        delete timer;
        route->joinTimer = nullptr;
    }
}

Referenced by handleMessageWhenUp().

processKeepAliveTimer()

void inet::PimSm::processKeepAliveTimer ( cMessage *  timer )

private

{
    EV << "pimSM::processKeepAliveTimer: route will be deleted" << endl;
    Route *route = static_cast<Route *>(timer->getContextPointer());
    ASSERT(route->type == SG);
    ASSERT(timer == route->keepAliveTimer);
 
    delete timer;
    route->keepAliveTimer = nullptr;
    deleteMulticastRoute(route);
}

Referenced by handleMessageWhenUp().

processPruneG()

void inet::PimSm::processPruneG ( Ipv4Address  multGroup, Ipv4Address  upstreamNeighborField, NetworkInterface *  inInterface  )

private

{
    EV_DETAIL << "Processing Prune(*," << group << ") received on interface '" << inInterface->getInterfaceName() << "'.\n";
 
    //
    // Downstream per-interface (*,G) state machine; event = Receive Prune(*,G)
    //
 
    // check UpstreamNeighbor field
    if (upstreamNeighborField != inInterface->getProtocolData<Ipv4InterfaceData>()->getIPAddress())
        return;
 
    Route *routeG = findRouteG(group);
    if (routeG) {
        DownstreamInterface *downstream = routeG->findDownstreamInterfaceByInterfaceId(inInterface->getInterfaceId());
        if (downstream && downstream->joinPruneState == DownstreamInterface::JOIN) {
            // The (*,G) downstream state machine on interface I transitions
            // to the Prune-Pending state.  The Prune-Pending Timer is
            // started.  It is set to the J/P_Override_Interval(I) if the
            // router has more than one neighbor on that interface;
            // otherwise, it is set to zero, causing it to expire
            // immediately.
            downstream->joinPruneState = DownstreamInterface::PRUNE_PENDING;
            double pruneOverrideInterval = pimNbt->getNumNeighbors(inInterface->getInterfaceId()) > 1 ?
                joinPruneOverrideInterval() : 0.0;
            downstream->startPrunePendingTimer(pruneOverrideInterval);
        }
    }
 
    // check upstream state transition
    if (routeG)
        updateJoinDesired(routeG);
}

Referenced by processJoinPrunePacket().

processPrunePendingTimer()

void inet::PimSm::processPrunePendingTimer ( cMessage *  timer )

private

Prune Pending Timer is used for delaying of Prune message sending (for possible overriding Join from another PIM neighbor)

{
    EV << "pimSM::processPrunePendingTimer:" << endl;
    DownstreamInterface *downstream = static_cast<DownstreamInterface *>(timer->getContextPointer());
    ASSERT(timer == downstream->prunePendingTimer);
    ASSERT(downstream->joinPruneState == DownstreamInterface::PRUNE_PENDING);
    Route *route = downstream->route();
 
    if (route->type == G || route->type == SG) {
        //
        // Downstream (*,G)/(S,G) Join/Prune State Machine; event: PPT expires
        //
 
        // go to NO_INFO state
        downstream->joinPruneState = DownstreamInterface::NO_INFO;
        cancelAndDeleteTimer(downstream->expiryTimer);
        downstream->prunePendingTimer = nullptr;
        delete timer;
 
        // optionally send PruneEcho message
        if (pimNbt->getNumNeighbors(downstream->ie->getInterfaceId()) > 1) {
            // A PruneEcho is simply a Prune message sent by the
            // upstream router on a LAN with its own address in the Upstream
            // Neighbor Address field.  Its purpose is to add additional
            // reliability so that if a Prune that should have been
            // overridden by another router is lost locally on the LAN, then
            // the PruneEcho may be received and cause the override to happen.
            Ipv4Address pruneAddr = route->type == G ? route->rpAddr : route->source;
            Ipv4Address upstreamNeighborField = downstream->ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
            sendPIMPrune(route->group, pruneAddr, upstreamNeighborField, route->type);
        }
    }
    else if (route->type == SGrpt) {
        //
        // Downstream (S,G,rpt) Join/Prune State Machine; event: PPT expires
        //
 
        // go to PRUNE state
        // TODO
    }
 
    // Now check upstream state transitions
    updateJoinDesired(route);
}

Referenced by handleMessageWhenUp().

processPruneSG()

void inet::PimSm::processPruneSG ( Ipv4Address  source, Ipv4Address  group, Ipv4Address  upstreamNeighborField, NetworkInterface *  inInterface  )

private

{
    EV_DETAIL << "Processing Prune(" << source << ", " << group << ") received on interface '" << inInterface->getInterfaceName() << "'.'n";
 
    //
    // Downstream per-interface (S,G) state machine; event = Receive Prune(S,G)
    //
 
    // check UpstreamNeighbor field
    if (upstreamNeighborField != inInterface->getProtocolData<Ipv4InterfaceData>()->getIPAddress())
        return;
 
    Route *routeSG = findRouteSG(source, group);
    if (routeSG) {
        DownstreamInterface *downstream = routeSG->findDownstreamInterfaceByInterfaceId(inInterface->getInterfaceId());
        if (downstream && downstream->joinPruneState == DownstreamInterface::JOIN) {
            // The (S,G) downstream state machine on interface I transitions
            // to the Prune-Pending state.  The Prune-Pending Timer is
            // started.  It is set to the J/P_Override_Interval(I) if the
            // router has more than one neighbor on that interface;
            // otherwise, it is set to zero, causing it to expire
            // immediately.
            downstream->joinPruneState = DownstreamInterface::PRUNE_PENDING;
            double pruneOverrideInterval = pimNbt->getNumNeighbors(inInterface->getInterfaceId()) > 1 ?
                joinPruneOverrideInterval() : 0.0;
            downstream->startPrunePendingTimer(pruneOverrideInterval);
        }
    }
 
    // check upstream state transition
    if (routeSG)
        updateJoinDesired(routeSG);
}

Referenced by processJoinPrunePacket().

processPruneSGrpt()

void inet::PimSm::processPruneSGrpt ( Ipv4Address  source, Ipv4Address  group, Ipv4Address  upstreamNeighborField, NetworkInterface *  inInterface  )

private

{
    // TODO
}

Referenced by processJoinPrunePacket().

processRegisterPacket()

void inet::PimSm::processRegisterPacket ( Packet *  pk )

private

The method is used for processing PIM Register message sent from source DR.

If PIM Register isn't Null and route doesn't exist, it is created and PIM Register-Stop is sent. If PIM Register is Null, Register-Stop is sent.

{
    const auto& pkt = pk->popAtFront<PimRegister>();
    EV_INFO << "Received Register packet.\n";
 
    emit(rcvdRegisterPkSignal, pk);
 
    Ipv4Address srcAddr = pk->getTag<L3AddressInd>()->getSrcAddress().toIpv4();
    Ipv4Address destAddr = pk->getTag<L3AddressInd>()->getDestAddress().toIpv4();
    const auto& encapData = pk->peekAtFront<Ipv4Header>();
    Ipv4Address source = encapData->getSrcAddress();
    Ipv4Address group = encapData->getDestAddress();
    Route *routeG = findRouteG(group);
    Route *routeSG = findRouteSG(source, group);
 
    if (!pkt->getN()) { // It is Null Register ?
        if (!routeG) {
            routeG = addNewRouteG(group, Route::PRUNED);
        }
 
        if (!routeSG) {
            routeSG = addNewRouteSG(source, group, Route::PRUNED);
            routeSG->startKeepAliveTimer(keepAlivePeriod);
        }
        else if (routeSG->keepAliveTimer) {
            EV << " (S,G) KAT timer refresh" << endl;
            restartTimer(routeSG->keepAliveTimer, KAT);
        }
 
        if (!routeG->isInheritedOlistNull()) { // we have some active receivers
            routeSG->clearFlag(Route::PRUNED);
 
            if (!routeSG->isFlagSet(Route::SPT_BIT)) { // only if isn't build SPT between RP and registering DR
                // decapsulate and forward the inner packet to inherited_olist(S,G,rpt)
                // TODO we are forwarding on inherited_olist(*,G)
                for (auto& elem : routeG->downstreamInterfaces) {
                    DownstreamInterface *downstream = elem;
                    if (downstream->isInInheritedOlist())
                        forwardMulticastData(pk->dup(), downstream->getInterfaceId());
                }
 
                // send Join(S,G) toward source to establish SPT between RP and registering DR
                sendPIMJoin(group, source, routeSG->upstreamInterface->rpfNeighbor(), SG);
 
                // send register-stop packet
                sendPIMRegisterStop(destAddr, srcAddr, group, source);
            }
        }
    }
 
    if (routeG) {
        if (routeG->isFlagSet(Route::PRUNED) || pkt->getN()) {
            sendPIMRegisterStop(destAddr, srcAddr, group, source);
        }
    }
 
    delete pk;
}

Referenced by handleMessageWhenUp().

processRegisterStopPacket()

void inet::PimSm::processRegisterStopPacket ( Packet *  pk )

private

The method is used for processing PIM Register-Stop message sent from RP.

If the message is received Register Tunnel between RP and source DR is set from Join status revert to Prune status. Also Register Stop Timer is created for periodic sending PIM Register Null messages.

{
    const auto& pkt = pk->peekAtFront<PimRegisterStop>();
    EV_INFO << "Received RegisterStop packet.\n";
 
    emit(rcvdRegisterStopPkSignal, pk);
 
    // TODO support wildcard source address
    Route *routeSG = findRouteSG(pkt->getSourceAddress().unicastAddress.toIpv4(), pkt->getGroupAddress().groupAddress.toIpv4());
    if (routeSG) {
        if (routeSG->registerState == Route::RS_JOIN || routeSG->registerState == Route::RS_JOIN_PENDING) {
            routeSG->registerState = Route::RS_PRUNE;
            cancelAndDeleteTimer(routeSG->registerStopTimer);
 
            // The Register-Stop Timer is set to a random value chosen
            // uniformly from the interval ( 0.5 * Register_Suppression_Time,
            // 1.5 * Register_Suppression_Time) minus Register_Probe_Time.
            // Subtracting off Register_Probe_Time is a bit unnecessary because
            // it is really small compared to Register_Suppression_Time, but
            // this was in the old spec and is kept for compatibility.
            routeSG->startRegisterStopTimer(uniform(0.5 * registerSuppressionTime, 1.5 * registerSuppressionTime) - registerProbeTime);
        }
    }
    delete pk;
}

Referenced by handleMessageWhenUp().

processRegisterStopTimer()

void inet::PimSm::processRegisterStopTimer ( cMessage *  timer )

private

{
    EV << "pimSM::processRegisterStopTimer: " << endl;
    Route *routeSG = static_cast<Route *>(timer->getContextPointer());
    ASSERT(timer == routeSG->registerStopTimer);
    ASSERT(routeSG->type == SG);
 
    delete timer;
    routeSG->registerStopTimer = nullptr;
 
    if (routeSG->registerState == Route::RS_PRUNE) {
        routeSG->registerState = Route::RS_JOIN_PENDING;
        sendPIMRegisterNull(routeSG->source, routeSG->group);
        routeSG->startRegisterStopTimer(registerProbeTime);
    }
    else if (routeSG->registerState == Route::RS_JOIN_PENDING) {
        routeSG->registerState = Route::RS_JOIN;
    }
}

Referenced by handleMessageWhenUp().

receiveSignal()

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

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    printSignalBanner(signalID, obj, details);
 
    if (signalID == ipv4MulticastGroupRegisteredSignal) {
        EV << "pimSM::receiveChangeNotification - NEW IGMP ADDED" << endl;
        const Ipv4MulticastGroupInfo *info = check_and_cast<const Ipv4MulticastGroupInfo *>(obj);
        PimInterface *pimInterface = pimIft->getInterfaceById(info->ie->getInterfaceId());
        if (pimInterface && pimInterface->getMode() == PimInterface::SparseMode)
            multicastReceiverAdded(info->ie, info->groupAddress);
    }
    else if (signalID == ipv4MulticastGroupUnregisteredSignal) {
        EV << "pimSM::receiveChangeNotification - IGMP REMOVED" << endl;
        const Ipv4MulticastGroupInfo *info = check_and_cast<const Ipv4MulticastGroupInfo *>(obj);
        PimInterface *pimInterface = pimIft->getInterfaceById(info->ie->getInterfaceId());
        if (pimInterface && pimInterface->getMode() == PimInterface::SparseMode)
            multicastReceiverRemoved(info->ie, info->groupAddress);
    }
    else if (signalID == ipv4NewMulticastSignal) {
        EV << "PimSM::receiveChangeNotification - NEW MULTICAST" << endl;
        const Ipv4Header *ipv4Header = check_and_cast<const Ipv4Header *>(obj);
        Ipv4Address srcAddr = ipv4Header->getSrcAddress();
        Ipv4Address destAddr = ipv4Header->getDestAddress();
        unroutableMulticastPacketArrived(srcAddr, destAddr);
    }
    else if (signalID == ipv4DataOnRpfSignal) {
        EV << "pimSM::receiveChangeNotification - DATA ON RPF" << endl;
        const Ipv4Header *ipv4Header = check_and_cast<const Ipv4Header *>(obj);
        PimInterface *incomingInterface = getIncomingInterface(check_and_cast<NetworkInterface *>(details));
        if (incomingInterface && incomingInterface->getMode() == PimInterface::SparseMode) {
            Route *route = findRouteG(ipv4Header->getDestAddress());
            if (route)
                multicastPacketArrivedOnRpfInterface(route);
            route = findRouteSG(ipv4Header->getSrcAddress(), ipv4Header->getDestAddress());
            if (route)
                multicastPacketArrivedOnRpfInterface(route);
        }
    }
    else if (signalID == ipv4DataOnNonrpfSignal) {
        const Ipv4Header *ipv4Header = check_and_cast<const Ipv4Header *>(obj);
        PimInterface *incomingInterface = getIncomingInterface(check_and_cast<NetworkInterface *>(details));
        if (incomingInterface && incomingInterface->getMode() == PimInterface::SparseMode) {
            Ipv4Address srcAddr = ipv4Header->getSrcAddress();
            Ipv4Address destAddr = ipv4Header->getDestAddress();
            Route *route;
            if ((route = findRouteSG(srcAddr, destAddr)) != nullptr)
                multicastPacketArrivedOnNonRpfInterface(route, incomingInterface->getInterfaceId());
            else if ((route = findRouteG(destAddr)) != nullptr)
                multicastPacketArrivedOnNonRpfInterface(route, incomingInterface->getInterfaceId());
        }
    }
    else if (signalID == ipv4MdataRegisterSignal) {
        EV << "pimSM::receiveChangeNotification - REGISTER DATA" << endl;
        Packet *pk = check_and_cast<Packet *>(obj);
        const auto& ipv4Header = pk->peekAtFront<Ipv4Header>();
        PimInterface *incomingInterface = getIncomingInterface(check_and_cast<NetworkInterface *>(details));
        Route *route = findRouteSG(ipv4Header->getSrcAddress(), ipv4Header->getDestAddress());
        (void)route; // TODO unused variable
        if (incomingInterface && incomingInterface->getMode() == PimInterface::SparseMode)
            multicastPacketForwarded(pk);
    }
    else if (signalID == pimNeighborAddedSignal || signalID == pimNeighborDeletedSignal || signalID == pimNeighborChangedSignal) {
        PimNeighbor *neighbor = check_and_cast<PimNeighbor *>(obj);
        updateDesignatedRouterAddress(neighbor->getInterfacePtr());
    }
}

removeRoute()

bool inet::PimSm::removeRoute ( Route *  route )

private

{
    SourceAndGroup sg(route->source, route->group);
    if (route->type == G)
        return gRoutes.erase(sg);
    else
        return sgRoutes.erase(sg);
}

Referenced by deleteMulticastRoute().

restartExpiryTimer()

void inet::PimSm::restartExpiryTimer ( Route *  route, NetworkInterface *  originIntf, int  holdTime  )

private

The method is used to restart ET.

ET is used for outgoing interfaces and whole route in router. After ET expires, outgoing interface is removed or if there aren't any outgoing interface, route is removed after ET expires.

{
    EV << "pimSM::restartExpiryTimer: next ET @ " << simTime() + holdTime << " for type: ";
 
    if (route) {
        // ET for route
        if (route->upstreamInterface && route->upstreamInterface->expiryTimer)
            restartTimer(route->upstreamInterface->expiryTimer, holdTime);
 
        // ET for outgoing interfaces
        for (unsigned i = 0; i < route->downstreamInterfaces.size(); i++) { // if exist ET and for given interface
            DownstreamInterface *downstream = route->downstreamInterfaces[i];
            if (downstream->expiryTimer && (downstream->getInterfaceId() == originIntf->getInterfaceId())) {
                EV << /*timer->getStateType() << " , " <<*/ route->group << " , " << route->source << ", int: " << downstream->ie->getInterfaceName() << endl;
                restartTimer(downstream->expiryTimer, holdTime);
                break;
            }
        }
    }
}

restartTimer()

void inet::PimSm::restartTimer ( cMessage *  timer, double  interval  )

private

{
    rescheduleAfter(interval, timer);
}

Referenced by multicastPacketArrivedOnRpfInterface(), multicastPacketForwarded(), processAssertG(), processAssertSG(), processAssertTimer(), processJoinG(), processJoinSG(), processJoinTimer(), processRegisterPacket(), and restartExpiryTimer().

sendPIMAssert()

void inet::PimSm::sendPIMAssert ( Ipv4Address  source, Ipv4Address  group, AssertMetric  metric, NetworkInterface *  ie, bool  rptBit  )

private

{
    EV_INFO << "Sending Assert(S= " << source << ", G= " << group << ") message on interface '" << ie->getInterfaceName() << "'\n";
 
    Packet *pk = new Packet("PimAssert");
    const auto& pkt = makeShared<PimAssert>();
    pkt->getGroupAddressForUpdate().groupAddress = group;
    // TODO set other fields of groupAddress
    pkt->getSourceAddressForUpdate().unicastAddress = source;
    pkt->setR(rptBit);
    pkt->setMetricPreference(metric.preference);
    pkt->setMetric(metric.metric);
 
    pkt->setChunkLength(PIM_HEADER_LENGTH
            + ENCODED_GROUP_ADDRESS_LENGTH
            + ENCODED_UNICODE_ADDRESS_LENGTH
            + B(8));
    pkt->setCrcMode(pimModule->getCrcMode());
    Pim::insertCrc(pkt);
    pk->insertAtFront(pkt);
 
    emit(sentAssertPkSignal, pk);
 
    sendToIP(pk, Ipv4Address::UNSPECIFIED_ADDRESS, ALL_PIM_ROUTERS_MCAST, ie->getInterfaceId(), 1);
}

Referenced by multicastPacketArrivedOnNonRpfInterface(), processAssertG(), processAssertSG(), and processAssertTimer().

sendPIMJoin()

void inet::PimSm::sendPIMJoin ( Ipv4Address  group, Ipv4Address  source, Ipv4Address  upstreamNeighbor, RouteType  JPtype  )

private

{
    EV_INFO << "Sending Join(S=" << (routeType == G ? "*" : source.str()) << ", G=" << group << ") to neighbor " << upstreamNeighbor << ".\n";
 
    Packet *pk = new Packet("PIMJoin");
    const auto& msg = makeShared<PimJoinPrune>();
    msg->setType(JoinPrune);
    msg->getUpstreamNeighborAddressForUpdate().unicastAddress = upstreamNeighbor;
    msg->setHoldTime(joinPruneHoldTime());
 
    msg->setJoinPruneGroupsArraySize(1);
    JoinPruneGroup& multGroup = msg->getJoinPruneGroupsForUpdate(0);
    auto& groupAddr = multGroup.getGroupAddressForUpdate();
    groupAddr.groupAddress = group;
    // TODO other fields of groupAddr
    multGroup.setJoinedSourceAddressArraySize(1);
    auto& encodedAddr = multGroup.getJoinedSourceAddressForUpdate(0);
    encodedAddr.sourceAddress = source;
    encodedAddr.S = true;
    encodedAddr.W = (routeType == G);
    encodedAddr.R = (routeType == G);
 
    msg->setChunkLength(PIM_HEADER_LENGTH
            + ENCODED_UNICODE_ADDRESS_LENGTH
            + B(4)
            + ENCODED_GROUP_ADDRESS_LENGTH
            + B(4)
            + ENCODED_SOURCE_ADDRESS_LENGTH);
    msg->setCrcMode(pimModule->getCrcMode());
    Pim::insertCrc(msg);
 
    pk->insertAtFront(msg);
 
    emit(sentJoinPrunePkSignal, pk);
 
    NetworkInterface *interfaceToRP = rt->getInterfaceForDestAddr(source);
    sendToIP(pk, Ipv4Address::UNSPECIFIED_ADDRESS, ALL_PIM_ROUTERS_MCAST, interfaceToRP->getInterfaceId(), 1);
}

Referenced by joinDesiredChanged(), processJoinTimer(), and processRegisterPacket().

sendPIMPrune()

void inet::PimSm::sendPIMPrune ( Ipv4Address  group, Ipv4Address  source, Ipv4Address  upstreamNeighbor, RouteType  JPtype  )

private

{
    EV_INFO << "Sending Prune(S=" << (routeType == G ? "*" : source.str()) << ", G=" << group << ") to neighbor " << upstreamNeighbor << ".\n";
 
    Packet *pk = new Packet("PIMPrune");
    const auto& msg = makeShared<PimJoinPrune>();
    msg->setType(JoinPrune);
    msg->getUpstreamNeighborAddressForUpdate().unicastAddress = upstreamNeighbor;
    msg->setHoldTime(joinPruneHoldTime());
 
    msg->setJoinPruneGroupsArraySize(1);
    JoinPruneGroup& multGroup = msg->getJoinPruneGroupsForUpdate(0);
    multGroup.getGroupAddressForUpdate().groupAddress = group;
    multGroup.setPrunedSourceAddressArraySize(1);
    auto& encodedAddr = multGroup.getPrunedSourceAddressForUpdate(0);
    encodedAddr.sourceAddress = source;
    encodedAddr.S = true;
    encodedAddr.W = (routeType == G);
    encodedAddr.R = (routeType == G);
 
    msg->setChunkLength(PIM_HEADER_LENGTH
            + ENCODED_UNICODE_ADDRESS_LENGTH
            + B(4)
            + ENCODED_GROUP_ADDRESS_LENGTH
            + B(4)
            + ENCODED_SOURCE_ADDRESS_LENGTH);
    msg->setCrcMode(pimModule->getCrcMode());
    Pim::insertCrc(msg);
 
    pk->insertAtFront(msg);
 
    emit(sentJoinPrunePkSignal, pk);
 
    NetworkInterface *interfaceToRP = rt->getInterfaceForDestAddr(source);
    sendToIP(pk, Ipv4Address::UNSPECIFIED_ADDRESS, ALL_PIM_ROUTERS_MCAST, interfaceToRP->getInterfaceId(), 1);
}

Referenced by joinDesiredChanged(), processExpiryTimer(), and processPrunePendingTimer().

sendPIMRegister()

void inet::PimSm::sendPIMRegister ( Packet *  pk, Ipv4Address  dest, int  outInterfaceId  )

private

{
    ASSERT(ipv4Packet->peekAtFront<Ipv4Header>() != nullptr);
 
    EV << "pimSM::sendPIMRegister - encapsulating data packet into Register packet and sending to RP" << endl;
 
    Packet *pk = new Packet("PimRegister");
    const auto& msg = makeShared<PimRegister>();
    msg->setType(Register);
    msg->setN(false);
    msg->setB(false);
 
    msg->setChunkLength(PIM_HEADER_LENGTH + B(4));
    msg->setCrcMode(pimModule->getCrcMode());
    Pim::insertCrc(msg);
 
    pk->insertAtBack(ipv4Packet->peekDataAt(b(0), ipv4Packet->getDataLength()));
    pk->insertAtFront(msg);
 
    emit(sentRegisterPkSignal, pk);
 
    sendToIP(pk, Ipv4Address::UNSPECIFIED_ADDRESS, dest, outInterfaceId, MAX_TTL);
}

Referenced by multicastPacketForwarded().

sendPIMRegisterNull()

void inet::PimSm::sendPIMRegisterNull ( Ipv4Address  multSource, Ipv4Address  multDest  )

private

{
    EV << "pimSM::sendPIMRegisterNull" << endl;
 
    // only if (S,G exist)
//    if (getRouteFor(multDest,multSource))
    if (findRouteG(multGroup)) {
        Packet *pk = new Packet("PimRegister(Null)");
        const auto& msg = makeShared<PimRegister>();
        msg->setType(Register);
        msg->setN(true);
        msg->setB(false);
        msg->setChunkLength(PIM_HEADER_LENGTH + B(4));
        msg->setCrcMode(pimModule->getCrcMode());
        Pim::insertCrc(msg);
        pk->insertAtFront(msg);
 
        // set encapsulated packet (Ipv4 header only)
        const auto& ipv4Header = makeShared<Ipv4Header>();
        ipv4Header->setDestAddress(multGroup);
        ipv4Header->setSrcAddress(multOrigin);
        ipv4Header->setProtocolId(IP_PROT_PIM);
        ipv4Header->setHeaderLength(IPv4_MIN_HEADER_LENGTH);
        ipv4Header->setTotalLengthField(IPv4_MIN_HEADER_LENGTH);
        ipv4Header->setCrcMode(pimModule->getCrcMode());
        Ipv4::insertCrc(ipv4Header);
        pk->insertAtBack(ipv4Header);
 
        emit(sentRegisterPkSignal, pk);
 
        NetworkInterface *interfaceToRP = rt->getInterfaceForDestAddr(rpAddr);
        sendToIP(pk, Ipv4Address::UNSPECIFIED_ADDRESS, rpAddr, interfaceToRP->getInterfaceId(), MAX_TTL);
    }
}

Referenced by processRegisterStopTimer().

sendPIMRegisterStop()

void inet::PimSm::sendPIMRegisterStop ( Ipv4Address  source, Ipv4Address  dest, Ipv4Address  multGroup, Ipv4Address  multSource  )

private

{
    EV << "pimSM::sendPIMRegisterStop" << endl;
 
    // create PIM Register datagram
    Packet *pk = new Packet("PimRegisterStop");
    const auto& msg = makeShared<PimRegisterStop>();
 
    // set PIM packet
    msg->setType(RegisterStop);
    msg->getSourceAddressForUpdate().unicastAddress = multSource;
    msg->getGroupAddressForUpdate().groupAddress = multGroup;
 
    msg->setChunkLength(B(PIM_HEADER_LENGTH + ENCODED_GROUP_ADDRESS_LENGTH + ENCODED_UNICODE_ADDRESS_LENGTH));
    msg->setCrcMode(pimModule->getCrcMode());
    Pim::insertCrc(msg);
    pk->insertAtFront(msg);
 
    emit(sentRegisterStopPkSignal, pk);
 
    // set IP packet
    NetworkInterface *interfaceToDR = rt->getInterfaceForDestAddr(dest);
    sendToIP(pk, source, dest, interfaceToDR->getInterfaceId(), MAX_TTL);
}

Referenced by processRegisterPacket().

sendToIP()

void inet::PimSm::sendToIP ( Packet *  packet, Ipv4Address  source, Ipv4Address  dest, int  outInterfaceId, short  ttl  )

private

{
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::pim);
    packet->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::pim);
    packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
    packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(outInterfaceId);
    packet->addTagIfAbsent<L3AddressReq>()->setSrcAddress(srcAddr);
    packet->addTagIfAbsent<L3AddressReq>()->setDestAddress(destAddr);
    packet->addTagIfAbsent<HopLimitReq>()->setHopLimit(ttl);
    send(packet, "ipOut");
}

Referenced by sendPIMAssert(), sendPIMJoin(), sendPIMPrune(), sendPIMRegister(), sendPIMRegisterNull(), and sendPIMRegisterStop().

stopPIMRouting()

void inet::PimSm::stopPIMRouting ( )

protectedvirtual

{
    if (isEnabled) {
        cModule *host = findContainingNode(this);
        if (!host)
            throw cRuntimeError("PimSm: containing node not found.");
        host->unsubscribe(ipv4NewMulticastSignal, this);
        host->unsubscribe(ipv4MdataRegisterSignal, this);
        host->unsubscribe(ipv4DataOnRpfSignal, this);
        host->unsubscribe(ipv4DataOnNonrpfSignal, this);
        host->unsubscribe(ipv4MulticastGroupRegisteredSignal, this);
        host->unsubscribe(ipv4MulticastGroupUnregisteredSignal, this);
        host->unsubscribe(pimNeighborAddedSignal, this);
        host->unsubscribe(pimNeighborDeletedSignal, this);
        host->unsubscribe(pimNeighborChangedSignal, this);
    }
 
    clearRoutes();
}

Referenced by handleCrashOperation(), and handleStopOperation().

unroutableMulticastPacketArrived()

void inet::PimSm::unroutableMulticastPacketArrived ( Ipv4Address  srcAddr, Ipv4Address  destAddr  )

private

{
    Ipv4Route *routeTowardSource = rt->findBestMatchingRoute(source); // rt->getInterfaceForDestAddr(source);
    if (!routeTowardSource)
        return;
 
    PimInterface *rpfInterface = pimIft->getInterfaceById(routeTowardSource->getInterface()->getInterfaceId());
    if (!rpfInterface || rpfInterface->getMode() != PimInterface::SparseMode)
        return;
 
    NetworkInterface *interfaceTowardRP = rt->getInterfaceForDestAddr(rpAddr);
 
    // RPF check and check if I am DR of the source
    if ((interfaceTowardRP != routeTowardSource->getInterface()) && routeTowardSource->getGateway().isUnspecified()) {
        EV_DETAIL << "New multicast source observed: source=" << source << ", group=" << group << ".\n";
 
        // create new (S,G) route
        Route *newRouteSG = addNewRouteSG(source, group, Route::PRUNED | Route::REGISTER | Route::SPT_BIT);
        newRouteSG->startKeepAliveTimer(keepAlivePeriod);
        newRouteSG->registerState = Route::RS_JOIN;
 
        // create new (*,G) route
        addNewRouteG(newRouteSG->group, Route::PRUNED | Route::REGISTER);
    }
}

Referenced by receiveSignal().

updateAssertTrackingDesired()

void inet::PimSm::updateAssertTrackingDesired ( PimsmInterface *  interface )

private

{
    // TODO
 
    // AssertTrackingDesired(S,G,I) =
    // (I in ( ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
    //         (+) ( pim_include(*,G) (-) pim_exclude(S,G) )
    //         (-) lost_assert(*,G)
    //         (+) joins(S,G) ) )
    // OR (local_receiver_include(S,G,I) == TRUE
    //     AND (I_am_DR(I) OR (AssertWinner(S,G,I) == me)))
    // OR ((RPF_interface(S) == I) AND (JoinDesired(S,G) == TRUE))
    // OR ((RPF_interface(RP(G)) == I) AND (JoinDesired(*,G) == TRUE)
    //     AND (SPTbit(S,G) == FALSE))
 
    // AssertTrackingDesired(*,G,I) =
    //   CouldAssert(*,G,I)
    //   OR (local_receiver_include(*,G,I)==TRUE
    //       AND (I_am_DR(I) OR AssertWinner(*,G,I) == me))
    //   OR (RPF_interface(RP(G)) == I AND RPTJoinDesired(G))
}

updateCouldAssert()

void inet::PimSm::updateCouldAssert ( DownstreamInterface *  interface )

private

{
    // TODO
 
    // CouldAssert(S,G,I) =
    // SPTbit(S,G)==TRUE
    // AND (RPF_interface(S) != I)
    // AND (I in ( ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
    //            (+) ( pim_include(*,G) (-) pim_exclude(S,G) )
    //            (-) lost_assert(*,G)
    //            (+) joins(S,G) (+) pim_include(S,G) ) )
 
    // CouldAssert(*,G,I) =
    // ( I in ( joins(*,*,RP(G)) (+) joins(*,G)
    //          (+) pim_include(*,G)) )
    // AND (RPF_interface(RP(G)) != I)
}

updateDesignatedRouterAddress()

void inet::PimSm::updateDesignatedRouterAddress ( NetworkInterface *  ie )

private

{
    int interfaceId = ie->getInterfaceId();
    int numNeighbors = pimNbt->getNumNeighbors(interfaceId);
 
    bool eachNeighborHasPriority = true;
    for (int i = 0; i < numNeighbors && eachNeighborHasPriority; i++)
        if (pimNbt->getNeighbor(interfaceId, i))
            eachNeighborHasPriority = false;
 
    Ipv4Address drAddress = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
    int drPriority = this->designatedRouterPriority;
    for (int i = 0; i < numNeighbors; i++) {
        PimNeighbor *neighbor = pimNbt->getNeighbor(interfaceId, i);
        bool isBetter = eachNeighborHasPriority ?
            (neighbor->getDRPriority() > drPriority ||
             (neighbor->getDRPriority() == drPriority &&
              neighbor->getAddress() > drAddress)) :
            (neighbor->getAddress() > drAddress);
        if (isBetter) {
            drPriority = neighbor->getDRPriority();
            drAddress = neighbor->getAddress();
        }
    }
 
    PimInterface *pimInterface = pimIft->getInterfaceById(interfaceId);
    ASSERT(pimInterface);
    Ipv4Address oldDRAddress = pimInterface->getDRAddress();
    if (drAddress != oldDRAddress) {
        pimInterface->setDRAddress(drAddress);
        designatedRouterAddressHasChanged(ie);
 
        Ipv4Address myAddress = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
        bool iWasDR = oldDRAddress.isUnspecified() || oldDRAddress == myAddress;
        bool iAmDR = drAddress == myAddress;
        if (iWasDR != iAmDR)
            iAmDRHasChanged(ie, iAmDR);
    }
}

Referenced by receiveSignal().

updateJoinDesired()

void inet::PimSm::updateJoinDesired ( Route *  route )

private

{
    bool oldValue = route->joinDesired();
    bool newValue = false;
    if (route->type == RP)
        newValue = !route->isImmediateOlistNull();
    if (route->type == G)
        newValue = !route->isImmediateOlistNull() /* || JoinDesired(*,*,RP(G)) AND AssertWinner(*,G,RPF_interface(RP(G))) != nullptr */;
    else if (route->type == SG)
        newValue = !route->isImmediateOlistNull() || (route->keepAliveTimer && !route->isInheritedOlistNull());
 
    if (newValue != oldValue) {
        route->setFlag(Route::JOIN_DESIRED, newValue);
        joinDesiredChanged(route);
 
        if (route->type == RP) {
            // TODO
        }
        else if (route->type == G) {
            for (auto& elem : sgRoutes) {
                if (elem.second->gRoute == route)
                    updateJoinDesired(elem.second);
            }
        }
    }
}

Referenced by multicastReceiverAdded(), multicastReceiverRemoved(), processJoinG(), processJoinSG(), processPruneG(), processPrunePendingTimer(), and processPruneSG().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const PimSm::Route &  sourceGroup  )

friend

{
    out << "(" << (route.source.isUnspecified() ? "*" : route.source.str()) << ", "
        << (route.group.isUnspecified() ? "*" : route.group.str()) << "), ";
    out << "RP is " << route.rpAddr << ", ";
 
    out << "Incoming interface: ";
    if (route.upstreamInterface) {
        out << route.upstreamInterface->ie->getInterfaceName() << ", ";
        out << "RPF neighbor: " << route.upstreamInterface->rpfNeighbor() << ", ";
    }
    else
        out << "nullptr, ";
 
    out << "Downstream interfaces: ";
    for (unsigned int i = 0; i < route.downstreamInterfaces.size(); ++i) {
        if (i > 0)
            out << ", ";
        out << route.downstreamInterfaces[i]->ie->getInterfaceName() << " ";
        switch (route.downstreamInterfaces[i]->joinPruneState) {
            case PimSm::DownstreamInterface::NO_INFO:
                out << "(NI)";
                break;
 
            case PimSm::DownstreamInterface::JOIN:
                out << "(J)";
                break;
 
            case PimSm::DownstreamInterface::PRUNE_PENDING:
                out << "(PP)";
                break;
        }
    }
 
    return out;
}

Member Data Documentation

assertOverrideInterval

double inet::PimSm::assertOverrideInterval = 0

private

Referenced by initialize(), multicastPacketArrivedOnNonRpfInterface(), processAssertG(), processAssertSG(), and processAssertTimer().

assertTime

double inet::PimSm::assertTime = 0

private

Referenced by initialize(), multicastPacketArrivedOnNonRpfInterface(), processAssertG(), processAssertSG(), and processAssertTimer().

defaultOverrideInterval

double inet::PimSm::defaultOverrideInterval = 0

private

Referenced by initialize().

defaultPropagationDelay

double inet::PimSm::defaultPropagationDelay = 0

private

Referenced by initialize().

gRoutes

RoutingTable inet::PimSm::gRoutes

private

Referenced by addNewRouteG(), clearRoutes(), findRouteG(), handleStartOperation(), removeRoute(), and ~PimSm().

joinPrunePeriod

double inet::PimSm::joinPrunePeriod = 0

private

Referenced by initialize(), joinDesiredChanged(), processJoinTimer(), and inet::PimSm::Route::startJoinTimer().

keepAlivePeriod

double inet::PimSm::keepAlivePeriod = 0

private

Referenced by initialize(), multicastPacketArrivedOnRpfInterface(), processJoinSG(), processRegisterPacket(), inet::PimSm::Route::startKeepAliveTimer(), and unroutableMulticastPacketArrived().

rcvdAssertPkSignal

simsignal_t inet::PimSm::rcvdAssertPkSignal = registerSignal("rcvdAssertPk")

staticprivate

Referenced by processAssertPacket().

rcvdJoinPrunePkSignal

simsignal_t inet::PimSm::rcvdJoinPrunePkSignal = registerSignal("rcvdJoinPrunePk")

staticprivate

Referenced by processJoinPrunePacket().

rcvdRegisterPkSignal

simsignal_t inet::PimSm::rcvdRegisterPkSignal = registerSignal("rcvdRegisterPk")

staticprivate

Referenced by processRegisterPacket().

rcvdRegisterStopPkSignal

simsignal_t inet::PimSm::rcvdRegisterStopPkSignal = registerSignal("rcvdRegisterStopPk")

staticprivate

Referenced by processRegisterStopPacket().

registerProbeTime

double inet::PimSm::registerProbeTime = 0

private

Referenced by initialize(), processRegisterStopPacket(), and processRegisterStopTimer().

registerSuppressionTime

double inet::PimSm::registerSuppressionTime = 0

private

Referenced by initialize(), and processRegisterStopPacket().

rpAddr

Ipv4Address inet::PimSm::rpAddr

private

Referenced by addNewRouteG(), addNewRouteSG(), handleStartOperation(), initialize(), processExpiryTimer(), sendPIMRegisterNull(), and unroutableMulticastPacketArrived().

rpKeepAlivePeriod

double inet::PimSm::rpKeepAlivePeriod = 0

private

Referenced by initialize().

sentAssertPkSignal

simsignal_t inet::PimSm::sentAssertPkSignal = registerSignal("sentAssertPk")

staticprivate

Referenced by sendPIMAssert().

sentJoinPrunePkSignal

simsignal_t inet::PimSm::sentJoinPrunePkSignal = registerSignal("sentJoinPrunePk")

staticprivate

Referenced by sendPIMJoin(), and sendPIMPrune().

sentRegisterPkSignal

simsignal_t inet::PimSm::sentRegisterPkSignal = registerSignal("sentRegisterPk")

staticprivate

Referenced by sendPIMRegister(), and sendPIMRegisterNull().

sentRegisterStopPkSignal

simsignal_t inet::PimSm::sentRegisterStopPkSignal = registerSignal("sentRegisterStopPk")

staticprivate

Referenced by sendPIMRegisterStop().

sgRoutes

RoutingTable inet::PimSm::sgRoutes

private

Referenced by addNewRouteG(), addNewRouteSG(), clearRoutes(), deleteMulticastRoute(), findRouteSG(), handleStartOperation(), removeRoute(), updateJoinDesired(), and ~PimSm().

---

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

• PimSm.h
• PimSm.cc