inet::ospfv3::Ospfv3Neighbor Class Reference

#include <Ospfv3Neighbor.h>

Classes
struct	TransmittedLSA

Public Types
enum	Ospfv3NeighborEventType {   HELLO_RECEIVED = 0, START = 1, TWOWAY_RECEIVED = 2, NEGOTIATION_DONE = 3,   EXCHANGE_DONE = 4, BAD_LINK_STATE_REQUEST = 5, LOADING_DONE = 6, IS_ADJACENCY_OK = 7,   SEQUENCE_NUMBER_MISMATCH = 8, ONEWAY_RECEIVED = 9, KILL_NEIGHBOR = 10, INACTIVITY_TIMER = 11,   POLL_TIMER = 12, LINK_DOWN = 13, DD_RETRANSMISSION_TIMER = 14, UPDATE_RETRANSMISSION_TIMER = 15,   REQUEST_RETRANSMISSION_TIMER = 16 }
enum	Ospfv3NeighborStateType {   DOWN_STATE = 0, ATTEMPT_STATE = 1, INIT_STATE = 2, TWOWAY_STATE = 4,   EXCHANGE_START_STATE = 8, EXCHANGE_STATE = 16, LOADING_STATE = 32, FULL_STATE = 64 }
enum	Ospfv3DatabaseExchangeRelationshipType { MASTER = 0, SLAVE = 1 }

Public Member Functions
	Ospfv3Neighbor (Ipv4Address newId, Ospfv3Interface *parent)
virtual	~Ospfv3Neighbor ()
void	setNeighborPriority (int newPriority)
void	setNeighborDeadInterval (int newInterval)
void	setNeighborID (Ipv4Address newId)
void	setNeighborAddress (Ipv6Address newAddress)
void	setDesignatedRouterID (Ipv4Address newId)
void	setBackupDesignatedRouterID (Ipv4Address newId)
void	setOptions (Ospfv3Options options)
void	setDatabaseExchangeRelationship (Ospfv3DatabaseExchangeRelationshipType newRelationship)
void	setDDSequenceNumber (unsigned long newSequenceNmr)
void	setupDesignatedRouters (bool setUp)
void	setNeighborInterfaceID (uint32_t newID)
bool	designatedRoutersAreSetUp () const
Ospfv3Interface *	getInterface ()
Ipv4Address	getNeighborID ()
Ipv4Address	getNeighborsDR ()
Ipv4Address	getNeighborsBackup ()
Ipv6Address	getNeighborIP ()
L3Address	getNeighborBackupIP ()
L3Address	getNeighborDesignatedIP ()
uint32_t	getNeighborInterfaceID ()
Ospfv3Options	getOptions () const
Ospfv3DatabaseExchangeRelationshipType	getDatabaseExchangeRelationship ()
unsigned long	getDDSequenceNumber ()
Ospfv3NeighborStateType	getState () const
unsigned short	getNeighborPriority ()
unsigned short	getNeighborDeadInterval ()
void	processEvent (Ospfv3Neighbor::Ospfv3NeighborEventType event)
void	changeState (Ospfv3NeighborState *newState, Ospfv3NeighborState *currentState)
void	reset ()
cMessage *	getInactivityTimer ()
cMessage *	getPollTimer ()
cMessage *	getDDRetransmissionTimer ()
cMessage *	getUpdateRetransmissionTimer ()
cMessage *	getRequestRetransmissionTimer ()
bool	needAdjacency ()
bool	isFirstAdjacencyInited () const
void	initFirstAdjacency ()
unsigned long	getUniqueULong ()
void	incrementDDSequenceNumber ()
void	startUpdateRetransmissionTimer ()
void	clearUpdateRetransmissionTimer ()
void	startRequestRetransmissionTimer ()
void	clearRequestRetransmissionTimer ()
void	sendDDPacket (bool init=false)
void	sendLinkStateRequestPacket ()
void	setLastReceivedDDPacket (Ospfv3DdPacketId packetID)
Ospfv3DdPacketId	getLastReceivedDDPacket ()
bool	isLinkStateRequestListEmpty ()
bool	isRequestRetransmissionTimerActive ()
bool	isUpdateRetransmissionTimerActive () const
unsigned long	getDatabaseSummaryListCount () const
void	createDatabaseSummary ()
void	deleteLastSentDDPacket ()
void	retransmitUpdatePacket ()
void	addToRetransmissionList (const Ospfv3Lsa *lsaC)
void	removeFromRetransmissionList (LSAKeyType lsaKey)
Ospfv3Lsa *	findOnRetransmissionList (LSAKeyType lsaKey)
bool	isRetransmissionListEmpty () const
void	ageTransmittedLSAList ()
bool	isLinkStateRequestListEmpty (LSAKeyType lsaKey) const
void	addToRequestList (const Ospfv3LsaHeader *lsaHeader)
bool	retransmitDatabaseDescriptionPacket ()
bool	isLSAOnRequestList (LSAKeyType lsaKey)
Ospfv3LsaHeader *	findOnRequestList (LSAKeyType lsaKey)
void	removeFromRequestList (LSAKeyType lsaKey)
void	addToTransmittedLSAList (LSAKeyType lsaKey)
bool	isOnTransmittedLSAList (LSAKeyType lsaKey) const
void	setLastHelloTime (int time)
int	getLastHelloTime ()

Private Attributes
Ospfv3NeighborState *	state = nullptr
Ospfv3NeighborState *	previousState = nullptr
cMessage *	inactivityTimer = nullptr
cMessage *	pollTimer = nullptr
cMessage *	ddRetransmissionTimer = nullptr
cMessage *	updateRetransmissionTimer = nullptr
bool	updateRetransmissionTimerActive = false
cMessage *	requestRetransmissionTimer = nullptr
bool	requestRetransmissionTimerActive = false
Ospfv3DatabaseExchangeRelationshipType	databaseExchangeRelationship = static_cast<Ospfv3DatabaseExchangeRelationshipType>(-1)
bool	firstAdjacencyInited = false
unsigned long	ddSequenceNumber
Ospfv3DdPacketId	lastReceivedDDPacket
unsigned short	neighborRtrPriority
Ipv4Address	neighborId
Ipv6Address	neighborIPAddress
Ospfv3Options	neighborOptions
Ipv4Address	neighborsDesignatedRouter
Ipv4Address	neighborsBackupDesignatedRouter
L3Address	neighborsBackupIP
	Backup advertised by the router. More...
L3Address	neighborsDesignatedIP
uint32_t	neighborInterfaceID
bool	designatedRoutersSetUp = false
short	neighborsRouterDeadInterval = 0
std::list< Ospfv3Lsa * >	linkStateRetransmissionList
std::list< Ospfv3LsaHeader * >	databaseSummaryList
std::list< Ospfv3LsaHeader * >	linkStateRequestList
std::list< TransmittedLSA >	transmittedLSAs
Packet *	lastTransmittedDDPacket = nullptr
Ospfv3Interface *	containingInterface = nullptr
int	last_hello_received = 0

Static Private Attributes
static unsigned long	ddSequenceNumberInitSeed = 0

Member Enumeration Documentation

Ospfv3DatabaseExchangeRelationshipType

enum inet::ospfv3::Ospfv3Neighbor::Ospfv3DatabaseExchangeRelationshipType

Enumerator
MASTER
SLAVE

                                                {
        MASTER = 0,
        SLAVE  = 1
    };

Ospfv3NeighborEventType

enum inet::ospfv3::Ospfv3Neighbor::Ospfv3NeighborEventType

Enumerator
HELLO_RECEIVED
START
TWOWAY_RECEIVED
NEGOTIATION_DONE
EXCHANGE_DONE
BAD_LINK_STATE_REQUEST
LOADING_DONE
IS_ADJACENCY_OK
SEQUENCE_NUMBER_MISMATCH
ONEWAY_RECEIVED
KILL_NEIGHBOR
INACTIVITY_TIMER
POLL_TIMER
LINK_DOWN
DD_RETRANSMISSION_TIMER
UPDATE_RETRANSMISSION_TIMER
REQUEST_RETRANSMISSION_TIMER

                                 {
        HELLO_RECEIVED               = 0,
        START                        = 1,
        TWOWAY_RECEIVED              = 2,
        NEGOTIATION_DONE             = 3,
        EXCHANGE_DONE                = 4,
        BAD_LINK_STATE_REQUEST       = 5,
        LOADING_DONE                 = 6,
        IS_ADJACENCY_OK              = 7,
        SEQUENCE_NUMBER_MISMATCH     = 8,
        ONEWAY_RECEIVED              = 9,
        KILL_NEIGHBOR                = 10,
        INACTIVITY_TIMER             = 11,
        POLL_TIMER                   = 12,
        LINK_DOWN                    = 13,
        DD_RETRANSMISSION_TIMER      = 14,
        UPDATE_RETRANSMISSION_TIMER  = 15,
        REQUEST_RETRANSMISSION_TIMER = 16
    };

Ospfv3NeighborStateType

enum inet::ospfv3::Ospfv3Neighbor::Ospfv3NeighborStateType

Enumerator
DOWN_STATE
ATTEMPT_STATE
INIT_STATE
TWOWAY_STATE
EXCHANGE_START_STATE
EXCHANGE_STATE
LOADING_STATE
FULL_STATE

                                 {
        DOWN_STATE           = 0,
        ATTEMPT_STATE        = 1,
        INIT_STATE           = 2,
        TWOWAY_STATE         = 4,
        EXCHANGE_START_STATE = 8,
        EXCHANGE_STATE       = 16,
        LOADING_STATE        = 32,
        FULL_STATE           = 64
    };

Constructor & Destructor Documentation

Ospfv3Neighbor()

inet::ospfv3::Ospfv3Neighbor::Ospfv3Neighbor	(	Ipv4Address	newId,
		Ospfv3Interface *	parent
	)

{
    EV_DEBUG << "$$$$$$ New Ospfv3Neighbor has been created\n";
    this->neighborId = newId;
    this->state = new Ospfv3NeighborStateDown;
    this->containingInterface = parent;
    this->neighborsDesignatedRouter = NULL_IPV4ADDRESS;
    this->neighborsBackupDesignatedRouter = NULL_IPV4ADDRESS;
    this->neighborsRouterDeadInterval = DEFAULT_DEAD_INTERVAL;
    // this is always only link local address
    this->neighborIPAddress = Ipv6Address::UNSPECIFIED_ADDRESS;
    if (this->getInterface()->getArea()->getInstance()->getAddressFamily() == IPV6INSTANCE) {
        this->neighborsDesignatedIP = Ipv6Address::UNSPECIFIED_ADDRESS;
        this->neighborsBackupIP = Ipv6Address::UNSPECIFIED_ADDRESS;
    }
    else {
        this->neighborsDesignatedIP = Ipv4Address::UNSPECIFIED_ADDRESS;
        this->neighborsBackupIP = Ipv4Address::UNSPECIFIED_ADDRESS;
    }
 
    inactivityTimer = new cMessage("Ospfv3Neighbor::NeighborInactivityTimer", NEIGHBOR_INACTIVITY_TIMER);
    inactivityTimer->setContextPointer(this);
    pollTimer = new cMessage("Ospfv3Neighbor::NeighborPollTimer", NEIGHBOR_POLL_TIMER);
    pollTimer->setContextPointer(this);
    ddRetransmissionTimer = new cMessage("Ospfv3Neighbor::NeighborDDRetransmissionTimer", NEIGHBOR_DD_RETRANSMISSION_TIMER);
    ddRetransmissionTimer->setContextPointer(this);
    updateRetransmissionTimer = new cMessage("Ospfv3Neighbor::Neighbor::NeighborUpdateRetransmissionTimer", NEIGHBOR_UPDATE_RETRANSMISSION_TIMER);
    updateRetransmissionTimer->setContextPointer(this);
    requestRetransmissionTimer = new cMessage("Ospfv3sNeighbor::NeighborRequestRetransmissionTimer", NEIGHBOR_REQUEST_RETRANSMISSION_TIMER);
    requestRetransmissionTimer->setContextPointer(this);
} // constructor

~Ospfv3Neighbor()

inet::ospfv3::Ospfv3Neighbor::~Ospfv3Neighbor ( )

virtual

{
    reset();
    Ospfv3Process *proc = this->getInterface()->getArea()->getInstance()->getProcess();
    proc->clearTimer(inactivityTimer);
    proc->clearTimer(pollTimer);
    proc->clearTimer(ddRetransmissionTimer);
    proc->clearTimer(updateRetransmissionTimer);
    proc->clearTimer(requestRetransmissionTimer);
    delete inactivityTimer;
    delete pollTimer;
    delete ddRetransmissionTimer;
    delete updateRetransmissionTimer;
    delete requestRetransmissionTimer;
    if (previousState != nullptr) {
        delete previousState;
    }
    delete state;
} // destructor

Member Function Documentation

addToRequestList()

void inet::ospfv3::Ospfv3Neighbor::addToRequestList

(

const Ospfv3LsaHeader *

lsaHeader

)

{
    linkStateRequestList.push_back(new Ospfv3LsaHeader(*lsaHeader));
    EV_DEBUG << "Currently on request list:\n";
    for (auto it = linkStateRequestList.begin(); it != linkStateRequestList.end(); it++) {
        EV_DEBUG << "\tType: " << (*it)->getLsaType() << ", ID: " << (*it)->getLinkStateID() << ", Adv: " << (*it)->getAdvertisingRouter() << "\n";
    }
}

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket().

addToRetransmissionList()

void inet::ospfv3::Ospfv3Neighbor::addToRetransmissionList

(

const Ospfv3Lsa *

lsaC

)

{
    auto it = linkStateRetransmissionList.begin();
    for (; it != linkStateRetransmissionList.end(); it++) {
        if (((*it)->getHeader().getLinkStateID() == lsa->getHeader().getLinkStateID()) &&
            ((*it)->getHeader().getAdvertisingRouter().getInt() == lsa->getHeader().getAdvertisingRouter().getInt()))
        {
            break;
        }
    }
 
    Ospfv3Lsa *lsaCopy = lsa->dup();
//    switch (lsaC->getHeader().getLsaType()) {
//        case ROUTER_LSA:
//            lsaCopy = new Ospfv3RouterLsa((const_cast<Ospfv3Lsa*>(lsaC))));
//            break;
//
//        case NETWORK_LSA:
//            lsaCopy = new Ospfv3NetworkLsa(*(check_and_cast<Ospfv3NetworkLsa *>(const_cast<Ospfv3Lsa*>(lsaC))));
//            break;
//
//        case INTER_AREA_PREFIX_LSA:
//            lsaCopy = new Ospfv3InterAreaPrefixLsa(*(check_and_cast<Ospfv3InterAreaPrefixLsa* >(const_cast<Ospfv3Lsa*>(lsaC))));
//            break;
//
//        case LINK_LSA:
//            lsaCopy = new Ospfv3LinkLsa(*(check_and_cast<Ospfv3LinkLsa *>(const_cast<Ospfv3Lsa*>(lsaC))));
//            break;
//
//        case INTRA_AREA_PREFIX_LSA:
//            lsaCopy = new Ospfv3IntraAreaPrefixLsa(*(check_and_cast<Ospfv3IntraAreaPrefixLsa *>(const_cast<Ospfv3Lsa*>(lsaC))));
//            break;
//
//        default:
//            ASSERT(false);    // error
//            break;
//    }
 
    // if LSA is on retransmission list then replace it
    if (it != linkStateRetransmissionList.end()) {
        delete *it;
        *it = static_cast<Ospfv3Lsa *>(lsaCopy);
    }
    else {
        // if not then add it
        linkStateRetransmissionList.push_back(static_cast<Ospfv3Lsa *>(lsaCopy));
    }
}

addToTransmittedLSAList()

void inet::ospfv3::Ospfv3Neighbor::addToTransmittedLSAList

(

LSAKeyType

lsaKey

)

{
    TransmittedLSA transmit;
 
    transmit.lsaKey = lsaKey;
    transmit.age = 0;
 
    transmittedLSAs.push_back(transmit);
} // addToTransmittedLSAList

Referenced by inet::ospfv3::Ospfv3Interface::floodLSA().

ageTransmittedLSAList()

void inet::ospfv3::Ospfv3Neighbor::ageTransmittedLSAList

(

)

{
    auto it = transmittedLSAs.begin();
    while ((it != transmittedLSAs.end()) && (it->age == MIN_LS_ARRIVAL)) {
        transmittedLSAs.pop_front();
        it = transmittedLSAs.begin();
    }
//    for (long i = 0; i < transmittedLSAs.size(); i++)
//    {
//        transmittedLSAs[i].age++;
//    }
    for (it = transmittedLSAs.begin(); it != transmittedLSAs.end(); it++) {
        it->age++;
    }
} // ageTransmittedLSAList

changeState()

void inet::ospfv3::Ospfv3Neighbor::changeState	(	Ospfv3NeighborState *	newState,
		Ospfv3NeighborState *	currentState
	)

{
    if (this->previousState != nullptr) {
        EV_DEBUG << "Changing neighbor from state" << currentState->getNeighborStateString() << " to " << newState->getNeighborStateString() << "\n";
        delete this->previousState;
    }
    this->state = newState;
    this->previousState = currentState;
}

Referenced by inet::ospfv3::Ospfv3NeighborState::changeState().

clearRequestRetransmissionTimer()

void inet::ospfv3::Ospfv3Neighbor::clearRequestRetransmissionTimer

(

)

{
    this->getInterface()->getArea()->getInstance()->getProcess()->clearTimer(this->getRequestRetransmissionTimer());
    this->requestRetransmissionTimerActive = false;
}

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), removeFromRequestList(), and reset().

clearUpdateRetransmissionTimer()

void inet::ospfv3::Ospfv3Neighbor::clearUpdateRetransmissionTimer

(

)

{
    this->getInterface()->getArea()->getInstance()->getProcess()->clearTimer(this->getUpdateRetransmissionTimer());
    this->updateRetransmissionTimerActive = false;
}

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3Interface::processLSAck(), and reset().

createDatabaseSummary()

void inet::ospfv3::Ospfv3Neighbor::createDatabaseSummary

(

)

{
    Ospfv3Area *area = this->getInterface()->getArea();
    int routerLSACount = area->getRouterLSACount();
 
    for (int i = 0; i < routerLSACount; i++) {
        Ospfv3LsaHeader *lsaHeader = new Ospfv3LsaHeader(area->getRouterLSA(i)->getHeader());
        this->databaseSummaryList.push_back(lsaHeader);
    }
 
    int networkLSACount = area->getNetworkLSACount();
    for (int i = 0; i < networkLSACount; i++) {
        Ospfv3LsaHeader *lsaHeader = new Ospfv3LsaHeader(area->getNetworkLSA(i)->getHeader());
        this->databaseSummaryList.push_back(lsaHeader);
    }
 
    int interAreaPrefixCount = area->getInterAreaPrefixLSACount();
    for (int i = 0; i < interAreaPrefixCount; i++) {
        Ospfv3LsaHeader *lsaHeader = new Ospfv3LsaHeader(area->getInterAreaPrefixLSA(i)->getHeader());
        this->databaseSummaryList.push_back(lsaHeader);
    }
 
    int linkLsaCount = this->getInterface()->getLinkLSACount();
    for (int i = 0; i < linkLsaCount; i++) {
        Ospfv3LsaHeader *lsaHeader = new Ospfv3LsaHeader(this->getInterface()->getLinkLSA(i)->getHeader());
        this->databaseSummaryList.push_back(lsaHeader);
    }
 
    int intraAreaPrefixCnt = area->getIntraAreaPrefixLSACount();
    for (int i = 0; i < intraAreaPrefixCnt; i++) {
        Ospfv3LsaHeader *lsaHeader = new Ospfv3LsaHeader(area->getIntraAreaPrefixLSA(i)->getHeader());
        this->databaseSummaryList.push_back(lsaHeader);
    }
}

Referenced by inet::ospfv3::Ospfv3NeighborStateExStart::processEvent().

deleteLastSentDDPacket()

void inet::ospfv3::Ospfv3Neighbor::deleteLastSentDDPacket

(

)

{
    if (lastTransmittedDDPacket != nullptr) {
        delete lastTransmittedDDPacket;
        lastTransmittedDDPacket = nullptr;
    }
} // deleteLastSentDDPacket

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), and inet::ospfv3::Ospfv3NeighborStateLoading::processEvent().

designatedRoutersAreSetUp()

bool inet::ospfv3::Ospfv3Neighbor::designatedRoutersAreSetUp ( ) const

inline

{ return designatedRoutersSetUp; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

findOnRequestList()

Ospfv3LsaHeader * inet::ospfv3::Ospfv3Neighbor::findOnRequestList

(

LSAKeyType

lsaKey

)

{
    // linkStateRequestList - list of LSAs that need to be received from the neighbor
    for (auto it = linkStateRequestList.begin(); it != linkStateRequestList.end(); it++) {
        if (((*it)->getLinkStateID() == lsaKey.linkStateID) &&
            ((*it)->getAdvertisingRouter() == lsaKey.advertisingRouter))
        {
            return *it;
        }
    }
    return nullptr;
}

Referenced by isLSAOnRequestList().

findOnRetransmissionList()

Ospfv3Lsa * inet::ospfv3::Ospfv3Neighbor::findOnRetransmissionList

(

LSAKeyType

lsaKey

)

{
    for (auto& elem : linkStateRetransmissionList) {
        if (((elem)->getHeader().getLinkStateID() == lsaKey.linkStateID) &&
            ((elem)->getHeader().getAdvertisingRouter() == lsaKey.advertisingRouter))
        {
            return elem;
        }
    }
    return nullptr;
}

Referenced by inet::ospfv3::Ospfv3Interface::processLSAck().

getDatabaseExchangeRelationship()

Ospfv3DatabaseExchangeRelationshipType inet::ospfv3::Ospfv3Neighbor::getDatabaseExchangeRelationship ( )

inline

{ return this->databaseExchangeRelationship; }

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket(), and inet::ospfv3::Ospfv3Interface::processDDPacket().

getDatabaseSummaryListCount()

unsigned long inet::ospfv3::Ospfv3Neighbor::getDatabaseSummaryListCount ( ) const

inline

{ return databaseSummaryList.size(); }

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), and sendDDPacket().

getDDRetransmissionTimer()

cMessage* inet::ospfv3::Ospfv3Neighbor::getDDRetransmissionTimer ( )

inline

{ return this->ddRetransmissionTimer; }

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), and inet::ospfv3::Ospfv3NeighborStateInit::processEvent().

getDDSequenceNumber()

unsigned long inet::ospfv3::Ospfv3Neighbor::getDDSequenceNumber ( )

inline

{ return this->ddSequenceNumber; }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket().

getInactivityTimer()

cMessage* inet::ospfv3::Ospfv3Neighbor::getInactivityTimer ( )

inline

{ return this->inactivityTimer; }

Referenced by inet::ospfv3::Ospfv3NeighborStateAttempt::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateDown::processEvent(), inet::ospfv3::Ospfv3NeighborStateInit::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExStart::processEvent().

getInterface()

Ospfv3Interface* inet::ospfv3::Ospfv3Neighbor::getInterface ( )

inline

{ return this->containingInterface; }

Referenced by inet::ospfv3::Ospfv3Interface::addNeighbor(), inet::ospfv3::Ospfv3NeighborState::changeState(), clearRequestRetransmissionTimer(), clearUpdateRetransmissionTimer(), createDatabaseSummary(), inet::ospfv3::Ospfv3Process::handleTimer(), needAdjacency(), Ospfv3Neighbor(), inet::ospfv3::Ospfv3NeighborStateAttempt::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateDown::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborStateInit::processEvent(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), reset(), retransmitDatabaseDescriptionPacket(), retransmitUpdatePacket(), sendDDPacket(), sendLinkStateRequestPacket(), startRequestRetransmissionTimer(), startUpdateRetransmissionTimer(), and ~Ospfv3Neighbor().

getLastHelloTime()

int inet::ospfv3::Ospfv3Neighbor::getLastHelloTime ( )

inline

{ return this->last_hello_received; }

Referenced by inet::ospfv3::Ospfv3Instance::detailedInfo().

getLastReceivedDDPacket()

Ospfv3DdPacketId inet::ospfv3::Ospfv3Neighbor::getLastReceivedDDPacket ( )

inline

{ return this->lastReceivedDDPacket; }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket().

getNeighborBackupIP()

L3Address inet::ospfv3::Ospfv3Neighbor::getNeighborBackupIP ( )

inline

{ return this->neighborsBackupIP; }

getNeighborDeadInterval()

unsigned short inet::ospfv3::Ospfv3Neighbor::getNeighborDeadInterval ( )

inline

{ return this->neighborsRouterDeadInterval; }

Referenced by inet::ospfv3::Ospfv3NeighborStateAttempt::processEvent(), and inet::ospfv3::Ospfv3NeighborStateDown::processEvent().

getNeighborDesignatedIP()

L3Address inet::ospfv3::Ospfv3Neighbor::getNeighborDesignatedIP ( )

inline

{ return this->neighborsDesignatedIP; }

getNeighborID()

Ipv4Address inet::ospfv3::Ospfv3Neighbor::getNeighborID ( )

inline

{ return this->neighborId; }

Referenced by inet::ospfv3::Ospfv3Interface::addNeighbor(), inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Area::calculateNextHops(), inet::ospfv3::Ospfv3NeighborState::changeState(), inet::ospfv3::Ospfv3Instance::detailedInfo(), inet::ospfv3::Ospfv3Interface::floodLSA(), inet::ospfv3::Ospfv3Process::handleTimer(), needAdjacency(), inet::ospfv3::Ospfv3Area::originateNetworkLSA(), inet::ospfv3::Ospfv3Area::originateRouterLSA(), inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), inet::ospfv3::Ospfv3Interface::processHelloPacket(), inet::ospfv3::Ospfv3Interface::removeNeighborByID(), and reset().

getNeighborInterfaceID()

uint32_t inet::ospfv3::Ospfv3Neighbor::getNeighborInterfaceID ( )

inline

{ return this->neighborInterfaceID; }

Referenced by inet::ospfv3::Ospfv3Interface::addNeighbor(), inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Area::calculateNextHops(), inet::ospfv3::Ospfv3Instance::detailedInfo(), and inet::ospfv3::Ospfv3Area::originateRouterLSA().

getNeighborIP()

Ipv6Address inet::ospfv3::Ospfv3Neighbor::getNeighborIP ( )

inline

{ return this->neighborIPAddress; }

Referenced by inet::ospfv3::Ospfv3Interface::acknowledgeLSA(), inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3NeighborStateDown::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDrOther::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDr::processEvent(), inet::ospfv3::Ospfv3InterfaceStateWaiting::processEvent(), inet::ospfv3::Ospfv3InterfaceStatePointToPoint::processEvent(), inet::ospfv3::Ospfv3InterfaceStateBackup::processEvent(), inet::ospfv3::Ospfv3Interface::processHelloPacket(), inet::ospfv3::Ospfv3Interface::processLSR(), inet::ospfv3::Ospfv3Interface::processLSU(), retransmitDatabaseDescriptionPacket(), retransmitUpdatePacket(), sendDDPacket(), and sendLinkStateRequestPacket().

getNeighborPriority()

unsigned short inet::ospfv3::Ospfv3Neighbor::getNeighborPriority ( )

inline

{ return this->neighborRtrPriority; }

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Instance::detailedInfo(), inet::ospfv3::Ospfv3InterfaceStateDown::processEvent(), inet::ospfv3::Ospfv3InterfaceStateDrOther::processEvent(), inet::ospfv3::Ospfv3InterfaceStateWaiting::processEvent(), and inet::ospfv3::Ospfv3Interface::processHelloPacket().

getNeighborsBackup()

Ipv4Address inet::ospfv3::Ospfv3Neighbor::getNeighborsBackup ( )

inline

{ return this->neighborsBackupDesignatedRouter; }

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), and inet::ospfv3::Ospfv3Interface::processHelloPacket().

getNeighborsDR()

Ipv4Address inet::ospfv3::Ospfv3Neighbor::getNeighborsDR ( )

inline

{ return this->neighborsDesignatedRouter; }

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), and inet::ospfv3::Ospfv3Interface::processHelloPacket().

getOptions()

Ospfv3Options inet::ospfv3::Ospfv3Neighbor::getOptions ( ) const

inline

{ return this->neighborOptions; }

getPollTimer()

cMessage* inet::ospfv3::Ospfv3Neighbor::getPollTimer ( )

inline

{ return this->pollTimer; }

Referenced by inet::ospfv3::Ospfv3NeighborStateAttempt::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateDown::processEvent(), inet::ospfv3::Ospfv3NeighborStateInit::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExStart::processEvent().

getRequestRetransmissionTimer()

cMessage* inet::ospfv3::Ospfv3Neighbor::getRequestRetransmissionTimer ( )

inline

{ return this->requestRetransmissionTimer; }

Referenced by clearRequestRetransmissionTimer(), and inet::ospfv3::Ospfv3NeighborStateLoading::processEvent().

getState()

Ospfv3Neighbor::Ospfv3NeighborStateType inet::ospfv3::Ospfv3Neighbor::getState

(

)

const

{
    return state->getState();
}

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Instance::detailedInfo(), inet::ospfv3::Ospfv3Area::originateRouterLSA(), inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3Interface::processHelloPacket(), inet::ospfv3::Ospfv3Interface::processLSAck(), inet::ospfv3::Ospfv3Interface::processLSR(), inet::ospfv3::Ospfv3Interface::processLSU(), and removeFromRequestList().

getUniqueULong()

unsigned long inet::ospfv3::Ospfv3Neighbor::getUniqueULong

(

)

{
    return ddSequenceNumberInitSeed++;
}

Referenced by initFirstAdjacency().

getUpdateRetransmissionTimer()

cMessage* inet::ospfv3::Ospfv3Neighbor::getUpdateRetransmissionTimer ( )

inline

{ return this->updateRetransmissionTimer; }

Referenced by clearUpdateRetransmissionTimer(), and startUpdateRetransmissionTimer().

incrementDDSequenceNumber()

void inet::ospfv3::Ospfv3Neighbor::incrementDDSequenceNumber ( )

inline

{ this->ddSequenceNumber++; }

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), and inet::ospfv3::Ospfv3NeighborStateInit::processEvent().

initFirstAdjacency()

void inet::ospfv3::Ospfv3Neighbor::initFirstAdjacency

(

)

{
    ddSequenceNumber = getUniqueULong();
    firstAdjacencyInited = true;
}

Referenced by inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), and inet::ospfv3::Ospfv3NeighborStateInit::processEvent().

isFirstAdjacencyInited()

bool inet::ospfv3::Ospfv3Neighbor::isFirstAdjacencyInited ( ) const

inline

{ return this->firstAdjacencyInited; }

Referenced by inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), and inet::ospfv3::Ospfv3NeighborStateInit::processEvent().

isLinkStateRequestListEmpty() [1/2]

bool inet::ospfv3::Ospfv3Neighbor::isLinkStateRequestListEmpty ( )

inline

{ return this->linkStateRequestList.empty(); }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), and inet::ospfv3::Ospfv3Interface::processLSU().

isLinkStateRequestListEmpty() [2/2]

bool inet::ospfv3::Ospfv3Neighbor::isLinkStateRequestListEmpty

(

LSAKeyType

lsaKey

)

const

{
    for (auto lsa : linkStateRetransmissionList) {
        if ((lsa->getHeader().getLinkStateID() == lsaKey.linkStateID) &&
            (lsa->getHeader().getAdvertisingRouter() == lsaKey.advertisingRouter))
        {
            return true;
        }
    }
    return false;
}

isLSAOnRequestList()

bool inet::ospfv3::Ospfv3Neighbor::isLSAOnRequestList

(

LSAKeyType

lsaKey

)

{
    if (findOnRequestList(lsaKey) == nullptr)
        return false;
 
    return true;
}

isOnTransmittedLSAList()

bool inet::ospfv3::Ospfv3Neighbor::isOnTransmittedLSAList

(

LSAKeyType

lsaKey

)

const

{
    for (std::list<TransmittedLSA>::const_iterator it = transmittedLSAs.begin(); it != transmittedLSAs.end(); it++) {
        if ((it->lsaKey.linkStateID == lsaKey.linkStateID) &&
            (it->lsaKey.advertisingRouter == lsaKey.advertisingRouter))
        {
            return true;
        }
    }
    return false;
} // isOnTransmittedLSAList

isRequestRetransmissionTimerActive()

bool inet::ospfv3::Ospfv3Neighbor::isRequestRetransmissionTimerActive ( )

inline

{ return this->requestRetransmissionTimerActive; }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket().

isRetransmissionListEmpty()

bool inet::ospfv3::Ospfv3Neighbor::isRetransmissionListEmpty ( ) const

inline

{ return linkStateRetransmissionList.empty(); }

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), and inet::ospfv3::Ospfv3Interface::processLSAck().

isUpdateRetransmissionTimerActive()

bool inet::ospfv3::Ospfv3Neighbor::isUpdateRetransmissionTimerActive ( ) const

inline

{ return this->updateRetransmissionTimerActive; }

Referenced by inet::ospfv3::Ospfv3Interface::floodLSA(), and inet::ospfv3::Ospfv3NeighborStateFull::processEvent().

needAdjacency()

bool inet::ospfv3::Ospfv3Neighbor::needAdjacency

(

)

{
    Ospfv3Interface::Ospfv3InterfaceType interfaceType = this->getInterface()->getType();
    Ipv4Address routerID = this->getInterface()->getArea()->getInstance()->getProcess()->getRouterID();
    Ipv4Address dRouter = this->getInterface()->getDesignatedID();
    Ipv4Address backupDRouter = this->getInterface()->getBackupID();
 
    if ((interfaceType == Ospfv3Interface::POINTTOPOINT_TYPE) ||
        (interfaceType == Ospfv3Interface::POINTTOMULTIPOINT_TYPE) ||
        (interfaceType == Ospfv3Interface::VIRTUAL_TYPE) ||
        (dRouter == routerID) ||
        (backupDRouter == routerID) ||
        (!designatedRoutersSetUp &&
         neighborsDesignatedRouter == NULL_IPV4ADDRESS) ||
        (this->getNeighborID() == dRouter) ||
        (this->getNeighborID() == backupDRouter))
    {
        EV_DEBUG << "I need an adjacency with router " << this->getNeighborID() << "\n";
        return true;
    }
    else {
        return false;
    }
}

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), and inet::ospfv3::Ospfv3NeighborStateInit::processEvent().

processEvent()

void inet::ospfv3::Ospfv3Neighbor::processEvent

(

Ospfv3Neighbor::Ospfv3NeighborEventType

event

)

{
    EV_DEBUG << "Passing event number " << event << " to state\n";
    this->state->processEvent(this, event);
}

Referenced by inet::ospfv3::Ospfv3InterfaceState::calculateDesignatedRouter(), inet::ospfv3::Ospfv3Process::handleTimer(), inet::ospfv3::Ospfv3Interface::preProcessDDPacket(), inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3InterfaceStateDown::processEvent(), inet::ospfv3::Ospfv3Interface::processHelloPacket(), inet::ospfv3::Ospfv3Interface::processLSR(), and removeFromRequestList().

removeFromRequestList()

void inet::ospfv3::Ospfv3Neighbor::removeFromRequestList

(

LSAKeyType

lsaKey

)

{
    auto it = linkStateRequestList.begin();
    while (it != linkStateRequestList.end()) {
        if (((*it)->getLinkStateID() == lsaKey.linkStateID) &&
            ((*it)->getAdvertisingRouter() == lsaKey.advertisingRouter))
        {
            delete *it;
            it = linkStateRequestList.erase(it);
        }
        else {
            it++;
        }
    }
    if ((getState() == Ospfv3Neighbor::LOADING_STATE) && (linkStateRequestList.empty())) {
        clearRequestRetransmissionTimer();
        processEvent(Ospfv3Neighbor::LOADING_DONE);
    }
} // removeFromRequestList

Referenced by inet::ospfv3::Ospfv3Interface::processLSU().

removeFromRetransmissionList()

void inet::ospfv3::Ospfv3Neighbor::removeFromRetransmissionList

(

LSAKeyType

lsaKey

)

{
    auto it = linkStateRetransmissionList.begin();
    int counter = 0;
    while (it != linkStateRetransmissionList.end()) {
 
        EV_DEBUG << counter++ << " - HEADER in retransmition list:\n" << (*it)->getHeader() << "\n";
        if (((*it)->getHeader().getLinkStateID() == lsaKey.linkStateID) &&
            ((*it)->getHeader().getAdvertisingRouter() == lsaKey.advertisingRouter))
        {
            delete *it;
            it = linkStateRetransmissionList.erase(it);
        }
        else {
            it++;
        }
    }
} // removeFromRetransmissionList

Referenced by inet::ospfv3::Ospfv3Interface::processLSAck(), and inet::ospfv3::Ospfv3Interface::processLSU().

reset()

void inet::ospfv3::Ospfv3Neighbor::reset

(

)

{
    EV_DEBUG << "Reseting the neighbor " << this->getNeighborID() << "\n";
    for (auto retIt = linkStateRetransmissionList.begin();
         retIt != linkStateRetransmissionList.end();
         retIt++)
    {
        delete *retIt;
    }
    linkStateRetransmissionList.clear();
 
    for (auto it = databaseSummaryList.begin(); it != databaseSummaryList.end(); it++) {
        delete *it;
    }
    databaseSummaryList.clear();
    for (auto it = linkStateRequestList.begin(); it != linkStateRequestList.end(); it++) {
        delete *it;
    }
    linkStateRequestList.clear();
 
    this->getInterface()->getArea()->getInstance()->getProcess()->clearTimer(ddRetransmissionTimer);
    clearUpdateRetransmissionTimer();
    clearRequestRetransmissionTimer();
 
    if (lastTransmittedDDPacket != nullptr) {
        delete lastTransmittedDDPacket;
        lastTransmittedDDPacket = nullptr;
    }
}

Referenced by inet::ospfv3::Ospfv3NeighborStateAttempt::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateInit::processEvent(), inet::ospfv3::Ospfv3NeighborStateExStart::processEvent(), and ~Ospfv3Neighbor().

retransmitDatabaseDescriptionPacket()

bool inet::ospfv3::Ospfv3Neighbor::retransmitDatabaseDescriptionPacket

(

)

{
    EV_DEBUG << "Retransmitting DD Packet\n";
    if (lastTransmittedDDPacket != nullptr) {
        Packet *ddPacket = new Packet(*lastTransmittedDDPacket);
        this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(ddPacket, this->getNeighborIP(), this->getInterface()->getIntName().c_str());
        return true;
    }
    else {
        EV_DEBUG << "But no packet is in the line\n";
        return false;
    }
}

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket(), and inet::ospfv3::Ospfv3NeighborStateExStart::processEvent().

retransmitUpdatePacket()

void inet::ospfv3::Ospfv3Neighbor::retransmitUpdatePacket

(

)

{
    EV_DEBUG << "Retransmitting update packet\n";
    const auto& updatePacket = makeShared<Ospfv3LinkStateUpdatePacket>();
 
    updatePacket->setType(ospf::LINKSTATE_UPDATE_PACKET);
    updatePacket->setRouterID(this->getInterface()->getArea()->getInstance()->getProcess()->getRouterID());
    updatePacket->setAreaID(this->getInterface()->getArea()->getAreaID());
    updatePacket->setInstanceID(this->getInterface()->getArea()->getInstance()->getInstanceID());
 
    bool packetFull = false;
    unsigned short lsaCount = 0;
    B packetLength = OSPFV3_HEADER_LENGTH + OSPFV3_LSA_HEADER_LENGTH;
    auto it = linkStateRetransmissionList.begin();
 
    while (!packetFull && (it != linkStateRetransmissionList.end())) {
        uint16_t lsaType = (*it)->getHeader().getLsaType();
        const Ospfv3RouterLsa *routerLSA = (lsaType == ROUTER_LSA) ? dynamic_cast<Ospfv3RouterLsa *>(*it) : nullptr;
        const Ospfv3NetworkLsa *networkLSA = (lsaType == NETWORK_LSA) ? dynamic_cast<Ospfv3NetworkLsa *>(*it) : nullptr;
        const Ospfv3LinkLsa *linkLSA = (lsaType == LINK_LSA) ? dynamic_cast<Ospfv3LinkLsa *>(*it) : nullptr;
        const Ospfv3InterAreaPrefixLsa *interAreaPrefixLSA = (lsaType == INTER_AREA_PREFIX_LSA) ? dynamic_cast<Ospfv3InterAreaPrefixLsa *>(*it) : nullptr;
        const Ospfv3IntraAreaPrefixLsa *intraAreaPrefixLSA = (lsaType == INTRA_AREA_PREFIX_LSA) ? dynamic_cast<Ospfv3IntraAreaPrefixLsa *>(*it) : nullptr;
//        OSPFASExternalLSA *asExternalLSA = (lsaType == AS_EXTERNAL_LSA_TYPE) ? dynamic_cast<OSPFASExternalLSA *>(*it) : nullptr;
        B lsaSize;
        bool includeLSA = false;
 
        switch (lsaType) {
            case ROUTER_LSA:
                if (routerLSA != nullptr) {
                    lsaSize = calculateLSASize(routerLSA);
                }
                break;
 
            case NETWORK_LSA:
                if (networkLSA != nullptr) {
                    lsaSize = calculateLSASize(networkLSA);
                }
                break;
            case INTER_AREA_PREFIX_LSA:
                if (interAreaPrefixLSA != nullptr) {
                    lsaSize = calculateLSASize(interAreaPrefixLSA);
                }
                break;
//            case AS_EXTERNAL_LSA_TYPE:
//                if (asExternalLSA != nullptr) {
//                    lsaSize = calculateLSASize(asExternalLSA);
//                }
//                break;
//
//            default:
//                break;
            case LINK_LSA:
                if (linkLSA != nullptr)
                    lsaSize = calculateLSASize(linkLSA);
                break;
            case INTRA_AREA_PREFIX_LSA:
                if (intraAreaPrefixLSA != nullptr) {
                    lsaSize = calculateLSASize(intraAreaPrefixLSA);
                }
                break;
        }
 
        if (B(packetLength + lsaSize).get() < this->getInterface()->getInterfaceMTU()) {
            includeLSA = true;
            lsaCount++;
        }
        else {
            if ((lsaCount == 0) && (packetLength + lsaSize < IPV6_DATAGRAM_LENGTH)) {
                includeLSA = true;
                lsaCount++;
                packetFull = true;
            }
        }
 
        if (includeLSA) {
            packetLength += lsaSize;
            switch (lsaType) {
                case ROUTER_LSA:
                    if (routerLSA != nullptr) {
                        unsigned int routerLSACount = updatePacket->getRouterLSAsArraySize();
 
                        updatePacket->setRouterLSAsArraySize(routerLSACount + 1);
                        updatePacket->setRouterLSAs(routerLSACount, *routerLSA);
 
                        unsigned short lsAge = updatePacket->getRouterLSAs(routerLSACount).getHeader().getLsaAge();
                        if (lsAge < MAX_AGE - this->getInterface()->getTransDelayInterval()) {
                            updatePacket->getRouterLSAsForUpdate(routerLSACount).getHeaderForUpdate().setLsaAge(lsAge + this->getInterface()->getTransDelayInterval());
                        }
                        else {
                            updatePacket->getRouterLSAsForUpdate(routerLSACount).getHeaderForUpdate().setLsaAge(MAX_AGE);
                        }
                    }
                    break;
 
                case NETWORK_LSA:
                    if (networkLSA != nullptr) {
                        unsigned int networkLSACount = updatePacket->getNetworkLSAsArraySize();
 
                        updatePacket->setNetworkLSAsArraySize(networkLSACount + 1);
                        updatePacket->setNetworkLSAs(networkLSACount, *networkLSA);
 
                        unsigned short lsAge = updatePacket->getNetworkLSAs(networkLSACount).getHeader().getLsaAge();
                        if (lsAge < MAX_AGE - this->getInterface()->getTransDelayInterval()) {
                            updatePacket->getNetworkLSAsForUpdate(networkLSACount).getHeaderForUpdate().setLsaAge(lsAge + this->getInterface()->getTransDelayInterval());
                        }
                        else {
                            updatePacket->getNetworkLSAsForUpdate(networkLSACount).getHeaderForUpdate().setLsaAge(MAX_AGE);
                        }
                    }
                    break;
                case INTER_AREA_PREFIX_LSA:
                    if (interAreaPrefixLSA != nullptr) {
                        unsigned int interAreaPrefixLSACount = updatePacket->getInterAreaPrefixLSAsArraySize();
 
                        updatePacket->setInterAreaPrefixLSAsArraySize(interAreaPrefixLSACount + 1);
                        updatePacket->setInterAreaPrefixLSAs(interAreaPrefixLSACount, *interAreaPrefixLSA);
 
                        unsigned short lsAge = updatePacket->getInterAreaPrefixLSAs(interAreaPrefixLSACount).getHeader().getLsaAge();
                        if (lsAge < MAX_AGE - this->getInterface()->getTransDelayInterval()) {
                            updatePacket->getInterAreaPrefixLSAsForUpdate(interAreaPrefixLSACount).getHeaderForUpdate().setLsaAge(lsAge + this->getInterface()->getTransDelayInterval());
                        }
                        else {
                            updatePacket->getInterAreaPrefixLSAsForUpdate(interAreaPrefixLSACount).getHeaderForUpdate().setLsaAge(MAX_AGE);
                        }
                    }
                    break;
//                case AS_EXTERNAL_LSA_TYPE:
//                    if (asExternalLSA != nullptr) {
//                        unsigned int asExternalLSACount = updatePacket->getAsExternalLSAsArraySize();
//
//                        updatePacket->setAsExternalLSAsArraySize(asExternalLSACount + 1);
//                        updatePacket->setAsExternalLSAs(asExternalLSACount, *asExternalLSA);
//
//                        unsigned short lsAge = updatePacket->getAsExternalLSAs(asExternalLSACount).getHeader().getLsAge();
//                        if (lsAge < MAX_AGE - parentInterface->getTransmissionDelay()) {
//                            updatePacket->getAsExternalLSAs(asExternalLSACount).getHeader().setLsAge(lsAge + parentInterface->getTransmissionDelay());
//                        }
//                        else {
//                            updatePacket->getAsExternalLSAs(asExternalLSACount).getHeader().setLsAge(MAX_AGE);
//                        }
//                    }
//                    break;
                case LINK_LSA:
                    if (linkLSA != nullptr) {
                        unsigned int linkLSACount = updatePacket->getLinkLSAsArraySize();
 
                        updatePacket->setLinkLSAsArraySize(linkLSACount + 1);
                        updatePacket->setLinkLSAs(linkLSACount, *linkLSA);
 
                        unsigned short lsAge = updatePacket->getLinkLSAs(linkLSACount).getHeader().getLsaAge();
                        if (lsAge < MAX_AGE - this->getInterface()->getTransDelayInterval()) {
                            updatePacket->getLinkLSAsForUpdate(linkLSACount).getHeaderForUpdate().setLsaAge(lsAge + this->getInterface()->getTransDelayInterval());
                        }
                        else {
                            updatePacket->getLinkLSAsForUpdate(linkLSACount).getHeaderForUpdate().setLsaAge(MAX_AGE);
                        }
                    }
                    break;
                case INTRA_AREA_PREFIX_LSA:
                    if (intraAreaPrefixLSA != nullptr) {
                        unsigned int intraAreaPrefixLSACount = updatePacket->getIntraAreaPrefixLSAsArraySize();
 
                        updatePacket->setIntraAreaPrefixLSAsArraySize(intraAreaPrefixLSACount + 1);
                        updatePacket->setIntraAreaPrefixLSAs(intraAreaPrefixLSACount, *intraAreaPrefixLSA);
 
                        unsigned short lsAge = updatePacket->getIntraAreaPrefixLSAs(intraAreaPrefixLSACount).getHeader().getLsaAge();
                        if (lsAge < MAX_AGE - this->getInterface()->getTransDelayInterval()) {
                            updatePacket->getIntraAreaPrefixLSAsForUpdate(intraAreaPrefixLSACount).getHeaderForUpdate().setLsaAge(lsAge + this->getInterface()->getTransDelayInterval());
                        }
                        else {
                            updatePacket->getIntraAreaPrefixLSAsForUpdate(intraAreaPrefixLSACount).getHeaderForUpdate().setLsaAge(MAX_AGE);
                        }
                    }
                    break;
                default:
                    break;
            }
        }
 
        it++;
    }
 
    EV_DEBUG << "Retransmit - packet length: " << packetLength << "\n";
    updatePacket->setChunkLength(B(packetLength)); // IPV6 HEADER BYTES
    Packet *pk = new Packet();
    pk->insertAtBack(updatePacket);
 
    this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(pk, this->getNeighborIP(), this->getInterface()->getIntName().c_str());
    // TODO
//    int ttl = (parentInterface->getType() == Interface::VIRTUAL) ? VIRTUAL_LINK_TTL : 1;
//    messageHandler->sendPacket(updatePacket, neighborIPAddress, parentInterface->getIfIndex(), ttl);
}

Referenced by inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExchange::processEvent().

sendDDPacket()

void inet::ospfv3::Ospfv3Neighbor::sendDDPacket

(

bool

init = false

)

&& (packetSize <= (maxPacketSize - OSPF_LSA_HEADER_LENGTH))) {

{
    EV_DEBUG << "Start of function send DD Packet\n";
    const auto& ddPacket = makeShared<Ospfv3DatabaseDescriptionPacket>();
 
    // common header first
    ddPacket->setType(ospf::DATABASE_DESCRIPTION_PACKET);
    ddPacket->setRouterID(this->getInterface()->getArea()->getInstance()->getProcess()->getRouterID());
    ddPacket->setAreaID(this->getInterface()->getArea()->getAreaID());
    ddPacket->setInstanceID(this->getInterface()->getArea()->getInstance()->getInstanceID());
 
    // DD packet next
    Ospfv3Options options;
    options.eBit = this->getInterface()->getArea()->getExternalRoutingCapability();
    ddPacket->setOptions(options);
    ddPacket->setInterfaceMTU(this->getInterface()->getInterfaceMTU());
    Ospfv3DdOptions ddOptions;
    ddPacket->setSequenceNumber(this->ddSequenceNumber);
 
    B packetSize = OSPFV3_HEADER_LENGTH + OSPFV3_DD_HEADER_LENGTH;
 
    if (init || databaseSummaryList.empty()) {
        ddPacket->setLsaHeadersArraySize(0);
    }
    else {
        while (!this->databaseSummaryList.empty()) { 
            unsigned long headerCount = ddPacket->getLsaHeadersArraySize();
            Ospfv3LsaHeader *lsaHeader = *(databaseSummaryList.begin());
            ddPacket->setLsaHeadersArraySize(headerCount + 1);
            ddPacket->setLsaHeaders(headerCount, *lsaHeader);
            delete lsaHeader;
            databaseSummaryList.pop_front();
            packetSize += OSPFV3_LSA_HEADER_LENGTH;
        }
    }
 
    EV_DEBUG << "DatabaseSummatyListCount = " << this->getDatabaseSummaryListCount() << endl;
    if (init) {
        ddOptions.iBit = true;
        ddOptions.mBit = true;
        ddOptions.msBit = true;
    }
    else {
        ddOptions.iBit = false;
        ddOptions.mBit = (databaseSummaryList.empty()) ? false : true;
        ddOptions.msBit = (databaseExchangeRelationship == Ospfv3Neighbor::MASTER) ? true : false;
    }
 
    ddPacket->setDdOptions(ddOptions);
 
    ddPacket->setPacketLengthField(packetSize.get());
    ddPacket->setChunkLength(packetSize);
    Packet *pk = new Packet();
    pk->insertAtBack(ddPacket);
 
    // TODO - ddPacket does not include Virtual Links and HopLimit. Also Checksum is not calculated
    if (this->getInterface()->getType() == Ospfv3Interface::POINTTOPOINT_TYPE) {
        EV_DEBUG << "(P2P link ) Send DD Packet to OSPF MCAST\n";
        this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(pk, Ipv6Address::ALL_OSPF_ROUTERS_MCAST, this->getInterface()->getIntName().c_str());
    }
    else {
        EV_DEBUG << "Send DD Packet to " << this->getNeighborIP() << "\n";
        this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(pk, this->getNeighborIP(), this->getInterface()->getIntName().c_str());
    }
}

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket(), inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), inet::ospfv3::Ospfv3NeighborStateExchange::processEvent(), inet::ospfv3::Ospfv3NeighborState2Way::processEvent(), inet::ospfv3::Ospfv3NeighborStateInit::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExStart::processEvent().

sendLinkStateRequestPacket()

void inet::ospfv3::Ospfv3Neighbor::sendLinkStateRequestPacket

(

)

{
    const auto& requestPacket = makeShared<Ospfv3LinkStateRequestPacket>();
    requestPacket->setType(ospf::LINKSTATE_REQUEST_PACKET);
    requestPacket->setRouterID(this->getInterface()->getArea()->getInstance()->getProcess()->getRouterID());
    requestPacket->setAreaID(this->getInterface()->getArea()->getAreaID());
    requestPacket->setInstanceID(this->getInterface()->getArea()->getInstance()->getInstanceID());
 
//    long maxPacketSize = (((IP_MAX_HEADER_BYTES + OSPF_HEADER_LENGTH + OSPF_REQUEST_LENGTH) > parentInterface->getMTU()) ?
//                          IPV4_DATAGRAM_LENGTH :
//                          parentInterface->getMTU()) - IP_MAX_HEADER_BYTES;
    B packetSize = OSPFV3_HEADER_LENGTH;
 
    if (linkStateRequestList.empty()) {
        requestPacket->setRequestsArraySize(0);
    }
    else {
        auto it = linkStateRequestList.begin();
 
        while (it != linkStateRequestList.end()) { // TODO - maxpacketsize
            unsigned long requestCount = requestPacket->getRequestsArraySize();
            Ospfv3LsaHeader *requestHeader = (*it);
            Ospfv3LsRequest request;
 
            request.lsaType = requestHeader->getLsaType();
            request.lsaID = requestHeader->getLinkStateID();
            request.advertisingRouter = requestHeader->getAdvertisingRouter();
 
            requestPacket->setRequestsArraySize(requestCount + 1);
            requestPacket->setRequests(requestCount, request);
 
            packetSize += OSPFV3_LSR_LENGTH;
            it++;
        }
    }
 
    requestPacket->setChunkLength(packetSize);
    // TODO - TTL and Checksum calculation  for LS Request is not implemented yet
 
    Packet *pk = new Packet();
    pk->insertAtBack(requestPacket);
    if (this->getInterface()->getType() == Ospfv3Interface::POINTTOPOINT_TYPE) {
        this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(pk, Ipv6Address::ALL_OSPF_ROUTERS_MCAST, this->getInterface()->getIntName().c_str());
    }
    else {
        this->getInterface()->getArea()->getInstance()->getProcess()->sendPacket(pk, this->getNeighborIP(), this->getInterface()->getIntName().c_str());
    }
}

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExchange::processEvent().

setBackupDesignatedRouterID()

void inet::ospfv3::Ospfv3Neighbor::setBackupDesignatedRouterID ( Ipv4Address  newId )

inline

{ this->neighborsBackupDesignatedRouter = newId; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setDatabaseExchangeRelationship()

void inet::ospfv3::Ospfv3Neighbor::setDatabaseExchangeRelationship ( Ospfv3DatabaseExchangeRelationshipType  newRelationship )

inline

{ this->databaseExchangeRelationship = newRelationship; }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket().

setDDSequenceNumber()

void inet::ospfv3::Ospfv3Neighbor::setDDSequenceNumber ( unsigned long  newSequenceNmr )

inline

{ this->ddSequenceNumber = newSequenceNmr; }

Referenced by inet::ospfv3::Ospfv3Interface::preProcessDDPacket().

setDesignatedRouterID()

void inet::ospfv3::Ospfv3Neighbor::setDesignatedRouterID ( Ipv4Address  newId )

inline

{ this->neighborsDesignatedRouter = newId; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setLastHelloTime()

void inet::ospfv3::Ospfv3Neighbor::setLastHelloTime ( int  time )

inline

{ this->last_hello_received = time; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setLastReceivedDDPacket()

void inet::ospfv3::Ospfv3Neighbor::setLastReceivedDDPacket ( Ospfv3DdPacketId  packetID )

inline

{ lastReceivedDDPacket = packetID; }

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket().

setNeighborAddress()

void inet::ospfv3::Ospfv3Neighbor::setNeighborAddress ( Ipv6Address  newAddress )

inline

{ this->neighborIPAddress = newAddress; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setNeighborDeadInterval()

void inet::ospfv3::Ospfv3Neighbor::setNeighborDeadInterval ( int  newInterval )

inline

{ this->neighborsRouterDeadInterval = newInterval; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setNeighborID()

void inet::ospfv3::Ospfv3Neighbor::setNeighborID ( Ipv4Address  newId )

inline

{ this->neighborId = newId; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setNeighborInterfaceID()

void inet::ospfv3::Ospfv3Neighbor::setNeighborInterfaceID ( uint32_t  newID )

inline

{ this->neighborInterfaceID = newID; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setNeighborPriority()

void inet::ospfv3::Ospfv3Neighbor::setNeighborPriority ( int  newPriority )

inline

{ this->neighborRtrPriority = newPriority; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

setOptions()

void inet::ospfv3::Ospfv3Neighbor::setOptions ( Ospfv3Options  options )

inline

{ this->neighborOptions = options; }

setupDesignatedRouters()

void inet::ospfv3::Ospfv3Neighbor::setupDesignatedRouters ( bool  setUp )

inline

{ this->designatedRoutersSetUp = setUp; }

Referenced by inet::ospfv3::Ospfv3Interface::processHelloPacket().

startRequestRetransmissionTimer()

void inet::ospfv3::Ospfv3Neighbor::startRequestRetransmissionTimer

(

)

{
    this->getInterface()->getArea()->getInstance()->getProcess()->setTimer(this->requestRetransmissionTimer, this->getInterface()->getRetransmissionInterval());
    this->requestRetransmissionTimerActive = true;
}

Referenced by inet::ospfv3::Ospfv3Interface::processDDPacket(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExchange::processEvent().

startUpdateRetransmissionTimer()

void inet::ospfv3::Ospfv3Neighbor::startUpdateRetransmissionTimer

(

)

{
    this->getInterface()->getArea()->getInstance()->getProcess()->setTimer(this->getUpdateRetransmissionTimer(), this->getInterface()->getRetransmissionInterval());
    this->updateRetransmissionTimerActive = true;
    EV_DEBUG << "Starting UPDATE TIMER\n";
}

Referenced by inet::ospfv3::Ospfv3Interface::floodLSA(), inet::ospfv3::Ospfv3NeighborStateLoading::processEvent(), inet::ospfv3::Ospfv3NeighborStateFull::processEvent(), and inet::ospfv3::Ospfv3NeighborStateExchange::processEvent().

Member Data Documentation

containingInterface

Ospfv3Interface* inet::ospfv3::Ospfv3Neighbor::containingInterface = nullptr

private

Referenced by getInterface(), and Ospfv3Neighbor().

databaseExchangeRelationship

Ospfv3DatabaseExchangeRelationshipType inet::ospfv3::Ospfv3Neighbor::databaseExchangeRelationship = static_cast<Ospfv3DatabaseExchangeRelationshipType>(-1)

private

Referenced by getDatabaseExchangeRelationship(), sendDDPacket(), and setDatabaseExchangeRelationship().

databaseSummaryList

std::list<Ospfv3LsaHeader *> inet::ospfv3::Ospfv3Neighbor::databaseSummaryList

private

Referenced by createDatabaseSummary(), getDatabaseSummaryListCount(), reset(), and sendDDPacket().

ddRetransmissionTimer

cMessage* inet::ospfv3::Ospfv3Neighbor::ddRetransmissionTimer = nullptr

private

Referenced by getDDRetransmissionTimer(), Ospfv3Neighbor(), reset(), and ~Ospfv3Neighbor().

ddSequenceNumber

unsigned long inet::ospfv3::Ospfv3Neighbor::ddSequenceNumber

private

Referenced by getDDSequenceNumber(), incrementDDSequenceNumber(), initFirstAdjacency(), sendDDPacket(), and setDDSequenceNumber().

ddSequenceNumberInitSeed

unsigned long inet::ospfv3::Ospfv3Neighbor::ddSequenceNumberInitSeed = 0

staticprivate

Referenced by getUniqueULong().

designatedRoutersSetUp

bool inet::ospfv3::Ospfv3Neighbor::designatedRoutersSetUp = false

private

Referenced by designatedRoutersAreSetUp(), needAdjacency(), and setupDesignatedRouters().

firstAdjacencyInited

bool inet::ospfv3::Ospfv3Neighbor::firstAdjacencyInited = false

private

Referenced by initFirstAdjacency(), and isFirstAdjacencyInited().

inactivityTimer

cMessage* inet::ospfv3::Ospfv3Neighbor::inactivityTimer = nullptr

private

Referenced by getInactivityTimer(), Ospfv3Neighbor(), and ~Ospfv3Neighbor().

last_hello_received

int inet::ospfv3::Ospfv3Neighbor::last_hello_received = 0

private

Referenced by getLastHelloTime(), and setLastHelloTime().

lastReceivedDDPacket

Ospfv3DdPacketId inet::ospfv3::Ospfv3Neighbor::lastReceivedDDPacket

private

Referenced by getLastReceivedDDPacket(), and setLastReceivedDDPacket().

lastTransmittedDDPacket

Packet* inet::ospfv3::Ospfv3Neighbor::lastTransmittedDDPacket = nullptr

private

Referenced by deleteLastSentDDPacket(), reset(), and retransmitDatabaseDescriptionPacket().

linkStateRequestList

std::list<Ospfv3LsaHeader *> inet::ospfv3::Ospfv3Neighbor::linkStateRequestList

private

Referenced by addToRequestList(), findOnRequestList(), isLinkStateRequestListEmpty(), removeFromRequestList(), reset(), and sendLinkStateRequestPacket().

linkStateRetransmissionList

std::list<Ospfv3Lsa *> inet::ospfv3::Ospfv3Neighbor::linkStateRetransmissionList

private

Referenced by addToRetransmissionList(), findOnRetransmissionList(), isLinkStateRequestListEmpty(), isRetransmissionListEmpty(), removeFromRetransmissionList(), reset(), and retransmitUpdatePacket().

neighborId

Ipv4Address inet::ospfv3::Ospfv3Neighbor::neighborId

private

Referenced by getNeighborID(), Ospfv3Neighbor(), and setNeighborID().

neighborInterfaceID

uint32_t inet::ospfv3::Ospfv3Neighbor::neighborInterfaceID

private

Referenced by getNeighborInterfaceID(), and setNeighborInterfaceID().

neighborIPAddress

Ipv6Address inet::ospfv3::Ospfv3Neighbor::neighborIPAddress

private

Referenced by getNeighborIP(), Ospfv3Neighbor(), and setNeighborAddress().

neighborOptions

Ospfv3Options inet::ospfv3::Ospfv3Neighbor::neighborOptions

private

Referenced by getOptions(), and setOptions().

neighborRtrPriority

unsigned short inet::ospfv3::Ospfv3Neighbor::neighborRtrPriority

private

Referenced by getNeighborPriority(), and setNeighborPriority().

neighborsBackupDesignatedRouter

Ipv4Address inet::ospfv3::Ospfv3Neighbor::neighborsBackupDesignatedRouter

private

Referenced by getNeighborsBackup(), Ospfv3Neighbor(), and setBackupDesignatedRouterID().

neighborsBackupIP

L3Address inet::ospfv3::Ospfv3Neighbor::neighborsBackupIP

private

Backup advertised by the router.

Referenced by getNeighborBackupIP(), and Ospfv3Neighbor().

neighborsDesignatedIP

L3Address inet::ospfv3::Ospfv3Neighbor::neighborsDesignatedIP

private

Referenced by getNeighborDesignatedIP(), and Ospfv3Neighbor().

neighborsDesignatedRouter

Ipv4Address inet::ospfv3::Ospfv3Neighbor::neighborsDesignatedRouter

private

Referenced by getNeighborsDR(), needAdjacency(), Ospfv3Neighbor(), and setDesignatedRouterID().

neighborsRouterDeadInterval

short inet::ospfv3::Ospfv3Neighbor::neighborsRouterDeadInterval = 0

private

Referenced by getNeighborDeadInterval(), Ospfv3Neighbor(), and setNeighborDeadInterval().

pollTimer

cMessage* inet::ospfv3::Ospfv3Neighbor::pollTimer = nullptr

private

Referenced by getPollTimer(), Ospfv3Neighbor(), and ~Ospfv3Neighbor().

previousState

Ospfv3NeighborState* inet::ospfv3::Ospfv3Neighbor::previousState = nullptr

private

Referenced by changeState(), and ~Ospfv3Neighbor().

requestRetransmissionTimer

cMessage* inet::ospfv3::Ospfv3Neighbor::requestRetransmissionTimer = nullptr

private

Referenced by getRequestRetransmissionTimer(), Ospfv3Neighbor(), startRequestRetransmissionTimer(), and ~Ospfv3Neighbor().

requestRetransmissionTimerActive

bool inet::ospfv3::Ospfv3Neighbor::requestRetransmissionTimerActive = false

private

Referenced by clearRequestRetransmissionTimer(), isRequestRetransmissionTimerActive(), and startRequestRetransmissionTimer().

state

Ospfv3NeighborState* inet::ospfv3::Ospfv3Neighbor::state = nullptr

private

Referenced by changeState(), getState(), Ospfv3Neighbor(), processEvent(), and ~Ospfv3Neighbor().

transmittedLSAs

std::list<TransmittedLSA> inet::ospfv3::Ospfv3Neighbor::transmittedLSAs

private

Referenced by addToTransmittedLSAList(), ageTransmittedLSAList(), and isOnTransmittedLSAList().

updateRetransmissionTimer

cMessage* inet::ospfv3::Ospfv3Neighbor::updateRetransmissionTimer = nullptr

private

Referenced by getUpdateRetransmissionTimer(), Ospfv3Neighbor(), and ~Ospfv3Neighbor().

updateRetransmissionTimerActive

bool inet::ospfv3::Ospfv3Neighbor::updateRetransmissionTimerActive = false

private

Referenced by clearUpdateRetransmissionTimer(), isUpdateRetransmissionTimerActive(), and startUpdateRetransmissionTimer().

---

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

• Ospfv3Neighbor.h
• Ospfv3Neighbor.cc