#include <OSPFInterface.h>

Public Types
enum	InterfaceEventType { INTERFACE_UP = 0, HELLO_TIMER = 1, WAIT_TIMER = 2, ACKNOWLEDGEMENT_TIMER = 3, BACKUP_SEEN = 4, NEIGHBOR_CHANGE = 5, LOOP_INDICATION = 6, UNLOOP_INDICATION = 7, INTERFACE_DOWN = 8 }

enum	OSPFInterfaceType { UNKNOWN_TYPE = 0, POINTTOPOINT = 1, BROADCAST = 2, NBMA = 3, POINTTOMULTIPOINT = 4, VIRTUAL = 5 }

enum	InterfaceStateType { DOWN_STATE = 0, LOOPBACK_STATE = 1, WAITING_STATE = 2, POINTTOPOINT_STATE = 3, NOT_DESIGNATED_ROUTER_STATE = 4, BACKUP_STATE = 5, DESIGNATED_ROUTER_STATE = 6 }

Public Member Functions
	Interface (OSPFInterfaceType ifType=UNKNOWN_TYPE)

virtual	~Interface ()

void	processEvent (InterfaceEventType event)

void	reset ()

void	sendHelloPacket (IPv4Address destination, short ttl=1)

void	sendLSAcknowledgement (OSPFLSAHeader *lsaHeader, IPv4Address destination)

Neighbor *	getNeighborByID (RouterID neighborID)

Neighbor *	getNeighborByAddress (IPv4Address address)

void	addNeighbor (Neighbor *neighbor)

InterfaceStateType	getState () const

bool	hasAnyNeighborInStates (int states) const

void	removeFromAllRetransmissionLists (LSAKeyType lsaKey)

bool	isOnAnyRetransmissionList (LSAKeyType lsaKey) const

bool	floodLSA (OSPFLSA lsa, Interface intf=nullptr, Neighbor *neighbor=nullptr)

void	addDelayedAcknowledgement (OSPFLSAHeader &lsaHeader)

void	sendDelayedAcknowledgements ()

void	ageTransmittedLSALists ()

OSPFLinkStateUpdatePacket *	createUpdatePacket (OSPFLSA *lsa)

void	setType (OSPFInterfaceType ifType)

OSPFInterfaceType	getType () const

void	setIfIndex (IInterfaceTable *ift, int index)

int	getIfIndex () const

void	setMTU (unsigned short ifMTU)

unsigned short	getMTU () const

void	setAreaID (AreaID areaId)

AreaID	getAreaID () const

void	setTransitAreaID (AreaID areaId)

AreaID	getTransitAreaID () const

void	setOutputCost (Metric cost)

Metric	getOutputCost () const

void	setRetransmissionInterval (short interval)

short	getRetransmissionInterval () const

void	setTransmissionDelay (short delay)

short	getTransmissionDelay () const

void	setAcknowledgementDelay (short delay)

short	getAcknowledgementDelay () const

void	setRouterPriority (unsigned char priority)

unsigned char	getRouterPriority () const

void	setHelloInterval (short interval)

short	getHelloInterval () const

void	setPollInterval (short interval)

short	getPollInterval () const

void	setRouterDeadInterval (short interval)

short	getRouterDeadInterval () const

void	setAuthenticationType (AuthenticationType type)

AuthenticationType	getAuthenticationType () const

void	setAuthenticationKey (AuthenticationKeyType key)

AuthenticationKeyType	getAuthenticationKey () const

void	setAddressRange (IPv4AddressRange range)

IPv4AddressRange	getAddressRange () const

cMessage *	getHelloTimer ()

cMessage *	getWaitTimer ()

cMessage *	getAcknowledgementTimer ()

DesignatedRouterID	getDesignatedRouter () const

DesignatedRouterID	getBackupDesignatedRouter () const

unsigned long	getNeighborCount () const

Neighbor *	getNeighbor (unsigned long i)

const Neighbor *	getNeighbor (unsigned long i) const

void	setArea (Area *area)

Area *	getArea ()

const Area *	getArea () const

Static Public Member Functions
static const char *	getStateString (InterfaceStateType stateType)

Private Member Functions
void	changeState (InterfaceState newState, InterfaceState currentState)

Private Attributes
OSPFInterfaceType	interfaceType

InterfaceState *	state

InterfaceState *	previousState

int	ifIndex

unsigned short	mtu

IPv4AddressRange	interfaceAddressRange

AreaID	areaID

AreaID	transitAreaID

short	helloInterval

short	pollInterval

short	routerDeadInterval

short	interfaceTransmissionDelay

unsigned char	routerPriority

cMessage *	helloTimer

cMessage *	waitTimer

cMessage *	acknowledgementTimer

std::map< RouterID, Neighbor * >	neighboringRoutersByID

std::map< IPv4Address, Neighbor * >	neighboringRoutersByAddress

std::vector< Neighbor * >	neighboringRouters

std::map< IPv4Address, std::list< OSPFLSAHeader > >	delayedAcknowledgements

DesignatedRouterID	designatedRouter

DesignatedRouterID	backupDesignatedRouter

Metric	interfaceOutputCost

short	retransmissionInterval

short	acknowledgementDelay

AuthenticationType	authenticationType

AuthenticationKeyType	authenticationKey

Area *	parentArea

Friends
class	InterfaceState

Member Enumeration Documentation

enum inet::ospf::Interface::InterfaceEventType

Enumerator
INTERFACE_UP
HELLO_TIMER
WAIT_TIMER
ACKNOWLEDGEMENT_TIMER
BACKUP_SEEN
NEIGHBOR_CHANGE
LOOP_INDICATION
UNLOOP_INDICATION
INTERFACE_DOWN

                             {
         INTERFACE_UP = 0,
         HELLO_TIMER = 1,
         WAIT_TIMER = 2,
         ACKNOWLEDGEMENT_TIMER = 3,
         BACKUP_SEEN = 4,
         NEIGHBOR_CHANGE = 5,
         LOOP_INDICATION = 6,
         UNLOOP_INDICATION = 7,
         INTERFACE_DOWN = 8
     };

enum inet::ospf::Interface::InterfaceStateType

Enumerator
DOWN_STATE
LOOPBACK_STATE
WAITING_STATE
POINTTOPOINT_STATE
NOT_DESIGNATED_ROUTER_STATE
BACKUP_STATE
DESIGNATED_ROUTER_STATE

                             {
         DOWN_STATE = 0,
         LOOPBACK_STATE = 1,
         WAITING_STATE = 2,
         POINTTOPOINT_STATE = 3,
         NOT_DESIGNATED_ROUTER_STATE = 4,
         BACKUP_STATE = 5,
         DESIGNATED_ROUTER_STATE = 6
     };

enum inet::ospf::Interface::OSPFInterfaceType

Enumerator
UNKNOWN_TYPE
POINTTOPOINT
BROADCAST
NBMA
POINTTOMULTIPOINT
VIRTUAL

                            {
         UNKNOWN_TYPE = 0,
         POINTTOPOINT = 1,
         BROADCAST = 2,
         NBMA = 3,
         POINTTOMULTIPOINT = 4,
         VIRTUAL = 5
     };

Constructor & Destructor Documentation

inet::ospf::Interface::Interface ( Interface::OSPFInterfaceType ifType = UNKNOWN_TYPE )

                                                       :
     interfaceType(ifType),
     ifIndex(0),
     mtu(0),
     interfaceAddressRange(NULL_IPV4ADDRESSRANGE),
     areaID(BACKBONE_AREAID),
     transitAreaID(BACKBONE_AREAID),
     helloInterval(10),
     pollInterval(120),
     routerDeadInterval(40),
     interfaceTransmissionDelay(1),
     routerPriority(0),
     designatedRouter(NULL_DESIGNATEDROUTERID),
     backupDesignatedRouter(NULL_DESIGNATEDROUTERID),
     interfaceOutputCost(1),
     retransmissionInterval(5),
     acknowledgementDelay(1),
     authenticationType(NULL_TYPE),
     parentArea(nullptr)
 {
     state = new InterfaceStateDown;
     previousState = nullptr;
     helloTimer = new cMessage();
     helloTimer->setKind(INTERFACE_HELLO_TIMER);
     helloTimer->setContextPointer(this);
     helloTimer->setName("Interface::InterfaceHelloTimer");
     waitTimer = new cMessage();
     waitTimer->setKind(INTERFACE_WAIT_TIMER);
     waitTimer->setContextPointer(this);
     waitTimer->setName("Interface::InterfaceWaitTimer");
     acknowledgementTimer = new cMessage();
     acknowledgementTimer->setKind(INTERFACE_ACKNOWLEDGEMENT_TIMER);
     acknowledgementTimer->setContextPointer(this);
     acknowledgementTimer->setName("Interface::InterfaceAcknowledgementTimer");
     memset(authenticationKey.bytes, 0, 8 * sizeof(char));
 }

inet::ospf::Interface::~Interface ( )

virtual

 {
     MessageHandler *messageHandler = parentArea->getRouter()->getMessageHandler();
     messageHandler->clearTimer(helloTimer);
     delete helloTimer;
     messageHandler->clearTimer(waitTimer);
     delete waitTimer;
     messageHandler->clearTimer(acknowledgementTimer);
     delete acknowledgementTimer;
     if (previousState != nullptr) {
         delete previousState;
     }
     delete state;
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         delete neighboringRouters[i];
     }
 }

Member Function Documentation

void inet::ospf::Interface::addDelayedAcknowledgement ( OSPFLSAHeader & lsaHeader )

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA().

 {
     if (interfaceType == Interface::BROADCAST) {
         if ((getState() == Interface::DESIGNATED_ROUTER_STATE) ||
             (getState() == Interface::BACKUP_STATE) ||
             (designatedRouter == NULL_DESIGNATEDROUTERID))
         {
             delayedAcknowledgements[IPv4Address::ALL_OSPF_ROUTERS_MCAST].push_back(lsaHeader);
         }
         else {
             delayedAcknowledgements[IPv4Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST].push_back(lsaHeader);
         }
     }
     else {
         long neighborCount = neighboringRouters.size();
         for (long i = 0; i < neighborCount; i++) {
             if (neighboringRouters[i]->getState() >= Neighbor::EXCHANGE_STATE) {
                 delayedAcknowledgements[neighboringRouters[i]->getAddress()].push_back(lsaHeader);
             }
         }
     }
 }

void inet::ospf::Interface::addNeighbor ( Neighbor * neighbor )

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), inet::ospf::OSPFConfigReader::loadVirtualLink(), and inet::ospf::HelloHandler::processPacket().

 {
     neighboringRoutersByID[neighbor->getNeighborID()] = neighbor;
     neighboringRoutersByAddress[neighbor->getAddress()] = neighbor;
     neighbor->setInterface(this);
     neighboringRouters.push_back(neighbor);
 }

void inet::ospf::Interface::ageTransmittedLSALists ( )

 {
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         neighboringRouters[i]->ageTransmittedLSAList();
     }
 }

void inet::ospf::Interface::changeState	(	InterfaceState *	newState,
		InterfaceState *	currentState
	)

private

Referenced by inet::ospf::InterfaceState::changeState().

 {
     if (previousState != nullptr) {
         delete previousState;
     }
     state = newState;
     previousState = currentState;
 }

OSPFLinkStateUpdatePacket * inet::ospf::Interface::createUpdatePacket ( OSPFLSA * lsa )

Referenced by floodLSA(), inet::ospf::LinkStateRequestHandler::processPacket(), and inet::ospf::LinkStateUpdateHandler::processPacket().

 {
     LSAType lsaType = static_cast<LSAType>(lsa->getHeader().getLsType());
     OSPFRouterLSA *routerLSA = (lsaType == ROUTERLSA_TYPE) ? dynamic_cast<OSPFRouterLSA *>(lsa) : nullptr;
     OSPFNetworkLSA *networkLSA = (lsaType == NETWORKLSA_TYPE) ? dynamic_cast<OSPFNetworkLSA *>(lsa) : nullptr;
     OSPFSummaryLSA *summaryLSA = ((lsaType == SUMMARYLSA_NETWORKS_TYPE) ||
                                   (lsaType == SUMMARYLSA_ASBOUNDARYROUTERS_TYPE)) ? dynamic_cast<OSPFSummaryLSA *>(lsa) : nullptr;
     OSPFASExternalLSA *asExternalLSA = (lsaType == AS_EXTERNAL_LSA_TYPE) ? dynamic_cast<OSPFASExternalLSA *>(lsa) : nullptr;
 
     if (((lsaType == ROUTERLSA_TYPE) && (routerLSA != nullptr)) ||
         ((lsaType == NETWORKLSA_TYPE) && (networkLSA != nullptr)) ||
         (((lsaType == SUMMARYLSA_NETWORKS_TYPE) || (lsaType == SUMMARYLSA_ASBOUNDARYROUTERS_TYPE)) && (summaryLSA != nullptr)) ||
         ((lsaType == AS_EXTERNAL_LSA_TYPE) && (asExternalLSA != nullptr)))
     {
         OSPFLinkStateUpdatePacket *updatePacket = new OSPFLinkStateUpdatePacket();
         long packetLength = OSPF_HEADER_LENGTH + sizeof(uint32_t);    // OSPF header + place for number of advertisements
 
         updatePacket->setType(LINKSTATE_UPDATE_PACKET);
         updatePacket->setRouterID(IPv4Address(parentArea->getRouter()->getRouterID()));
         updatePacket->setAreaID(IPv4Address(areaID));
         updatePacket->setAuthenticationType(authenticationType);
         for (int j = 0; j < 8; j++) {
             updatePacket->setAuthentication(j, authenticationKey.bytes[j]);
         }
 
         updatePacket->setNumberOfLSAs(1);
 
         switch (lsaType) {
             case ROUTERLSA_TYPE: {
                 updatePacket->setRouterLSAsArraySize(1);
                 updatePacket->setRouterLSAs(0, *routerLSA);
                 unsigned short lsAge = updatePacket->getRouterLSAs(0).getHeader().getLsAge();
                 if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                     updatePacket->getRouterLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                 }
                 else {
                     updatePacket->getRouterLSAs(0).getHeader().setLsAge(MAX_AGE);
                 }
                 packetLength += calculateLSASize(routerLSA);
             }
             break;
 
             case NETWORKLSA_TYPE: {
                 updatePacket->setNetworkLSAsArraySize(1);
                 updatePacket->setNetworkLSAs(0, *networkLSA);
                 unsigned short lsAge = updatePacket->getNetworkLSAs(0).getHeader().getLsAge();
                 if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                     updatePacket->getNetworkLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                 }
                 else {
                     updatePacket->getNetworkLSAs(0).getHeader().setLsAge(MAX_AGE);
                 }
                 packetLength += calculateLSASize(networkLSA);
             }
             break;
 
             case SUMMARYLSA_NETWORKS_TYPE:
             case SUMMARYLSA_ASBOUNDARYROUTERS_TYPE: {
                 updatePacket->setSummaryLSAsArraySize(1);
                 updatePacket->setSummaryLSAs(0, *summaryLSA);
                 unsigned short lsAge = updatePacket->getSummaryLSAs(0).getHeader().getLsAge();
                 if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                     updatePacket->getSummaryLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                 }
                 else {
                     updatePacket->getSummaryLSAs(0).getHeader().setLsAge(MAX_AGE);
                 }
                 packetLength += calculateLSASize(summaryLSA);
             }
             break;
 
             case AS_EXTERNAL_LSA_TYPE: {
                 updatePacket->setAsExternalLSAsArraySize(1);
                 updatePacket->setAsExternalLSAs(0, *asExternalLSA);
                 unsigned short lsAge = updatePacket->getAsExternalLSAs(0).getHeader().getLsAge();
                 if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                     updatePacket->getAsExternalLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                 }
                 else {
                     updatePacket->getAsExternalLSAs(0).getHeader().setLsAge(MAX_AGE);
                 }
                 packetLength += calculateLSASize(asExternalLSA);
             }
             break;
 
             default:
                 throw cRuntimeError("Invalid LSA type: %d", lsaType);
         }
 
         updatePacket->setByteLength(packetLength);
 
         return updatePacket;
     }
     return nullptr;
 }

bool inet::ospf::Interface::floodLSA	(	OSPFLSA *	lsa,
		Interface *	intf = `nullptr`,
		Neighbor *	neighbor = `nullptr`
	)

See also: RFC2328 Section 13.3.

 {
     bool floodedBackOut = false;
 
     if (
         (
             (lsa->getHeader().getLsType() == AS_EXTERNAL_LSA_TYPE) &&
             (interfaceType != Interface::VIRTUAL) &&
             (parentArea->getExternalRoutingCapability())
         ) ||
         (
             (lsa->getHeader().getLsType() != AS_EXTERNAL_LSA_TYPE) &&
             (
                 (
                     (areaID != BACKBONE_AREAID) &&
                     (interfaceType != Interface::VIRTUAL)
                 ) ||
                 (areaID == BACKBONE_AREAID)
             )
         )
         )
     {
         long neighborCount = neighboringRouters.size();
         bool lsaAddedToRetransmissionList = false;
         LinkStateID linkStateID = lsa->getHeader().getLinkStateID();
         LSAKeyType lsaKey;
 
         lsaKey.linkStateID = linkStateID;
         lsaKey.advertisingRouter = lsa->getHeader().getAdvertisingRouter();
 
         for (long i = 0; i < neighborCount; i++) {    // (1)
             if (neighboringRouters[i]->getState() < Neighbor::EXCHANGE_STATE) {    // (1) (a)
                 continue;
             }
             if (neighboringRouters[i]->getState() < Neighbor::FULL_STATE) {    // (1) (b)
                 OSPFLSAHeader *requestLSAHeader = neighboringRouters[i]->findOnRequestList(lsaKey);
                 if (requestLSAHeader != nullptr) {
                     // operator< and operator== on OSPFLSAHeaders determines which one is newer(less means older)
                     if (lsa->getHeader() < (*requestLSAHeader)) {
                         continue;
                     }
                     if (operator==(lsa->getHeader(), (*requestLSAHeader))) {
                         neighboringRouters[i]->removeFromRequestList(lsaKey);
                         continue;
                     }
                     neighboringRouters[i]->removeFromRequestList(lsaKey);
                 }
             }
             if (neighbor == neighboringRouters[i]) {    // (1) (c)
                 continue;
             }
             neighboringRouters[i]->addToRetransmissionList(lsa);    // (1) (d)
             lsaAddedToRetransmissionList = true;
         }
         if (lsaAddedToRetransmissionList) {    // (2)
             if ((intf != this) ||
                 ((neighbor != nullptr) &&
                  (neighbor->getNeighborID() != designatedRouter.routerID) &&
                  (neighbor->getNeighborID() != backupDesignatedRouter.routerID)))    // (3)
             {
                 if ((intf != this) || (getState() != Interface::BACKUP_STATE)) {    // (4)
                     OSPFLinkStateUpdatePacket *updatePacket = createUpdatePacket(lsa);    // (5)
 
                     if (updatePacket != nullptr) {
                         int ttl = (interfaceType == Interface::VIRTUAL) ? VIRTUAL_LINK_TTL : 1;
                         MessageHandler *messageHandler = parentArea->getRouter()->getMessageHandler();
 
                         if (interfaceType == Interface::BROADCAST) {
                             if ((getState() == Interface::DESIGNATED_ROUTER_STATE) ||
                                 (getState() == Interface::BACKUP_STATE) ||
                                 (designatedRouter == NULL_DESIGNATEDROUTERID))
                             {
                                 messageHandler->sendPacket(updatePacket, IPv4Address::ALL_OSPF_ROUTERS_MCAST, ifIndex, ttl);
                                 for (long k = 0; k < neighborCount; k++) {
                                     neighboringRouters[k]->addToTransmittedLSAList(lsaKey);
                                     if (!neighboringRouters[k]->isUpdateRetransmissionTimerActive()) {
                                         neighboringRouters[k]->startUpdateRetransmissionTimer();
                                     }
                                 }
                             }
                             else {
                                 messageHandler->sendPacket(updatePacket, IPv4Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST, ifIndex, ttl);
                                 Neighbor *dRouter = getNeighborByID(designatedRouter.routerID);
                                 Neighbor *backupDRouter = getNeighborByID(backupDesignatedRouter.routerID);
                                 if (dRouter != nullptr) {
                                     dRouter->addToTransmittedLSAList(lsaKey);
                                     if (!dRouter->isUpdateRetransmissionTimerActive()) {
                                         dRouter->startUpdateRetransmissionTimer();
                                     }
                                 }
                                 if (backupDRouter != nullptr) {
                                     backupDRouter->addToTransmittedLSAList(lsaKey);
                                     if (!backupDRouter->isUpdateRetransmissionTimerActive()) {
                                         backupDRouter->startUpdateRetransmissionTimer();
                                     }
                                 }
                             }
                         }
                         else {
                             if (interfaceType == Interface::POINTTOPOINT) {
                                 messageHandler->sendPacket(updatePacket, IPv4Address::ALL_OSPF_ROUTERS_MCAST, ifIndex, ttl);
                                 if (neighborCount > 0) {
                                     neighboringRouters[0]->addToTransmittedLSAList(lsaKey);
                                     if (!neighboringRouters[0]->isUpdateRetransmissionTimerActive()) {
                                         neighboringRouters[0]->startUpdateRetransmissionTimer();
                                     }
                                 }
                             }
                             else {
                                 for (long m = 0; m < neighborCount; m++) {
                                     if (neighboringRouters[m]->getState() >= Neighbor::EXCHANGE_STATE) {
                                         messageHandler->sendPacket(updatePacket, neighboringRouters[m]->getAddress(), ifIndex, ttl);
                                         neighboringRouters[m]->addToTransmittedLSAList(lsaKey);
                                         if (!neighboringRouters[m]->isUpdateRetransmissionTimerActive()) {
                                             neighboringRouters[m]->startUpdateRetransmissionTimer();
                                         }
                                     }
                                 }
                             }
                         }
 
                         if (intf == this) {
                             floodedBackOut = true;
                         }
                     }
                 }
             }
         }
     }
 
     return floodedBackOut;
 }

short inet::ospf::Interface::getAcknowledgementDelay ( ) const

inline

Referenced by inet::ospf::InterfaceStateDown::processEvent().

148 { return acknowledgementDelay; }

inet::ospf::Interface::acknowledgementDelay

short acknowledgementDelay

Definition: OSPFInterface.h:98

cMessage* inet::ospf::Interface::getAcknowledgementTimer ( )

inline

Referenced by inet::ospf::InterfaceStateDown::processEvent().

166 { return acknowledgementTimer; }

inet::ospf::Interface::acknowledgementTimer

cMessage * acknowledgementTimer

Definition: OSPFInterface.h:89

IPv4AddressRange inet::ospf::Interface::getAddressRange ( ) const

inline

Referenced by inet::ospf::InterfaceState::changeState(), inet::ospf::NeighborState::changeState(), inet::ospf::Area::originateNetworkLSA(), inet::ospf::Area::originateRouterLSA(), and inet::ospf::HelloHandler::processPacket().

162 { return interfaceAddressRange; }

inet::ospf::Interface::interfaceAddressRange

IPv4AddressRange interfaceAddressRange

Definition: OSPFInterface.h:79

Area* inet::ospf::Interface::getArea ( )

inline

174 { return parentArea; }

inet::ospf::Interface::parentArea

Area * parentArea

Definition: OSPFInterface.h:102

const Area* inet::ospf::Interface::getArea ( ) const

inline

175 { return parentArea; }

inet::ospf::Interface::parentArea

Area * parentArea

Definition: OSPFInterface.h:102

AreaID inet::ospf::Interface::getAreaID ( ) const

inline

Referenced by inet::ospf::OSPFConfigReader::loadVirtualLink(), and inet::ospf::Area::originateSummaryLSA().

138 { return areaID; }

inet::ospf::Interface::areaID

AreaID areaID

Definition: OSPFInterface.h:80

AuthenticationKeyType inet::ospf::Interface::getAuthenticationKey ( ) const

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Neighbor::retransmitUpdatePacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), and inet::ospf::Neighbor::sendLinkStateRequestPacket().

160 { return authenticationKey; }

inet::ospf::Interface::authenticationKey

AuthenticationKeyType authenticationKey

Definition: OSPFInterface.h:100

AuthenticationType inet::ospf::Interface::getAuthenticationType ( ) const

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Neighbor::retransmitUpdatePacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), and inet::ospf::Neighbor::sendLinkStateRequestPacket().

158 { return authenticationType; }

inet::ospf::Interface::authenticationType

AuthenticationType authenticationType

Definition: OSPFInterface.h:99

DesignatedRouterID inet::ospf::Interface::getBackupDesignatedRouter ( ) const

inline

Referenced by inet::ospf::Neighbor::needAdjacency(), and inet::ospf::InterfaceStateNotDesignatedRouter::processEvent().

168 { return backupDesignatedRouter; }

inet::ospf::Interface::backupDesignatedRouter

DesignatedRouterID backupDesignatedRouter

Definition: OSPFInterface.h:95

DesignatedRouterID inet::ospf::Interface::getDesignatedRouter ( ) const

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Neighbor::needAdjacency(), inet::ospf::Area::originateRouterLSA(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::LinkStateRequestHandler::processPacket(), and inet::ospf::LinkStateUpdateHandler::processPacket().

167 { return designatedRouter; }

inet::ospf::Interface::designatedRouter

DesignatedRouterID designatedRouter

Definition: OSPFInterface.h:94

short inet::ospf::Interface::getHelloInterval ( ) const

inline

Referenced by inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStateDesignatedRouter::processEvent(), and inet::ospf::HelloHandler::processPacket().

152 { return helloInterval; }

inet::ospf::Interface::helloInterval

short helloInterval

Definition: OSPFInterface.h:82

cMessage* inet::ospf::Interface::getHelloTimer ( )

inline

Referenced by inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStateDown::processEvent(), and inet::ospf::InterfaceStateDesignatedRouter::processEvent().

164 { return helloTimer; }

inet::ospf::Interface::helloTimer

cMessage * helloTimer

Definition: OSPFInterface.h:87

int inet::ospf::Interface::getIfIndex ( ) const

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Area::originateRouterLSA(), inet::ospf::MessageHandler::printEvent(), inet::ospf::LinkStateRequestHandler::processPacket(), inet::ospf::LinkStateUpdateHandler::processPacket(), inet::ospf::Neighbor::retransmitDatabaseDescriptionPacket(), inet::ospf::Neighbor::retransmitUpdatePacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), and inet::ospf::Neighbor::sendLinkStateRequestPacket().

134 { return ifIndex; }

inet::ospf::Interface::ifIndex

int ifIndex

Definition: OSPFInterface.h:77

unsigned short inet::ospf::Interface::getMTU ( ) const

inline

Referenced by inet::ospf::DatabaseDescriptionHandler::processPacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), and inet::ospf::Neighbor::sendLinkStateRequestPacket().

136 { return mtu; }

inet::ospf::Interface::mtu

unsigned short mtu

Definition: OSPFInterface.h:78

Neighbor* inet::ospf::Interface::getNeighbor ( unsigned long i )

inline

Referenced by inet::ospf::Area::calculateShortestPathTree(), inet::ospf::Area::originateNetworkLSA(), inet::ospf::Area::originateRouterLSA(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStateDown::processEvent(), inet::ospf::InterfaceStateDesignatedRouter::processEvent(), inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), and inet::ospf::HelloHandler::processPacket().

170 { return neighboringRouters[i]; }

inet::ospf::Interface::neighboringRouters

std::vector< Neighbor * > neighboringRouters

Definition: OSPFInterface.h:92

const Neighbor* inet::ospf::Interface::getNeighbor ( unsigned long i ) const

inline

171 { return neighboringRouters[i]; }

inet::ospf::Interface::neighboringRouters

std::vector< Neighbor * > neighboringRouters

Definition: OSPFInterface.h:92

Neighbor * inet::ospf::Interface::getNeighborByAddress ( IPv4Address address )

Referenced by inet::ospf::Area::originateRouterLSA(), inet::ospf::HelloHandler::processPacket(), and inet::ospf::MessageHandler::processPacket().

 {
     auto neighborIt =
         neighboringRoutersByAddress.find(address);
 
     if (neighborIt != neighboringRoutersByAddress.end()) {
         return neighborIt->second;
     }
     else {
         return nullptr;
     }
 }

Neighbor * inet::ospf::Interface::getNeighborByID ( RouterID neighborID )

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), floodLSA(), inet::ospf::HelloHandler::processPacket(), and inet::ospf::MessageHandler::processPacket().

 {
     auto neighborIt = neighboringRoutersByID.find(neighborID);
     if (neighborIt != neighboringRoutersByID.end()) {
         return neighborIt->second;
     }
     else {
         return nullptr;
     }
 }

unsigned long inet::ospf::Interface::getNeighborCount ( ) const

inline

Referenced by inet::ospf::Area::ageDatabase(), inet::ospf::Area::originateNetworkLSA(), inet::ospf::Area::originateRouterLSA(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStateDown::processEvent(), inet::ospf::InterfaceStateDesignatedRouter::processEvent(), inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), and inet::ospf::HelloHandler::processPacket().

169 { return neighboringRouters.size(); }

inet::ospf::Interface::neighboringRouters

std::vector< Neighbor * > neighboringRouters

Definition: OSPFInterface.h:92

Metric inet::ospf::Interface::getOutputCost ( ) const

inline

Referenced by inet::ospf::Area::originateRouterLSA().

142 { return interfaceOutputCost; }

inet::ospf::Interface::interfaceOutputCost

Metric interfaceOutputCost

Definition: OSPFInterface.h:96

short inet::ospf::Interface::getPollInterval ( ) const

inline

Referenced by inet::ospf::NeighborStateAttempt::processEvent(), inet::ospf::NeighborStateTwoWay::processEvent(), inet::ospf::NeighborStateLoading::processEvent(), inet::ospf::NeighborStateInit::processEvent(), inet::ospf::NeighborStateFull::processEvent(), inet::ospf::NeighborStateExchangeStart::processEvent(), inet::ospf::NeighborStateExchange::processEvent(), and inet::ospf::NeighborStateDown::processEvent().

154 { return pollInterval; }

inet::ospf::Interface::pollInterval

short pollInterval

Definition: OSPFInterface.h:83

short inet::ospf::Interface::getRetransmissionInterval ( ) const

inline

Referenced by inet::ospf::NeighborStateExchange::processEvent(), inet::ospf::NeighborStateExchangeStart::processEvent(), inet::ospf::NeighborStateLoading::processEvent(), inet::ospf::NeighborStateTwoWay::processEvent(), inet::ospf::NeighborStateFull::processEvent(), inet::ospf::NeighborStateInit::processEvent(), inet::ospf::Neighbor::startRequestRetransmissionTimer(), and inet::ospf::Neighbor::startUpdateRetransmissionTimer().

144 { return retransmissionInterval; }

inet::ospf::Interface::retransmissionInterval

short retransmissionInterval

Definition: OSPFInterface.h:97

short inet::ospf::Interface::getRouterDeadInterval ( ) const

inline

Referenced by inet::ospf::InterfaceStateDown::processEvent(), and inet::ospf::HelloHandler::processPacket().

156 { return routerDeadInterval; }

inet::ospf::Interface::routerDeadInterval

short routerDeadInterval

Definition: OSPFInterface.h:84

unsigned char inet::ospf::Interface::getRouterPriority ( ) const

inline

Referenced by inet::ospf::InterfaceStateDown::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), and inet::ospf::HelloHandler::processPacket().

150 { return routerPriority; }

inet::ospf::Interface::routerPriority

unsigned char routerPriority

Definition: OSPFInterface.h:86

Interface::InterfaceStateType inet::ospf::Interface::getState ( ) const

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), addDelayedAcknowledgement(), inet::ospf::Area::ageDatabase(), inet::ospf::InterfaceState::calculateDesignatedRouter(), inet::ospf::Area::calculateShortestPathTree(), inet::ospf::NeighborState::changeState(), floodLSA(), inet::ospf::Area::originateRouterLSA(), inet::ospf::MessageHandler::printEvent(), inet::ospf::HelloHandler::processPacket(), inet::ospf::LinkStateRequestHandler::processPacket(), inet::ospf::LinkStateUpdateHandler::processPacket(), inet::ospf::MessageHandler::processPacket(), sendDelayedAcknowledgements(), and sendHelloPacket().

 {
     return state->getState();
 }

const char * inet::ospf::Interface::getStateString ( Interface::InterfaceStateType stateType )

static

Referenced by inet::ospf::MessageHandler::printEvent().

 {
     switch (stateType) {
         case DOWN_STATE:
             return "Down";
 
         case LOOPBACK_STATE:
             return "Loopback";
 
         case WAITING_STATE:
             return "Waiting";
 
         case POINTTOPOINT_STATE:
             return "PointToPoint";
 
         case NOT_DESIGNATED_ROUTER_STATE:
             return "NotDesignatedRouter";
 
         case BACKUP_STATE:
             return "Backup";
 
         case DESIGNATED_ROUTER_STATE:
             return "DesignatedRouter";
 
         default:
             ASSERT(false);
             break;
     }
     return "";
 }

AreaID inet::ospf::Interface::getTransitAreaID ( ) const

inline

Referenced by inet::ospf::Area::calculateShortestPathTree(), and inet::ospf::MessageHandler::processPacket().

140 { return transitAreaID; }

inet::ospf::Interface::transitAreaID

AreaID transitAreaID

Definition: OSPFInterface.h:81

short inet::ospf::Interface::getTransmissionDelay ( ) const

inline

Referenced by inet::ospf::Neighbor::retransmitUpdatePacket().

146 { return interfaceTransmissionDelay; }

inet::ospf::Interface::interfaceTransmissionDelay

short interfaceTransmissionDelay

Definition: OSPFInterface.h:85

OSPFInterfaceType inet::ospf::Interface::getType ( ) const

inline

132 { return interfaceType; }

inet::ospf::Interface::interfaceType

OSPFInterfaceType interfaceType

Definition: OSPFInterface.h:74

cMessage* inet::ospf::Interface::getWaitTimer ( )

inline

Referenced by inet::ospf::InterfaceStateDown::processEvent().

165 { return waitTimer; }

inet::ospf::Interface::waitTimer

cMessage * waitTimer

Definition: OSPFInterface.h:88

bool inet::ospf::Interface::hasAnyNeighborInStates ( int states ) const

Referenced by inet::ospf::Area::ageDatabase(), inet::ospf::Area::originateNetworkLSA(), and inet::ospf::Area::originateRouterLSA().

 {
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         Neighbor::NeighborStateType neighborState = neighboringRouters[i]->getState();
         if (neighborState & states) {
             return true;
         }
     }
     return false;
 }

bool inet::ospf::Interface::isOnAnyRetransmissionList ( LSAKeyType lsaKey ) const

 {
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         if (neighboringRouters[i]->isLinkStateRequestListEmpty(lsaKey)) {
             return true;
         }
     }
     return false;
 }

void inet::ospf::Interface::processEvent ( Interface::InterfaceEventType event )

Referenced by inet::ospf::Area::calculateShortestPathTree(), inet::ospf::MessageHandler::handleTimer(), inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::HelloHandler::processPacket().

 {
     state->processEvent(this, event);
 }

void inet::ospf::Interface::removeFromAllRetransmissionLists ( LSAKeyType lsaKey )

 {
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         neighboringRouters[i]->removeFromRetransmissionList(lsaKey);
     }
 }

void inet::ospf::Interface::reset ( )

Referenced by inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStateLoopback::processEvent(), inet::ospf::InterfaceStateDown::processEvent(), and inet::ospf::InterfaceStateDesignatedRouter::processEvent().

 {
     MessageHandler *messageHandler = parentArea->getRouter()->getMessageHandler();
     messageHandler->clearTimer(helloTimer);
     messageHandler->clearTimer(waitTimer);
     messageHandler->clearTimer(acknowledgementTimer);
     designatedRouter = NULL_DESIGNATEDROUTERID;
     backupDesignatedRouter = NULL_DESIGNATEDROUTERID;
     long neighborCount = neighboringRouters.size();
     for (long i = 0; i < neighborCount; i++) {
         neighboringRouters[i]->processEvent(Neighbor::KILL_NEIGHBOR);
     }
 }

void inet::ospf::Interface::sendDelayedAcknowledgements ( )

Referenced by inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), and inet::ospf::InterfaceStateDesignatedRouter::processEvent().

 {
     MessageHandler *messageHandler = parentArea->getRouter()->getMessageHandler();
     long maxPacketSize = ((IP_MAX_HEADER_BYTES + OSPF_HEADER_LENGTH + OSPF_LSA_HEADER_LENGTH) > mtu) ? IPV4_DATAGRAM_LENGTH : mtu;
 
     for (auto & elem : delayedAcknowledgements)
     {
         int ackCount = elem.second.size();
         if (ackCount > 0) {
             while (!(elem.second.empty())) {
                 OSPFLinkStateAcknowledgementPacket *ackPacket = new OSPFLinkStateAcknowledgementPacket();
                 long packetSize = IP_MAX_HEADER_BYTES + OSPF_HEADER_LENGTH;
 
                 ackPacket->setType(LINKSTATE_ACKNOWLEDGEMENT_PACKET);
                 ackPacket->setRouterID(IPv4Address(parentArea->getRouter()->getRouterID()));
                 ackPacket->setAreaID(IPv4Address(areaID));
                 ackPacket->setAuthenticationType(authenticationType);
                 for (int i = 0; i < 8; i++) {
                     ackPacket->setAuthentication(i, authenticationKey.bytes[i]);
                 }
 
                 while ((!(elem.second.empty())) && (packetSize <= (maxPacketSize - OSPF_LSA_HEADER_LENGTH))) {
                     unsigned long headerCount = ackPacket->getLsaHeadersArraySize();
                     ackPacket->setLsaHeadersArraySize(headerCount + 1);
                     ackPacket->setLsaHeaders(headerCount, *(elem.second.begin()));
                     elem.second.pop_front();
                     packetSize += OSPF_LSA_HEADER_LENGTH;
                 }
 
                 ackPacket->setByteLength(packetSize - IP_MAX_HEADER_BYTES);
 
                 int ttl = (interfaceType == Interface::VIRTUAL) ? VIRTUAL_LINK_TTL : 1;
 
                 if (interfaceType == Interface::BROADCAST) {
                     if ((getState() == Interface::DESIGNATED_ROUTER_STATE) ||
                         (getState() == Interface::BACKUP_STATE) ||
                         (designatedRouter == NULL_DESIGNATEDROUTERID))
                     {
                         messageHandler->sendPacket(ackPacket, IPv4Address::ALL_OSPF_ROUTERS_MCAST, ifIndex, ttl);
                     }
                     else {
                         messageHandler->sendPacket(ackPacket, IPv4Address::ALL_OSPF_DESIGNATED_ROUTERS_MCAST, ifIndex, ttl);
                     }
                 }
                 else {
                     if (interfaceType == Interface::POINTTOPOINT) {
                         messageHandler->sendPacket(ackPacket, IPv4Address::ALL_OSPF_ROUTERS_MCAST, ifIndex, ttl);
                     }
                     else {
                         messageHandler->sendPacket(ackPacket, elem.first, ifIndex, ttl);
                     }
                 }
             }
         }
     }
     messageHandler->startTimer(acknowledgementTimer, acknowledgementDelay);
 }

void inet::ospf::Interface::sendHelloPacket	(	IPv4Address	destination,
		short	ttl = `1`
	)

Referenced by inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::NeighborStateDown::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStateDesignatedRouter::processEvent(), and inet::ospf::HelloHandler::processPacket().

 {
     OSPFOptions options;
     OSPFHelloPacket *helloPacket = new OSPFHelloPacket();
     std::vector<IPv4Address> neighbors;
 
     helloPacket->setRouterID(IPv4Address(parentArea->getRouter()->getRouterID()));
     helloPacket->setAreaID(IPv4Address(parentArea->getAreaID()));
     helloPacket->setAuthenticationType(authenticationType);
     for (int i = 0; i < 8; i++) {
         helloPacket->setAuthentication(i, authenticationKey.bytes[i]);
     }
 
     if (((interfaceType == POINTTOPOINT) &&
          (interfaceAddressRange.address == NULL_IPV4ADDRESS)) ||
         (interfaceType == VIRTUAL))
     {
         helloPacket->setNetworkMask(NULL_IPV4ADDRESS);
     }
     else {
         helloPacket->setNetworkMask(interfaceAddressRange.mask);
     }
     memset(&options, 0, sizeof(OSPFOptions));
     options.E_ExternalRoutingCapability = parentArea->getExternalRoutingCapability();
     helloPacket->setOptions(options);
     helloPacket->setHelloInterval(helloInterval);
     helloPacket->setRouterPriority(routerPriority);
     helloPacket->setRouterDeadInterval(routerDeadInterval);
     helloPacket->setDesignatedRouter(designatedRouter.ipInterfaceAddress);
     helloPacket->setBackupDesignatedRouter(backupDesignatedRouter.ipInterfaceAddress);
     long neighborCount = neighboringRouters.size();
     for (long j = 0; j < neighborCount; j++) {
         if (neighboringRouters[j]->getState() >= Neighbor::INIT_STATE) {
             neighbors.push_back(neighboringRouters[j]->getAddress());
         }
     }
     unsigned int initedNeighborCount = neighbors.size();
     helloPacket->setNeighborArraySize(initedNeighborCount);
     for (unsigned int k = 0; k < initedNeighborCount; k++) {
         helloPacket->setNeighbor(k, neighbors[k]);
     }
 
     helloPacket->setByteLength(OSPF_HEADER_LENGTH + OSPF_HELLO_HEADER_LENGTH + initedNeighborCount * 4);
 
     parentArea->getRouter()->getMessageHandler()->sendPacket(helloPacket, destination, ifIndex, ttl);
 }

void inet::ospf::Interface::sendLSAcknowledgement	(	OSPFLSAHeader *	lsaHeader,
		IPv4Address	destination
	)

Referenced by inet::ospf::LinkStateUpdateHandler::processPacket().

 {
     OSPFOptions options;
     OSPFLinkStateAcknowledgementPacket *lsAckPacket = new OSPFLinkStateAcknowledgementPacket();
 
     lsAckPacket->setType(LINKSTATE_ACKNOWLEDGEMENT_PACKET);
     lsAckPacket->setRouterID(IPv4Address(parentArea->getRouter()->getRouterID()));
     lsAckPacket->setAreaID(IPv4Address(parentArea->getAreaID()));
     lsAckPacket->setAuthenticationType(authenticationType);
     for (int i = 0; i < 8; i++) {
         lsAckPacket->setAuthentication(i, authenticationKey.bytes[i]);
     }
 
     lsAckPacket->setLsaHeadersArraySize(1);
     lsAckPacket->setLsaHeaders(0, *lsaHeader);
 
     lsAckPacket->setByteLength(OSPF_HEADER_LENGTH + OSPF_LSA_HEADER_LENGTH);
 
     int ttl = (interfaceType == Interface::VIRTUAL) ? VIRTUAL_LINK_TTL : 1;
     parentArea->getRouter()->getMessageHandler()->sendPacket(lsAckPacket, destination, ifIndex, ttl);
 }

void inet::ospf::Interface::setAcknowledgementDelay ( short delay )

inline

147 { acknowledgementDelay = delay; }

inet::ospf::Interface::acknowledgementDelay

short acknowledgementDelay

Definition: OSPFInterface.h:98

void inet::ospf::Interface::setAddressRange ( IPv4AddressRange range )

inline

Referenced by inet::ospf::Area::calculateShortestPathTree().

161 { interfaceAddressRange = range; }

inet::ospf::Interface::interfaceAddressRange

IPv4AddressRange interfaceAddressRange

Definition: OSPFInterface.h:79

void inet::ospf::Interface::setArea ( Area * area )

inline

Referenced by inet::ospf::Area::addInterface().

173 { parentArea = area; }

inet::ospf::Interface::parentArea

Area * parentArea

Definition: OSPFInterface.h:102

void inet::ospf::Interface::setAreaID ( AreaID areaId )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters().

137 { areaID = areaId; }

inet::ospf::Interface::areaID

AreaID areaID

Definition: OSPFInterface.h:80

void inet::ospf::Interface::setAuthenticationKey ( AuthenticationKeyType key )

inline

Referenced by inet::ospf::OSPFConfigReader::loadAuthenticationConfig().

159 { authenticationKey = key; }

inet::ospf::Interface::authenticationKey

AuthenticationKeyType authenticationKey

Definition: OSPFInterface.h:100

void inet::ospf::Interface::setAuthenticationType ( AuthenticationType type )

inline

Referenced by inet::ospf::OSPFConfigReader::loadAuthenticationConfig().

157 { authenticationType = type; }

inet::ospf::Interface::authenticationType

AuthenticationType authenticationType

Definition: OSPFInterface.h:99

void inet::ospf::Interface::setHelloInterval ( short interval )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::OSPFConfigReader::loadVirtualLink().

151 { helloInterval = interval; }

inet::ospf::Interface::helloInterval

short helloInterval

Definition: OSPFInterface.h:82

void inet::ospf::Interface::setIfIndex	(	IInterfaceTable *	ift,
		int	index
	)

Referenced by inet::ospf::Area::calculateShortestPathTree(), and inet::ospf::OSPFConfigReader::loadInterfaceParameters().

 {
     ifIndex = index;
     if (interfaceType == Interface::UNKNOWN_TYPE) {
         InterfaceEntry *routingInterface = ift->getInterfaceById(ifIndex);
         interfaceAddressRange.address = routingInterface->ipv4Data()->getIPAddress();
         interfaceAddressRange.mask = routingInterface->ipv4Data()->getNetmask();
         mtu = routingInterface->getMTU();
     }
 }

void inet::ospf::Interface::setMTU ( unsigned short ifMTU )

inline

135 { mtu = ifMTU; }

inet::ospf::Interface::mtu

unsigned short mtu

Definition: OSPFInterface.h:78

void inet::ospf::Interface::setOutputCost ( Metric cost )

inline

Referenced by inet::ospf::Area::calculateShortestPathTree(), and inet::ospf::OSPFConfigReader::loadInterfaceParameters().

141 { interfaceOutputCost = cost; }

inet::ospf::Interface::interfaceOutputCost

Metric interfaceOutputCost

Definition: OSPFInterface.h:96

void inet::ospf::Interface::setPollInterval ( short interval )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters().

153 { pollInterval = interval; }

inet::ospf::Interface::pollInterval

short pollInterval

Definition: OSPFInterface.h:83

void inet::ospf::Interface::setRetransmissionInterval ( short interval )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::OSPFConfigReader::loadVirtualLink().

143 { retransmissionInterval = interval; }

inet::ospf::Interface::retransmissionInterval

short retransmissionInterval

Definition: OSPFInterface.h:97

void inet::ospf::Interface::setRouterDeadInterval ( short interval )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::OSPFConfigReader::loadVirtualLink().

155 { routerDeadInterval = interval; }

inet::ospf::Interface::routerDeadInterval

short routerDeadInterval

Definition: OSPFInterface.h:84

void inet::ospf::Interface::setRouterPriority ( unsigned char priority )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters().

149 { routerPriority = priority; }

inet::ospf::Interface::routerPriority

unsigned char routerPriority

Definition: OSPFInterface.h:86

void inet::ospf::Interface::setTransitAreaID ( AreaID areaId )

inline

Referenced by inet::ospf::OSPFConfigReader::loadVirtualLink().

139 { transitAreaID = areaId; }

inet::ospf::Interface::transitAreaID

AreaID transitAreaID

Definition: OSPFInterface.h:81

void inet::ospf::Interface::setTransmissionDelay ( short delay )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::OSPFConfigReader::loadVirtualLink().

145 { interfaceTransmissionDelay = delay; }

inet::ospf::Interface::interfaceTransmissionDelay

short interfaceTransmissionDelay

Definition: OSPFInterface.h:85

void inet::ospf::Interface::setType ( OSPFInterfaceType ifType )

inline

Referenced by inet::ospf::OSPFConfigReader::loadInterfaceParameters(), and inet::ospf::OSPFConfigReader::loadVirtualLink().

131 { interfaceType = ifType; }

inet::ospf::Interface::interfaceType

OSPFInterfaceType interfaceType

Definition: OSPFInterface.h:74

Friends And Related Function Documentation

friend class InterfaceState

friend

Member Data Documentation

short inet::ospf::Interface::acknowledgementDelay

private

Referenced by sendDelayedAcknowledgements().

cMessage* inet::ospf::Interface::acknowledgementTimer

private

Referenced by Interface(), reset(), sendDelayedAcknowledgements(), and ~Interface().

AreaID inet::ospf::Interface::areaID

private

Referenced by createUpdatePacket(), floodLSA(), and sendDelayedAcknowledgements().

AuthenticationKeyType inet::ospf::Interface::authenticationKey

private

Referenced by createUpdatePacket(), Interface(), sendDelayedAcknowledgements(), sendHelloPacket(), and sendLSAcknowledgement().

AuthenticationType inet::ospf::Interface::authenticationType

private

Referenced by createUpdatePacket(), sendDelayedAcknowledgements(), sendHelloPacket(), and sendLSAcknowledgement().

DesignatedRouterID inet::ospf::Interface::backupDesignatedRouter

private

Referenced by inet::ospf::InterfaceState::calculateDesignatedRouter(), floodLSA(), reset(), and sendHelloPacket().

std::map<IPv4Address, std::list<OSPFLSAHeader> > inet::ospf::Interface::delayedAcknowledgements

private

Referenced by addDelayedAcknowledgement(), and sendDelayedAcknowledgements().

DesignatedRouterID inet::ospf::Interface::designatedRouter

private

Referenced by addDelayedAcknowledgement(), inet::ospf::InterfaceState::calculateDesignatedRouter(), floodLSA(), reset(), sendDelayedAcknowledgements(), and sendHelloPacket().

short inet::ospf::Interface::helloInterval

private

Referenced by sendHelloPacket().

cMessage* inet::ospf::Interface::helloTimer

private

Referenced by Interface(), reset(), and ~Interface().

int inet::ospf::Interface::ifIndex

private

Referenced by floodLSA(), sendDelayedAcknowledgements(), sendHelloPacket(), sendLSAcknowledgement(), and setIfIndex().

IPv4AddressRange inet::ospf::Interface::interfaceAddressRange

private

Referenced by inet::ospf::InterfaceState::calculateDesignatedRouter(), sendHelloPacket(), and setIfIndex().

Metric inet::ospf::Interface::interfaceOutputCost

private

short inet::ospf::Interface::interfaceTransmissionDelay

private

Referenced by createUpdatePacket().

OSPFInterfaceType inet::ospf::Interface::interfaceType

private

Referenced by addDelayedAcknowledgement(), inet::ospf::InterfaceState::calculateDesignatedRouter(), floodLSA(), sendDelayedAcknowledgements(), sendHelloPacket(), sendLSAcknowledgement(), and setIfIndex().

unsigned short inet::ospf::Interface::mtu

private

Referenced by sendDelayedAcknowledgements(), and setIfIndex().

std::vector<Neighbor *> inet::ospf::Interface::neighboringRouters

private

Referenced by addDelayedAcknowledgement(), addNeighbor(), ageTransmittedLSALists(), inet::ospf::InterfaceState::calculateDesignatedRouter(), floodLSA(), hasAnyNeighborInStates(), isOnAnyRetransmissionList(), removeFromAllRetransmissionLists(), reset(), sendHelloPacket(), and ~Interface().

std::map<IPv4Address, Neighbor *> inet::ospf::Interface::neighboringRoutersByAddress

private

Referenced by addNeighbor(), and getNeighborByAddress().

std::map<RouterID, Neighbor *> inet::ospf::Interface::neighboringRoutersByID

private

Referenced by addNeighbor(), and getNeighborByID().

Area* inet::ospf::Interface::parentArea

private

Referenced by inet::ospf::InterfaceState::calculateDesignatedRouter(), createUpdatePacket(), floodLSA(), reset(), sendDelayedAcknowledgements(), sendHelloPacket(), sendLSAcknowledgement(), and ~Interface().

short inet::ospf::Interface::pollInterval

private

InterfaceState* inet::ospf::Interface::previousState

private

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

short inet::ospf::Interface::retransmissionInterval

private

short inet::ospf::Interface::routerDeadInterval

private

Referenced by sendHelloPacket().

unsigned char inet::ospf::Interface::routerPriority

private

Referenced by inet::ospf::InterfaceState::calculateDesignatedRouter(), and sendHelloPacket().

InterfaceState* inet::ospf::Interface::state

private

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

AreaID inet::ospf::Interface::transitAreaID

private

cMessage* inet::ospf::Interface::waitTimer

private

Referenced by Interface(), reset(), and ~Interface().

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation