inet::PIMBase Class Reference

Base class of PIMSM and PIMDM modules. More...

#include <PIMBase.h>

Inheritance diagram for inet::PIMBase:

Classes
struct	AssertMetric
struct	Interface
struct	RouteEntry
struct	SourceAndGroup

Public Member Functions
	PIMBase (PIMInterface::PIMMode mode)
virtual	~PIMBase ()
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
enum	PIMTimerKind {   HelloTimer = 1, TriggeredHelloDelay, AssertTimer, PruneTimer,   PrunePendingTimer, GraftRetryTimer, UpstreamOverrideTimer, PruneLimitTimer,   SourceActiveTimer, StateRefreshTimer, KeepAliveTimer, RegisterStopTimer,   ExpiryTimer, JoinTimer }

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
void	sendHelloPackets ()
void	sendHelloPacket (PIMInterface *pimInterface)
void	processHelloTimer (cMessage *timer)
void	processHelloPacket (PIMHello *pkt)
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
virtual bool	handleNodeStart (IDoneCallback *doneCallback) override
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback) override
virtual void	handleNodeCrash () override
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual void	handleMessageWhenUp (cMessage *msg)=0
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	setOperational (bool isOperational)

Protected Attributes
IIPv4RoutingTable *	rt = nullptr
IInterfaceTable *	ift = nullptr
PIMInterfaceTable *	pimIft = nullptr
PIMNeighborTable *	pimNbt = nullptr
bool	isUp = false
bool	isEnabled = false
const char *	hostname = nullptr
double	helloPeriod = 0
double	holdTime = 0
int	designatedRouterPriority = 0
PIMInterface::PIMMode	mode = (PIMInterface::PIMMode)0
uint32_t	generationID = 0
cMessage *	helloTimer = nullptr
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Static Protected Attributes
static const IPv4Address	ALL_PIM_ROUTERS_MCAST
static simsignal_t	sentHelloPkSignal = registerSignal("sentHelloPk")
static simsignal_t	rcvdHelloPkSignal = registerSignal("rcvdHelloPk")

Detailed Description

Base class of PIMSM and PIMDM modules.

Member Enumeration Documentation

enum inet::PIMBase::PIMTimerKind

protected

Enumerator
HelloTimer
TriggeredHelloDelay
AssertTimer
PruneTimer
PrunePendingTimer
GraftRetryTimer
UpstreamOverrideTimer
PruneLimitTimer
SourceActiveTimer
StateRefreshTimer
KeepAliveTimer
RegisterStopTimer
ExpiryTimer
JoinTimer

                      {
        // global timers
        HelloTimer = 1,
        TriggeredHelloDelay,

        // timers for each interface and each source-group pair (S,G,I)
        AssertTimer,
        PruneTimer,
        PrunePendingTimer,

        // timers for each source-group pair (S,G)
        GraftRetryTimer,
        UpstreamOverrideTimer,
        PruneLimitTimer,
        SourceActiveTimer,
        StateRefreshTimer,

        //PIM-SM specific timers
        KeepAliveTimer,
        RegisterStopTimer,
        ExpiryTimer,
        JoinTimer,
    };

Constructor & Destructor Documentation

inet::PIMBase::PIMBase ( PIMInterface::PIMMode  mode )

inline

: mode(mode) {}

inet::PIMBase::~PIMBase ( )

virtual

{
    cancelAndDelete(helloTimer);
}

Member Function Documentation

void inet::PIMBase::handleNodeCrash ( )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::PIMDM, and inet::PIMSM.

Referenced by inet::PIMSM::handleNodeCrash(), and inet::PIMDM::handleNodeCrash().

{
    // TODO unregister IP_PROT_PIM
    cancelAndDelete(helloTimer);
    helloTimer = nullptr;
}

bool inet::PIMBase::handleNodeShutdown ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::PIMDM, and inet::PIMSM.

Referenced by inet::PIMSM::handleNodeShutdown(), and inet::PIMDM::handleNodeShutdown().

{
    // TODO unregister IP_PROT_PIM
    cancelAndDelete(helloTimer);
    helloTimer = nullptr;
    return true;
}

bool inet::PIMBase::handleNodeStart ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::PIMDM, and inet::PIMSM.

Referenced by inet::PIMSM::handleNodeStart(), and inet::PIMDM::handleNodeStart().

{
    generationID = intrand(UINT32_MAX);

    IPSocket ipSocket(gate("ipOut"));
    ipSocket.registerProtocol(IP_PROT_PIM);

    // to receive PIM messages, join to ALL_PIM_ROUTERS multicast group
    isEnabled = false;
    for (int i = 0; i < pimIft->getNumInterfaces(); i++) {
        PIMInterface *pimInterface = pimIft->getInterface(i);
        if (pimInterface->getMode() == mode) {
            pimInterface->getInterfacePtr()->ipv4Data()->joinMulticastGroup(ALL_PIM_ROUTERS_MCAST);
            isEnabled = true;
        }
    }

    if (isEnabled) {
        EV_INFO << "PIM is enabled on device " << hostname << endl;
        helloTimer = new cMessage("PIM HelloTimer", HelloTimer);
        scheduleAt(simTime() + par("triggeredHelloDelay").doubleValue(), helloTimer);
    }

    return true;
}

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

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::PIMDM, and inet::PIMSM.

Referenced by inet::PIMSM::initialize(), and inet::PIMDM::initialize().

{
    OperationalBase::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        pimIft = getModuleFromPar<PIMInterfaceTable>(par("pimInterfaceTableModule"), this);
        pimNbt = getModuleFromPar<PIMNeighborTable>(par("pimNeighborTableModule"), this);

        cModule *host = findContainingNode(this);
        if (!host)
            throw cRuntimeError("PIMBase: containing node not found.");

        hostname = host->getName();

        helloPeriod = par("helloPeriod");
        holdTime = par("holdTime");
        designatedRouterPriority = mode == PIMInterface::SparseMode ? par("designatedRouterPriority") : -1;
    }
}

virtual bool inet::PIMBase::isInitializeStage ( int  stage )

inlineoverrideprotectedvirtual

Implements inet::OperationalBase.

{ return stage == INITSTAGE_ROUTING_PROTOCOLS; }

virtual bool inet::PIMBase::isNodeShutdownStage ( int  stage )

inlineoverrideprotectedvirtual

Implements inet::OperationalBase.

{ return stage == INITSTAGE_ROUTING_PROTOCOLS; }

virtual bool inet::PIMBase::isNodeStartStage ( int  stage )

inlineoverrideprotectedvirtual

Implements inet::OperationalBase.

{ return stage == INITSTAGE_ROUTING_PROTOCOLS; }

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

inlineoverrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Reimplemented in inet::PIMDM, and inet::PIMSM.

{ return NUM_INIT_STAGES; }

void inet::PIMBase::processHelloPacket ( PIMHello *  pkt )

protected

Referenced by inet::PIMSM::handleMessageWhenUp().

{
    IPv4ControlInfo *ctrl = check_and_cast<IPv4ControlInfo *>(packet->getControlInfo());
    int interfaceId = ctrl->getInterfaceId();
    IPv4Address address = ctrl->getSrcAddr();
    int version = packet->getVersion();

    emit(rcvdHelloPkSignal, packet);

    // process options
    double holdTime = 3.5 * 30;
    long drPriority = -1L;
    unsigned int generationId = 0;
    for (unsigned int i = 0; i < packet->getOptionsArraySize(); i++) {
        HelloOption *option = packet->getOptions(i);
        if (dynamic_cast<HoldtimeOption *>(option))
            holdTime = (double)static_cast<HoldtimeOption *>(option)->getHoldTime();
        else if (dynamic_cast<DRPriorityOption *>(option))
            drPriority = static_cast<DRPriorityOption *>(option)->getPriority();
        else if (dynamic_cast<GenerationIDOption *>(option))
            generationId = static_cast<GenerationIDOption *>(option)->getGenerationID();
    }

    InterfaceEntry *ie = ift->getInterfaceById(interfaceId);

    EV_INFO << "Received PIM Hello from neighbor: interface=" << ie->getName() << " address=" << address << "\n";

    PIMNeighbor *neighbor = pimNbt->findNeighbor(interfaceId, address);
    if (neighbor)
        pimNbt->restartLivenessTimer(neighbor, holdTime);
    else {
        neighbor = new PIMNeighbor(ie, address, version);
        pimNbt->addNeighbor(neighbor, holdTime);

        // TODO If a Hello message is received from a new neighbor, the
        // receiving router SHOULD send its own Hello message after a random
        // delay between 0 and Triggered_Hello_Delay.
    }

    neighbor->setGenerationId(generationId);
    neighbor->setDRPriority(drPriority);

    delete packet;
}

void inet::PIMBase::processHelloTimer ( cMessage *  timer )

protected

Referenced by inet::PIMSM::handleMessageWhenUp().

{
    ASSERT(timer == helloTimer);
    EV_DETAIL << "Hello Timer expired.\n";
    sendHelloPackets();
    scheduleAt(simTime() + helloPeriod, helloTimer);
}

void inet::PIMBase::sendHelloPacket ( PIMInterface *  pimInterface )

protected

{
    EV_INFO << "Sending Hello packet on interface '" << pimInterface->getInterfacePtr()->getName() << "'\n";

    PIMHello *msg = new PIMHello("PIMHello");

    int byteLength = PIM_HEADER_LENGTH + 6 + 8;    // HoldTime + GenerationID option

    msg->setOptionsArraySize(designatedRouterPriority < 0 ? 2 : 3);
    HoldtimeOption *holdtimeOption = new HoldtimeOption();
    holdtimeOption->setHoldTime(holdTime < 0 ? (uint16_t)0xffff : (uint16_t)holdTime);
    msg->setOptions(0, holdtimeOption);

    GenerationIDOption *genIdOption = new GenerationIDOption();
    genIdOption->setGenerationID(generationID);
    msg->setOptions(1, genIdOption);

    if (designatedRouterPriority >= 0) {
        DRPriorityOption *drPriorityOption = new DRPriorityOption();
        drPriorityOption->setPriority(designatedRouterPriority);
        msg->setOptions(2, drPriorityOption);
        byteLength += 8;
    }

    IPv4ControlInfo *ctrl = new IPv4ControlInfo();
    ctrl->setDestAddr(ALL_PIM_ROUTERS_MCAST);
    ctrl->setProtocol(IP_PROT_PIM);
    ctrl->setTimeToLive(1);
    ctrl->setInterfaceId(pimInterface->getInterfaceId());
    msg->setControlInfo(ctrl);

    msg->setByteLength(byteLength);

    emit(sentHelloPkSignal, msg);

    send(msg, "ipOut");
}

void inet::PIMBase::sendHelloPackets ( )

protected

{
    for (int i = 0; i < pimIft->getNumInterfaces(); i++) {
        PIMInterface *pimInterface = pimIft->getInterface(i);
        if (pimInterface->getMode() == mode)
            sendHelloPacket(pimInterface);
    }
}

Member Data Documentation

const IPv4Address inet::PIMBase::ALL_PIM_ROUTERS_MCAST

staticprotected

Referenced by inet::PIMSM::sendPIMAssert(), inet::PIMSM::sendPIMJoin(), and inet::PIMSM::sendPIMPrune().

int inet::PIMBase::designatedRouterPriority = 0

protected

Referenced by inet::PIMSM::updateDesignatedRouterAddress().

uint32_t inet::PIMBase::generationID = 0

protected

double inet::PIMBase::helloPeriod = 0

protected

cMessage* inet::PIMBase::helloTimer = nullptr

protected

double inet::PIMBase::holdTime = 0

protected

Referenced by inet::PIMSM::processJoinPrunePacket().

const char* inet::PIMBase::hostname = nullptr

protected

IInterfaceTable* inet::PIMBase::ift = nullptr

protected

Referenced by inet::PIMSM::getIncomingInterface(), inet::PIMSM::processAssertPacket(), and inet::PIMSM::processJoinPrunePacket().

bool inet::PIMBase::isEnabled = false

protected

Referenced by inet::PIMSM::handleMessageWhenUp(), inet::PIMSM::handleNodeStart(), and inet::PIMSM::stopPIMRouting().

bool inet::PIMBase::isUp = false

protected

PIMInterface::PIMMode inet::PIMBase::mode = (PIMInterface::PIMMode)0

protected

PIMInterfaceTable* inet::PIMBase::pimIft = nullptr

protected

Referenced by inet::PIMSM::addNewRouteG(), inet::PIMSM::addNewRouteSG(), inet::PIMSM::getIncomingInterface(), inet::PIMSM::IamDR(), inet::PIMSM::receiveSignal(), inet::PIMSM::unroutableMulticastPacketArrived(), and inet::PIMSM::updateDesignatedRouterAddress().

PIMNeighborTable* inet::PIMBase::pimNbt = nullptr

protected

Referenced by inet::PIMSM::addNewRouteG(), inet::PIMSM::addNewRouteSG(), inet::PIMSM::processPruneG(), inet::PIMSM::processPrunePendingTimer(), inet::PIMSM::processPruneSG(), and inet::PIMSM::updateDesignatedRouterAddress().

simsignal_t inet::PIMBase::rcvdHelloPkSignal = registerSignal("rcvdHelloPk")

staticprotected

IIPv4RoutingTable* inet::PIMBase::rt = nullptr

protected

Referenced by inet::PIMSM::addNewRouteG(), inet::PIMSM::addNewRouteSG(), inet::PIMSM::clearRoutes(), inet::PIMSM::deleteMulticastRoute(), inet::PIMSM::findIPv4Route(), inet::PIMSM::multicastPacketForwarded(), inet::PIMSM::sendPIMJoin(), inet::PIMSM::sendPIMPrune(), inet::PIMSM::sendPIMRegisterNull(), inet::PIMSM::sendPIMRegisterStop(), and inet::PIMSM::unroutableMulticastPacketArrived().

simsignal_t inet::PIMBase::sentHelloPkSignal = registerSignal("sentHelloPk")

staticprotected

---

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

• PIMBase.h
• PIMBase.cc