inet::eigrp::EigrpRtpT< IPAddress > Class Template Reference

Class represents Reliable Transport Protocol for reliable transmission of EIGRP messages. More...

#include <EigrpRtp.h>

Inheritance diagram for inet::eigrp::EigrpRtpT< IPAddress >:

Classes
struct	NeighborInfo

Public Member Functions
	EigrpRtpT ()
virtual	~EigrpRtpT ()

Protected Member Functions
virtual void	initialize (int stage)
virtual void	handleMessage (cMessage *msg)
virtual int	numInitStages () const
void	initialize (int stage)
void	initialize (int stage)

Private Types
typedef std::list< EigrpMsgReq * >	MessageQueue

Private Member Functions
void	processRequest (cMessage *msg)
	Process request for message sending. More...
void	processHeader (cMessage *msg)
	Process message header for ensuring reliable transmission. More...
void	scheduleNextMsg (int ifaceId)
	Schedule sending next reliable/unreliable message in transmission queue. More...
void	scheduleNewMsg (EigrpMsgReq *msgReq)
	Schedule new request for sending message. More...
void	sendMsg (EigrpMsgReq *msgReq)
	Send reliable/unreliable message. More...
void	sendRelMsg (EigrpMsgReq *msgReq)
	Send reliable message. More...
void	sendUnrelMsg (EigrpMsgReq *msgReq)
	Send unreliable message. More...
void	discardMsg (EigrpMsgReq *msgReq)
	Delete request. More...
EigrpNeighbor< IPAddress > *	getNeighborId (cMessage *msg)
	Return informations about neighbor. More...
void	acknowledgeMsg (int neighId, int ifaceId, uint32_t ackNum)
	Send message with specified acknowledge number to neighbor. More...
EigrpNeighbor< Ipv4Address > *	getNeighborId (cMessage *msg)
EigrpNeighbor< Ipv6Address > *	getNeighborId (cMessage *msg)

Private Attributes
const char *	RTP_OUTPUT_GW
uint32_t	seqNumber
	Sequence number for reliable transport of messages. More...
EigrpRequestQueue *	requestQ
EigrpInterfaceTable *	eigrpIft
EigrpNeighborTable< IPAddress > *	eigrpNt

Detailed Description

template<typename IPAddress>
class inet::eigrp::EigrpRtpT< IPAddress >

Class represents Reliable Transport Protocol for reliable transmission of EIGRP messages.

Member Typedef Documentation

MessageQueue

template<typename IPAddress >

typedef std::list<EigrpMsgReq *> inet::eigrp::EigrpRtpT< IPAddress >::MessageQueue

private

Constructor & Destructor Documentation

EigrpRtpT()

template<typename IPAddress >

inet::eigrp::EigrpRtpT< IPAddress >::EigrpRtpT

{
    RTP_OUTPUT_GW = "pdmOut";
}

~EigrpRtpT()

template<typename IPAddress >

inet::eigrp::EigrpRtpT< IPAddress >::~EigrpRtpT

virtual

{
    delete requestQ;
}

Member Function Documentation

acknowledgeMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::acknowledgeMsg ( int  neighId, int  ifaceId, uint32_t  ackNum  )

private

Send message with specified acknowledge number to neighbor.

{
    EigrpMsgReq *msgReq = nullptr;
 
    /*if ((msgReq = requestQ->findReqByIf(ifaceId, false)) != nullptr && msgReq->getDestNeighbor() == neighId)
    { // Use scheduled message as acknowledge
        EV_DEBUG << "EIGRP RTP: do not create Ack message, use existing message to neighbor " << neighId << endl;
        msgReq->setAckNumber(ackNum);
    }
    else*/
    // Create Ack message and send it
    msgReq = new EigrpMsgReq("Ack");
    msgReq->setOpcode(EIGRP_HELLO_MSG);
    msgReq->setDestNeighbor(neighId);
    msgReq->setDestInterface(ifaceId);
    msgReq->setAckNumber(ackNum);
 
    scheduleNewMsg(msgReq);
}

discardMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::discardMsg ( EigrpMsgReq *  msgReq )

private

Delete request.

{
    EV_DEBUG << "EIGRP RTP: discard message " << eigrpRtp::UserMsgs[msgReq->getOpcode()] << endl;
    requestQ->removeReq(msgReq);
    delete msgReq;
 
    scheduleNextMsg(msgReq->getDestInterface());
}

getNeighborId() [1/3]

template<typename IPAddress >

EigrpNeighbor<IPAddress>* inet::eigrp::EigrpRtpT< IPAddress >::getNeighborId ( cMessage *  msg )

private

Return informations about neighbor.

getNeighborId() [2/3]

EigrpNeighbor< Ipv4Address > * inet::eigrp::EigrpRtpT< Ipv4Address >::getNeighborId ( cMessage *  msg )

private

{
    Packet *packet = check_and_cast<Packet *>(msg);
    Ipv4Address srcAddr = packet->getTag<L3AddressInd>()->getSrcAddress().toIpv4();
 
    return eigrpNt->findNeighbor(srcAddr);
}

getNeighborId() [3/3]

EigrpNeighbor< Ipv6Address > * inet::eigrp::EigrpRtpT< Ipv6Address >::getNeighborId ( cMessage *  msg )

private

{
    Packet *packet = check_and_cast<Packet *>(msg);
    Ipv6Address srcAddr = packet->getTag<L3AddressInd>()->getSrcAddress().toIpv6();
 
    return eigrpNt->findNeighbor(srcAddr);
}

handleMessage()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::handleMessage ( cMessage *  msg )

protectedvirtual

{
 
    if (msg->isSelfMessage()) { // Timer
    }
    else {
        if (dynamic_cast<EigrpMsgReq *>(msg) != nullptr) { // EIGRP message request
            processRequest(msg);
 
            // Do not delete msg
        }
        else { // Process EIGRP header
            processHeader(msg);
 
            delete msg;
        }
    }
}

initialize() [1/3]

template<typename IPAddress >

virtual void inet::eigrp::EigrpRtpT< IPAddress >::initialize ( int  stage )

protectedvirtual

initialize() [2/3]

void inet::eigrp::EigrpRtpT< Ipv4Address >::initialize ( int  stage )

protected

{
    cSimpleModule::initialize(stage);
    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        seqNumber = 1;
 
//        this->eigrpIft = EigrpIfTableAccess().get();
//        this->eigrpNt = Eigrpv4NeighTableAccess().get();
        eigrpIft = check_and_cast<EigrpInterfaceTable *>(getModuleByPath("^.eigrpInterfaceTable"));
        eigrpNt = check_and_cast<EigrpIpv4NeighborTable *>(getModuleByPath("^.eigrpIpv4NeighborTable"));
 
        requestQ = new EigrpRequestQueue();
 
//        WATCH_PTRLIST(requestQ->reqQueue);
    }
}

initialize() [3/3]

void inet::eigrp::EigrpRtpT< Ipv6Address >::initialize ( int  stage )

protected

{
    cSimpleModule::initialize(stage);
    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        seqNumber = 1;
 
//        this->eigrpIft = EigrpIfTable6Access().get();
//        this->eigrpNt = Eigrpv6NeighTableAccess().get();
        eigrpIft = check_and_cast<EigrpInterfaceTable *>(getModuleByPath("^.eigrpInterfaceTable6"));
        eigrpNt = check_and_cast<EigrpIpv6NeighborTable *>(getModuleByPath("^.eigrpIpv6NeighborTable"));
        requestQ = new EigrpRequestQueue();
 
//        WATCH_PTRLIST(requestQ->reqQueue);
    }
}

numInitStages()

template<typename IPAddress >

virtual int inet::eigrp::EigrpRtpT< IPAddress >::numInitStages ( ) const

inlineprotectedvirtual

{ return NUM_INIT_STAGES; }

processHeader()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::processHeader ( cMessage *  msg )

private

Process message header for ensuring reliable transmission.

{
    Packet *pk = check_and_cast<Packet *>(msg);
    const auto& header = pk->peekAtFront<EigrpMessage>();
    uint32_t seqNumNeigh; // Sequence number of neighbor
    uint32_t ackNum; // Acknowledge number
    EigrpMsgReq *msgReq = nullptr;
    int numOfAck;
    EigrpNeighbor<IPAddress> *neigh = nullptr;
    EigrpInterface *eigrpIface = nullptr;
 
    if ((neigh = getNeighborId(msg)) == nullptr)
        return;
 
//    EV_DEBUG << "EIGRP RTP: received " << eigrpRtp::UserMsgs[header->getOpcode()] << " message for processing" << endl;
    //header->getOpcode() == EIGRP_UPDATE_MSG
    seqNumNeigh = header->getSeqNum();
    ackNum = header->getAckNum();
 
    if (ackNum != 0) { // Acknowledge of message
        if ((msgReq = requestQ->findReqBySeq(ackNum)) != nullptr && neigh->getAck() == ackNum) { // Record ack
            neigh->setAck(0);
            numOfAck = msgReq->getNumOfAck();
            msgReq->setNumOfAck(--numOfAck);
 
            if (numOfAck == 0) { // All acknowledges received
                eigrpIface = eigrpIft->findInterfaceById(neigh->getIfaceId());
                eigrpIface->decPendingMsgs();
 
                // Delete request
                requestQ->removeReq(msgReq);
                delete msgReq;
                msgReq = nullptr;
 
                scheduleNextMsg(neigh->getIfaceId());
            }
        }
        // else do nothing (wrong message ack)
    }
 
    if (seqNumNeigh != 0) { // Received message must be acknowledged
        // Store last sequence number from neighbor
        neigh->setSeqNumber(seqNumNeigh);
 
        acknowledgeMsg(neigh->getNeighborId(), neigh->getIfaceId(), seqNumNeigh);
    }
}

processRequest()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::processRequest ( cMessage *  msg )

private

Process request for message sending.

{
    EigrpMsgReq *msgReq = check_and_cast<EigrpMsgReq *>(msg);
 
    scheduleNewMsg(msgReq);
}

scheduleNewMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::scheduleNewMsg ( EigrpMsgReq *  msgReq )

private

Schedule new request for sending message.

{
    requestQ->pushReq(msgReq);
 
    EV_DEBUG << "EIGRP RTP: enqueue " << eigrpRtp::UserMsgs[msgReq->getOpcode()];
    if (msgReq->getOpcode() == EIGRP_HELLO_MSG && msgReq->getAckNumber() != 0)
        EV_DEBUG << " (ack) ";
    EV_DEBUG << " on IF: " << msgReq->getDestInterface() << endl;
 
    scheduleNextMsg(msgReq->getDestInterface());
}

scheduleNextMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::scheduleNextMsg ( int  ifaceId )

private

Schedule sending next reliable/unreliable message in transmission queue.

{
    EigrpMsgReq *msgReq = nullptr;
    EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(ifaceId);
 
    if (eigrpIface == nullptr) {
        requestQ->removeAllMsgsToIf(ifaceId);
        return;
    }
 
    if (eigrpIface->getPendingMsgs() == 0) { // Try to send first rel/unrel message
        if ((msgReq = requestQ->findReqByIf(ifaceId)) != nullptr) {
            ASSERT(msgReq->getNumOfAck() == 0);
            sendMsg(msgReq);
        }
    }
    else { // Try to send first unrel message
        if ((msgReq = requestQ->findUnrelReqByIf(ifaceId)) != nullptr) {
            sendUnrelMsg(msgReq);
        }
    }
}

sendMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::sendMsg ( EigrpMsgReq *  msgReq )

private

Send reliable/unreliable message.

{
    if (msgReq->isMsgReliable()) { // Reliable
        sendRelMsg(msgReq);
    }
    else { // Unreliable
        sendUnrelMsg(msgReq);
    }
}

sendRelMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::sendRelMsg ( EigrpMsgReq *  msgReq )

private

Send reliable message.

{
    NeighborInfo info;
    EigrpMsgReq *msgToSend = nullptr;
    EigrpNeighbor<IPAddress> *neigh = nullptr;
    EigrpInterface *eigrpIface = nullptr;
 
    info.neighborId = msgReq->getDestNeighbor();
    info.neighborIfaceId = msgReq->getDestInterface();
 
    if (msgReq->getSeqNumber() == 0) { // Add sequence number
        msgReq->setSeqNumber(seqNumber);
        seqNumber++;
    }
 
    if (info.neighborId != 0) { // Unicast
        if ((neigh = eigrpNt->findNeighborById(info.neighborId)) == nullptr) {
            requestQ->removeAllMsgsToNeigh(info.neighborId);
            discardMsg(msgReq);
            return;
        }
        info.numOfAck = 1;
        neigh->setAck(msgReq->getSeqNumber());
        info.lastSeqNum = neigh->getSeqNumber();
    }
    else { // Multicast
        info.numOfAck = eigrpNt->setAckOnIface(info.neighborIfaceId, msgReq->getSeqNumber());
        info.lastSeqNum = 0; // Multicast message can not be an ack
    }
 
    eigrpIface = eigrpIft->findInterfaceById(info.neighborIfaceId);
    eigrpIface->incPendingMsgs();
 
    // Add last sequence number from neighbor
    msgReq->setAckNumber(info.lastSeqNum);
    msgReq->setNumOfAck(info.numOfAck);
 
    // Request and message must be duplicated (PDM deletes request and sends message)
    msgToSend = msgReq->dup();
    send(msgToSend, RTP_OUTPUT_GW);
 
    scheduleNextMsg(info.neighborIfaceId);
}

sendUnrelMsg()

template<typename IPAddress >

void inet::eigrp::EigrpRtpT< IPAddress >::sendUnrelMsg ( EigrpMsgReq *  msgReq )

private

Send unreliable message.

{
    int ifaceId = msgReq->getDestInterface();
 
    requestQ->removeReq(msgReq);
    send(msgReq, RTP_OUTPUT_GW); /* Do not duplicate EigrpMsgReq */
    // Schedule next waiting message
    scheduleNextMsg(ifaceId);
}

Member Data Documentation

eigrpIft

template<typename IPAddress >

EigrpInterfaceTable* inet::eigrp::EigrpRtpT< IPAddress >::eigrpIft

private

eigrpNt

template<typename IPAddress >

EigrpNeighborTable<IPAddress>* inet::eigrp::EigrpRtpT< IPAddress >::eigrpNt

private

requestQ

template<typename IPAddress >

EigrpRequestQueue* inet::eigrp::EigrpRtpT< IPAddress >::requestQ

private

RTP_OUTPUT_GW

template<typename IPAddress >

const char* inet::eigrp::EigrpRtpT< IPAddress >::RTP_OUTPUT_GW

private

seqNumber

template<typename IPAddress >

uint32_t inet::eigrp::EigrpRtpT< IPAddress >::seqNumber

private

Sequence number for reliable transport of messages.

---

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

• EigrpRtp.h
• EigrpRtp.cc