inet::bgp::BGPRouting Class Reference

#include <BGPRouting.h>

Inheritance diagram for inet::bgp::BGPRouting:

Public Member Functions
	BGPRouting ()
virtual	~BGPRouting ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::TCPSocket::CallbackInterface
virtual	~CallbackInterface ()
virtual void	socketStatusArrived (int connId, void *yourPtr, TCPStatusInfo *status)
virtual void	socketDeleted (int connId, void *yourPtr)

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	finish () override
virtual void	socketDataArrived (int connId, void *yourPtr, cPacket *msg, bool urgent) override
virtual void	socketEstablished (int connId, void *yourPtr) override
virtual void	socketFailure (int connId, void *yourPtr, int code) override
virtual void	socketPeerClosed (int connId, void *yourPtr) override
virtual void	socketClosed (int connId, void *yourPtr) override
void	getScheduleAt (simtime_t t, cMessage *msg)
simtime_t	getSimTime ()
void	getCancelAndDelete (cMessage *msg)
cMessage *	getCancelEvent (cMessage *msg)
cGate *	getGate (const char *gateName)
IIPv4RoutingTable *	getIPRoutingTable ()
std::vector< RoutingTableEntry * >	getBGPRoutingTable ()
void	listenConnectionFromPeer (SessionID sessionID)
	active listenSocket for a given session (used by fsm) More...
void	openTCPConnectionToPeer (SessionID sessionID)
	active TCPConnection for a given session (used by fsm) More...
void	updateSendProcess (const unsigned char decisionProcessResult, SessionID sessionIndex, RoutingTableEntry *entry)
	RFC 4271, 9.2 : Update-Send Process / Sent or not new UPDATE messages to its peers. More...
SessionID	findNextSession (BGPSessionType type, bool startSession=false)
	find the next SessionID compared to his type and start this session if boolean is true More...
bool	checkExternalRoute (const IPv4Route *ospfRoute)
	check if the route is in OSPF external IPv4RoutingTable More...

Private Types
typedef std::vector< RoutingTableEntry * >	RoutingTableEntryVector

Private Member Functions
void	handleTimer (cMessage *timer)
void	processMessageFromTCP (cMessage *msg)
void	processMessage (const BGPOpenMessage &msg)
void	processMessage (const BGPKeepAliveMessage &msg)
void	processMessage (const BGPUpdateMessage &msg)
bool	deleteBGPRoutingEntry (RoutingTableEntry *entry)
unsigned char	decisionProcess (const BGPUpdateMessage &msg, RoutingTableEntry *entry, SessionID sessionIndex)
	RFC 4271: 9.1. More...
bool	tieBreakingProcess (RoutingTableEntry *oldEntry, RoutingTableEntry *entry)
	RFC 4271: 9.1.2.2 Breaking Ties used when BGP speaker may have several routes to the same destination that have the same degree of preference. More...
SessionID	createSession (BGPSessionType typeSession, const char *peerAddr)
bool	isInASList (std::vector< ASID > ASList, RoutingTableEntry *entry)
unsigned long	isInTable (std::vector< RoutingTableEntry * > rtTable, RoutingTableEntry *entry)
std::vector< const char * >	loadASConfig (cXMLElementList &ASConfig)
void	loadSessionConfig (cXMLElementList &sessionList, simtime_t *delayTab)
void	loadConfigFromXML (cXMLElement *bgpConfig)
ASID	findMyAS (cXMLElementList &ASList, int &outRouterPosition)
bool	ospfExist (IIPv4RoutingTable *rtTable)
void	loadTimerConfig (cXMLElementList &timerConfig, simtime_t *delayTab)
unsigned char	asLoopDetection (RoutingTableEntry *entry, ASID myAS)
SessionID	findIdFromPeerAddr (std::map< SessionID, BGPSession * > sessions, IPv4Address peerAddr)
int	isInRoutingTable (IIPv4RoutingTable *rtTable, IPv4Address addr)
int	isInInterfaceTable (IInterfaceTable *rtTable, IPv4Address addr)
SessionID	findIdFromSocketConnId (std::map< SessionID, BGPSession * > sessions, int connId)
unsigned int	calculateStartDelay (int rtListSize, unsigned char rtPosition, unsigned char rtPeerPosition)

Private Attributes
TCPSocketMap	_socketMap
ASID	_myAS = 0
SessionID	_currSessionId = 0
IInterfaceTable *	_inft = nullptr
IIPv4RoutingTable *	_rt = nullptr
RoutingTableEntryVector	_BGPRoutingTable
RoutingTableEntryVector	_prefixListIN
RoutingTableEntryVector	_prefixListOUT
RoutingTableEntryVector	_prefixListINOUT
std::vector< ASID >	_ASListIN
std::vector< ASID >	_ASListOUT
std::map< SessionID, BGPSession * >	_BGPSessions

Static Private Attributes
static const int	BGP_TCP_CONNECT_VALID = 71
static const int	BGP_TCP_CONNECT_CONFIRM = 72
static const int	BGP_TCP_CONNECT_FAILED = 73
static const int	BGP_TCP_CONNECT_OPEN_RCV = 74
static const int	BGP_TCP_KEEP_ALIVE_RCV = 75

Friends
class	BGPSession

Member Typedef Documentation

typedef std::vector<RoutingTableEntry *> inet::bgp::BGPRouting::RoutingTableEntryVector

private

Constructor & Destructor Documentation

inet::bgp::BGPRouting::BGPRouting ( )

inline

{}

inet::bgp::BGPRouting::~BGPRouting ( void  )

virtual

{
    for (auto & elem : _BGPSessions)
    {
        delete (elem).second;
    }

    for (auto & elem : _prefixListINOUT) {
        delete (elem);
    }
}

Member Function Documentation

unsigned char inet::bgp::BGPRouting::asLoopDetection ( RoutingTableEntry *  entry, ASID  myAS  )

private

Referenced by processMessage().

{
    for (unsigned int i = 1; i < entry->getASCount(); i++) {
        if (myAS == entry->getAS(i)) {
            return ASLOOP_DETECTED;
        }
    }
    return ASLOOP_NO_DETECTED;
}

unsigned int inet::bgp::BGPRouting::calculateStartDelay ( int  rtListSize, unsigned char  rtPosition, unsigned char  rtPeerPosition  )

private

Referenced by loadConfigFromXML().

{
    unsigned int startDelay = 0;
    if (rtPeerPosition == 1) {
        if (rtPosition == 1) {
            startDelay = 1;
        }
        else {
            startDelay = (rtPosition - 1) * 2;
        }
        return startDelay;
    }

    if (rtPosition < rtPeerPosition) {
        startDelay = 2;
    }
    else if (rtPosition > rtPeerPosition) {
        startDelay = (rtListSize - 1) * 2 - 2 * (rtPeerPosition - 2);
    }
    else {
        startDelay = (rtListSize - 1) * 2 + 1;
    }
    return startDelay;
}

bool inet::bgp::BGPRouting::checkExternalRoute ( const IPv4Route *  ospfRoute )

protected

check if the route is in OSPF external IPv4RoutingTable

Returns

true if it is, false else

Referenced by inet::bgp::BGPSession::checkExternalRoute().

{
    IPv4Address OSPFRoute;
    OSPFRoute = route->getDestination();
    ospf::OSPFRouting *ospf = getModuleFromPar<ospf::OSPFRouting>(par("ospfRoutingModule"), this);
    bool returnValue = ospf->checkExternalRoute(OSPFRoute);
    return returnValue;
}

SessionID inet::bgp::BGPRouting::createSession ( BGPSessionType  typeSession, const char *  peerAddr  )

private

Referenced by loadConfigFromXML(), and loadSessionConfig().

{
    BGPSession *newSession = new BGPSession(*this);
    SessionID newSessionId;
    SessionInfo info;

    info.sessionType = typeSession;
    info.ASValue = _myAS;
    info.routerID = _rt->getRouterId();
    info.peerAddr.set(peerAddr);
    if (typeSession == EGP) {
        info.linkIntf = _rt->getInterfaceForDestAddr(info.peerAddr);
        if (info.linkIntf == nullptr) {
            throw cRuntimeError("BGP Error: No configuration interface for peer address: %s", peerAddr);
        }
        info.sessionID = info.peerAddr.getInt() + info.linkIntf->ipv4Data()->getIPAddress().getInt();
    }
    else {
        info.sessionID = info.peerAddr.getInt() + info.routerID.getInt();
    }
    newSessionId = info.sessionID;
    newSession->setInfo(info);
    _BGPSessions[newSessionId] = newSession;

    return newSessionId;
}

unsigned char inet::bgp::BGPRouting::decisionProcess ( const BGPUpdateMessage &  msg, RoutingTableEntry *  entry, SessionID  sessionIndex  )

private

RFC 4271: 9.1.

: Decision Process used when an UPDATE message is received As matches, routes are sent or not to UpdateSentProcess The result can be ROUTE_DESTINATION_CHANGED, NEW_ROUTE_ADDED or 0 if no routingTable modification

Referenced by processMessage().

{
    //Don't add the route if it exists in PrefixListINTable or in ASListINTable
    if (isInTable(_prefixListIN, entry) != (unsigned long)-1 || isInASList(_ASListIN, entry)) {
        delete entry;
        return 0;
    }

    /*If the AS_PATH attribute of a BGP route contains an AS loop, the BGP
       route should be excluded from the decision process. */
    entry->setPathType(msg.getPathAttributeList(0).getOrigin().getValue());
    entry->setGateway(msg.getPathAttributeList(0).getNextHop().getValue());

    //if the route already exist in BGP routing table, tieBreakingProcess();
    //(RFC 4271: 9.1.2.2 Breaking Ties)
    unsigned long BGPindex = isInTable(_BGPRoutingTable, entry);
    if (BGPindex != (unsigned long)-1) {
        if (tieBreakingProcess(_BGPRoutingTable[BGPindex], entry)) {
            delete entry;
            return 0;
        }
        else {
            entry->setInterface(_BGPSessions[sessionIndex]->getLinkIntf());
            _BGPRoutingTable.push_back(entry);
            _rt->addRoute(entry);
            return ROUTE_DESTINATION_CHANGED;
        }
    }

    //Don't add the route if it exists in IPv4 routing table except if the msg come from IGP session
    int indexIP = isInRoutingTable(_rt, entry->getDestination());
    if (indexIP != -1 && _rt->getRoute(indexIP)->getSourceType() != IRoute::BGP) {
        if (_BGPSessions[sessionIndex]->getType() != IGP) {
            delete entry;
            return 0;
        }
        else {
            IPv4Route *oldEntry = _rt->getRoute(indexIP);
            IPv4Route *newEntry = new IPv4Route;
            newEntry->setDestination(oldEntry->getDestination());
            newEntry->setNetmask(oldEntry->getNetmask());
            newEntry->setGateway(oldEntry->getGateway());
            newEntry->setInterface(oldEntry->getInterface());
            newEntry->setSourceType(IRoute::BGP);
            _rt->deleteRoute(oldEntry);
            _rt->addRoute(newEntry);
            //FIXME model error: the RoutingTableEntry *entry will be stored in _BGPRoutingTable, but not stored in _rt, memory leak
            //FIXME model error: The entry inserted to _BGPRoutingTable, but newEntry inserted to _rt; entry and newEntry are differ.
        }
    }

    entry->setInterface(_BGPSessions[sessionIndex]->getLinkIntf());
    _BGPRoutingTable.push_back(entry);

    if (_BGPSessions[sessionIndex]->getType() == EGP) {
        std::string entryh = entry->getDestination().str();
        std::string entryn = entry->getNetmask().str();
        _rt->addRoute(entry);
        //insertExternalRoute on OSPF ExternalRoutingTable if OSPF exist on this BGP router
        if (ospfExist(_rt)) {
            ospf::IPv4AddressRange OSPFnetAddr;
            OSPFnetAddr.address = entry->getDestination();
            OSPFnetAddr.mask = entry->getNetmask();
            ospf::OSPFRouting *ospf = getModuleFromPar<ospf::OSPFRouting>(par("ospfRoutingModule"), this);
            InterfaceEntry *ie = entry->getInterface();
            if (!ie)
                throw cRuntimeError("Model error: interface entry is nullptr");
            ospf->insertExternalRoute(ie->getInterfaceId(), OSPFnetAddr);
        }
    }
    return NEW_ROUTE_ADDED;     //FIXME model error: When returns NEW_ROUTE_ADDED then entry stored in _BGPRoutingTable, but sometimes not stored in _rt
}

bool inet::bgp::BGPRouting::deleteBGPRoutingEntry ( RoutingTableEntry *  entry )

private

Referenced by tieBreakingProcess().

{
    for (auto it = _BGPRoutingTable.begin();
         it != _BGPRoutingTable.end(); it++)
    {
        if (((*it)->getDestination().getInt() & (*it)->getNetmask().getInt()) ==
            (entry->getDestination().getInt() & entry->getNetmask().getInt()))
        {
            _BGPRoutingTable.erase(it);
            _rt->deleteRoute(entry);
            return true;
        }
    }
    return false;
}

SessionID inet::bgp::BGPRouting::findIdFromPeerAddr ( std::map< SessionID, BGPSession * >  sessions, IPv4Address  peerAddr  )

private

Referenced by processMessageFromTCP().

{
    for (auto & session : sessions)
    {
        if ((session).second->getPeerAddr().equals(peerAddr)) {
            return (session).first;
        }
    }
    return -1;
}

SessionID inet::bgp::BGPRouting::findIdFromSocketConnId ( std::map< SessionID, BGPSession * >  sessions, int  connId  )

private

Referenced by socketDataArrived(), socketEstablished(), and socketFailure().

{
    for (auto & session : sessions)
    {
        TCPSocket *socket = (session).second->getSocket();
        if (socket->getConnectionId() == connId) {
            return (session).first;
        }
    }
    return -1;
}

ASID inet::bgp::BGPRouting::findMyAS ( cXMLElementList &  ASList, int &  outRouterPosition  )

private

Referenced by loadConfigFromXML().

{
    // find my own IPv4 address in the configuration file and return the AS id under which it is configured
    // and also the 1 based position of the entry inside the AS config element
    for (auto & elem : asList) {
        cXMLElementList routerList = (elem)->getChildrenByTagName("Router");
        outRouterPosition = 1;
        for (auto & routerList_routerListIt : routerList) {
            IPv4Address routerAddr = IPv4Address((routerList_routerListIt)->getAttribute("interAddr"));
            for (int i = 0; i < _inft->getNumInterfaces(); i++) {
                if (_inft->getInterface(i)->ipv4Data()->getIPAddress() == routerAddr)
                    return atoi((routerList_routerListIt)->getParentNode()->getAttribute("id"));
            }
            outRouterPosition++;
        }
    }

    return 0;
}

SessionID inet::bgp::BGPRouting::findNextSession ( BGPSessionType  type, bool  startSession = false  )

protected

find the next SessionID compared to his type and start this session if boolean is true

Referenced by inet::bgp::BGPSession::findAndStartNextSession(), and socketEstablished().

{
    SessionID sessionID = -1;
    for (auto & elem : _BGPSessions)
    {
        if ((elem).second->getType() == type && !(elem).second->isEstablished()) {
            sessionID = (elem).first;
            break;
        }
    }
    if (startSession == true && type == IGP && sessionID != (SessionID)-1) {
        InterfaceEntry *linkIntf = _rt->getInterfaceForDestAddr(_BGPSessions[sessionID]->getPeerAddr());
        if (linkIntf == nullptr) {
            throw cRuntimeError("No configuration interface for peer address: %s", _BGPSessions[sessionID]->getPeerAddr().str().c_str());
        }
        _BGPSessions[sessionID]->setlinkIntf(linkIntf);
        _BGPSessions[sessionID]->startConnection();
    }
    return sessionID;
}

void inet::bgp::BGPRouting::finish ( )

overrideprotectedvirtual

{
    unsigned int statTab[NB_STATS] = {
        0, 0, 0, 0, 0, 0
    };
    for (auto & elem : _BGPSessions) {
        (elem).second->getStatistics(statTab);
    }
    recordScalar("OPENMsgSent", statTab[0]);
    recordScalar("OPENMsgRecv", statTab[1]);
    recordScalar("KeepAliveMsgSent", statTab[2]);
    recordScalar("KeepAliveMsgRcv", statTab[3]);
    recordScalar("UpdateMsgSent", statTab[4]);
    recordScalar("UpdateMsgRcv", statTab[5]);
}

std::vector<RoutingTableEntry *> inet::bgp::BGPRouting::getBGPRoutingTable ( )

inlineprotected

Referenced by inet::bgp::BGPSession::getBGPRoutingTable().

{ return _BGPRoutingTable; }

void inet::bgp::BGPRouting::getCancelAndDelete ( cMessage *  msg )

inlineprotected

Referenced by inet::bgp::BGPSession::~BGPSession().

{ return cancelAndDelete(msg); }

cMessage* inet::bgp::BGPRouting::getCancelEvent ( cMessage *  msg )

inlineprotected

Referenced by inet::bgp::BGPSession::restartsConnectRetryTimer(), inet::bgp::BGPSession::restartsHoldTimer(), and inet::bgp::BGPSession::restartsKeepAliveTimer().

{ return cancelEvent(msg); }

cGate* inet::bgp::BGPRouting::getGate ( const char *  gateName )

inlineprotected

{ return gate(gateName); }

IIPv4RoutingTable* inet::bgp::BGPRouting::getIPRoutingTable ( )

inlineprotected

Referenced by inet::bgp::BGPSession::getIPRoutingTable().

{ return _rt; }

void inet::bgp::BGPRouting::getScheduleAt ( simtime_t  t, cMessage *  msg  )

inlineprotected

Referenced by inet::bgp::BGPSession::restartsConnectRetryTimer(), inet::bgp::BGPSession::restartsHoldTimer(), inet::bgp::BGPSession::restartsKeepAliveTimer(), inet::bgp::BGPSession::setTimers(), and inet::bgp::BGPSession::startConnection().

{ scheduleAt(t, msg); }

simtime_t inet::bgp::BGPRouting::getSimTime ( )

inlineprotected

Referenced by inet::bgp::BGPSession::restartsConnectRetryTimer(), inet::bgp::BGPSession::restartsHoldTimer(), inet::bgp::BGPSession::restartsKeepAliveTimer(), inet::bgp::BGPSession::setTimers(), and inet::bgp::BGPSession::startConnection().

{ return simTime(); }

void inet::bgp::BGPRouting::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (msg->isSelfMessage()) {    //BGP level
        handleTimer(msg);
    }
    else if (!strcmp(msg->getArrivalGate()->getName(), "tcpIn")) {    //TCP level
        processMessageFromTCP(msg);
    }
    else {
        delete msg;
    }
}

bool inet::bgp::BGPRouting::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

{
    throw cRuntimeError("Lifecycle operation support not implemented");
}

void inet::bgp::BGPRouting::handleTimer ( cMessage *  timer )

private

Referenced by handleMessage().

{
    BGPSession *pSession = (BGPSession *)timer->getContextPointer();
    if (pSession) {
        switch (timer->getKind()) {
            case START_EVENT_KIND:
                EV_INFO << "Processing Start Event" << std::endl;
                pSession->getFSM()->ManualStart();
                break;

            case CONNECT_RETRY_KIND:
                EV_INFO << "Expiring Connect Retry Timer" << std::endl;
                pSession->getFSM()->ConnectRetryTimer_Expires();
                break;

            case HOLD_TIME_KIND:
                EV_INFO << "Expiring Hold Timer" << std::endl;
                pSession->getFSM()->HoldTimer_Expires();
                break;

            case KEEP_ALIVE_KIND:
                EV_INFO << "Expiring Keep Alive timer" << std::endl;
                pSession->getFSM()->KeepaliveTimer_Expires();
                break;

            default:
                throw cRuntimeError("Invalid timer kind %d", timer->getKind());
        }
    }
}

void inet::bgp::BGPRouting::initialize ( int  stage )

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        bool isOperational;
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");

        // we must wait until IPv4RoutingTable is completely initialized
        _rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        _inft = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);

        // read BGP configuration
        cXMLElement *bgpConfig = par("bgpConfig").xmlValue();
        loadConfigFromXML(bgpConfig);
        createWatch("myAutonomousSystem", _myAS);
        WATCH_PTRVECTOR(_BGPRoutingTable);
    }
}

bool inet::bgp::BGPRouting::isInASList ( std::vector< ASID >  ASList, RoutingTableEntry *  entry  )

private

Referenced by decisionProcess(), and updateSendProcess().

{
    for (auto & elem : ASList) {
        for (unsigned int i = 0; i < entry->getASCount(); i++) {
            if ((elem) == entry->getAS(i)) {
                return true;
            }
        }
    }
    return false;
}

int inet::bgp::BGPRouting::isInInterfaceTable ( IInterfaceTable *  rtTable, IPv4Address  addr  )

private

Referenced by loadASConfig(), and loadSessionConfig().

{
    for (int i = 0; i < ifTable->getNumInterfaces(); i++) {
        if (ifTable->getInterface(i)->ipv4Data()->getIPAddress() == addr) {
            return i;
        }
    }
    return -1;
}

int inet::bgp::BGPRouting::isInRoutingTable ( IIPv4RoutingTable *  rtTable, IPv4Address  addr  )

private

Referenced by decisionProcess().

{
    for (int i = 0; i < rtTable->getNumRoutes(); i++) {
        const IPv4Route *entry = rtTable->getRoute(i);
        if (IPv4Address::maskedAddrAreEqual(addr, entry->getDestination(), entry->getNetmask())) {
            return i;
        }
    }
    return -1;
}

unsigned long inet::bgp::BGPRouting::isInTable ( std::vector< RoutingTableEntry * >  rtTable, RoutingTableEntry *  entry  )

private

Referenced by decisionProcess(), and updateSendProcess().

{
    for (unsigned long i = 0; i < rtTable.size(); i++) {
        RoutingTableEntry *entryCur = rtTable[i];
        if ((entry->getDestination().getInt() & entry->getNetmask().getInt()) ==
            (entryCur->getDestination().getInt() & entryCur->getNetmask().getInt()))
        {
            return i;
        }
    }
    return -1;
}

void inet::bgp::BGPRouting::listenConnectionFromPeer ( SessionID  sessionID )

protected

active listenSocket for a given session (used by fsm)

Referenced by inet::bgp::BGPSession::listenConnectionFromPeer().

{
    if (_BGPSessions[sessionID]->getSocketListen()->getState() == TCPSocket::CLOSED) {
        //session StartDelayTime error, it's anormal that listenSocket is closed.
        _socketMap.removeSocket(_BGPSessions[sessionID]->getSocketListen());
        _BGPSessions[sessionID]->getSocketListen()->abort();
        _BGPSessions[sessionID]->getSocketListen()->renewSocket();
    }
    if (_BGPSessions[sessionID]->getSocketListen()->getState() != TCPSocket::LISTENING) {
        _BGPSessions[sessionID]->getSocketListen()->setOutputGate(gate("tcpOut"));
        _BGPSessions[sessionID]->getSocketListen()->readDataTransferModePar(*this);
        _BGPSessions[sessionID]->getSocketListen()->bind(TCP_PORT);
        _BGPSessions[sessionID]->getSocketListen()->listen();
    }
}

std::vector< const char * > inet::bgp::BGPRouting::loadASConfig ( cXMLElementList &  ASConfig )

private

Referenced by loadConfigFromXML().

{
    //create deny Lists
    std::vector<const char *> routerInSameASList;

    for (auto & elem : ASConfig) {
        std::string nodeName = (elem)->getTagName();
        if (nodeName == "Router") {
            if (isInInterfaceTable(_inft, IPv4Address((elem)->getAttribute("interAddr"))) == -1) {
                routerInSameASList.push_back((elem)->getAttribute("interAddr"));
            }
            continue;
        }
        if (nodeName == "DenyRoute" || nodeName == "DenyRouteIN" || nodeName == "DenyRouteOUT") {
            RoutingTableEntry *entry = new RoutingTableEntry();     //FIXME Who will delete this entry?
            entry->setDestination(IPv4Address((elem)->getAttribute("Address")));
            entry->setNetmask(IPv4Address((elem)->getAttribute("Netmask")));
            if (nodeName == "DenyRouteIN") {
                _prefixListIN.push_back(entry);
                _prefixListINOUT.push_back(entry);
            }
            else if (nodeName == "DenyRouteOUT") {
                _prefixListOUT.push_back(entry);
                _prefixListINOUT.push_back(entry);
            }
            else {
                _prefixListIN.push_back(entry);
                _prefixListOUT.push_back(entry);
                _prefixListINOUT.push_back(entry);
            }
        }
        else if (nodeName == "DenyAS" || nodeName == "DenyASIN" || nodeName == "DenyASOUT") {
            ASID ASCur = atoi((elem)->getNodeValue());
            if (nodeName == "DenyASIN") {
                _ASListIN.push_back(ASCur);
            }
            else if (nodeName == "DenyASOUT") {
                _ASListOUT.push_back(ASCur);
            }
            else {
                _ASListIN.push_back(ASCur);
                _ASListOUT.push_back(ASCur);
            }
        }
        else {
            throw cRuntimeError("BGP Error: unknown element named '%s' for AS %u", nodeName.c_str(), _myAS);
        }
    }
    return routerInSameASList;
}

void inet::bgp::BGPRouting::loadConfigFromXML ( cXMLElement *  bgpConfig )

private

Referenced by initialize().

{
    if (strcmp(bgpConfig->getTagName(), "BGPConfig"))
        throw cRuntimeError("Cannot read BGP configuration, unaccepted '%s' node at %s", bgpConfig->getTagName(), bgpConfig->getSourceLocation());

    // load bgp timer parameters informations
    simtime_t delayTab[NB_TIMERS];
    cXMLElement *paramNode = bgpConfig->getElementByPath("TimerParams");
    if (paramNode == nullptr)
        throw cRuntimeError("BGP Error: No configuration for BGP timer parameters");

    cXMLElementList timerConfig = paramNode->getChildren();
    loadTimerConfig(timerConfig, delayTab);

    //find my AS
    cXMLElementList ASList = bgpConfig->getElementsByTagName("AS");
    int routerPosition;
    _myAS = findMyAS(ASList, routerPosition);
    if (_myAS == 0)
        throw cRuntimeError("BGP Error:  No AS configuration for Router ID: %s", _rt->getRouterId().str().c_str());

    // load EGP Session informations
    cXMLElementList sessionList = bgpConfig->getElementsByTagName("Session");
    simtime_t saveStartDelay = delayTab[3];
    loadSessionConfig(sessionList, delayTab);
    delayTab[3] = saveStartDelay;

    // load AS information
    char ASXPath[32];
    sprintf(ASXPath, "AS[@id='%d']", _myAS);

    cXMLElement *ASNode = bgpConfig->getElementByPath(ASXPath);
    std::vector<const char *> routerInSameASList;
    if (ASNode == nullptr)
        throw cRuntimeError("BGP Error:  No configuration for AS ID: %d", _myAS);

    cXMLElementList ASConfig = ASNode->getChildren();
    routerInSameASList = loadASConfig(ASConfig);

    //create IGP Session(s)
    if (routerInSameASList.size()) {
        unsigned int routerPeerPosition = 1;
        delayTab[3] += sessionList.size() * 2;
        for (auto it = routerInSameASList.begin(); it != routerInSameASList.end(); it++, routerPeerPosition++) {
            SessionID newSessionID;
            TCPSocket *socketListenIGP = new TCPSocket();
            newSessionID = createSession(IGP, (*it));
            delayTab[3] += calculateStartDelay(routerInSameASList.size(), routerPosition, routerPeerPosition);
            _BGPSessions[newSessionID]->setTimers(delayTab);
            _BGPSessions[newSessionID]->setSocketListen(socketListenIGP);
        }
    }
}

void inet::bgp::BGPRouting::loadSessionConfig ( cXMLElementList &  sessionList, simtime_t *  delayTab  )

private

Referenced by loadConfigFromXML().

{
    simtime_t saveStartDelay = delayTab[3];
    for (auto sessionListIt = sessionList.begin(); sessionListIt != sessionList.end(); sessionListIt++, delayTab[3] = saveStartDelay) {
        const char *exterAddr = (*sessionListIt)->getFirstChild()->getAttribute("exterAddr");
        IPv4Address routerAddr1 = IPv4Address(exterAddr);
        exterAddr = (*sessionListIt)->getLastChild()->getAttribute("exterAddr");
        IPv4Address routerAddr2 = IPv4Address(exterAddr);
        if (isInInterfaceTable(_inft, routerAddr1) == -1 && isInInterfaceTable(_inft, routerAddr2) == -1) {
            continue;
        }
        IPv4Address peerAddr;
        if (isInInterfaceTable(_inft, routerAddr1) != -1) {
            peerAddr = routerAddr2;
            delayTab[3] += atoi((*sessionListIt)->getAttribute("id"));
        }
        else {
            peerAddr = routerAddr1;
            delayTab[3] += atoi((*sessionListIt)->getAttribute("id")) + 0.5;
        }
        if (peerAddr.isUnspecified()) {
            throw cRuntimeError("BGP Error: No valid external address for session ID : %s", (*sessionListIt)->getAttribute("id"));
        }

        SessionID newSessionID = createSession(EGP, peerAddr.str().c_str());
        _BGPSessions[newSessionID]->setTimers(delayTab);
        TCPSocket *socketListenEGP = new TCPSocket();
        _BGPSessions[newSessionID]->setSocketListen(socketListenEGP);
    }
}

void inet::bgp::BGPRouting::loadTimerConfig ( cXMLElementList &  timerConfig, simtime_t *  delayTab  )

private

Referenced by loadConfigFromXML().

{
    for (auto & elem : timerConfig) {
        std::string nodeName = (elem)->getTagName();
        if (nodeName == "connectRetryTime") {
            delayTab[0] = (double)atoi((elem)->getNodeValue());
        }
        else if (nodeName == "holdTime") {
            delayTab[1] = (double)atoi((elem)->getNodeValue());
        }
        else if (nodeName == "keepAliveTime") {
            delayTab[2] = (double)atoi((elem)->getNodeValue());
        }
        else if (nodeName == "startDelay") {
            delayTab[3] = (double)atoi((elem)->getNodeValue());
        }
    }
}

virtual int inet::bgp::BGPRouting::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::bgp::BGPRouting::openTCPConnectionToPeer ( SessionID  sessionID )

protected

active TCPConnection for a given session (used by fsm)

Referenced by inet::bgp::BGPSession::openTCPConnectionToPeer().

{
    InterfaceEntry *intfEntry = _BGPSessions[sessionID]->getLinkIntf();
    TCPSocket *socket = _BGPSessions[sessionID]->getSocket();
    if (socket->getState() != TCPSocket::NOT_BOUND) {
        _socketMap.removeSocket(socket);
        socket->abort();
        socket->renewSocket();
    }
    socket->setCallbackObject(this, (void *)sessionID);
    socket->setOutputGate(gate("tcpOut"));
    socket->readDataTransferModePar(*this);
    socket->bind(intfEntry->ipv4Data()->getIPAddress(), 0);
    _socketMap.addSocket(socket);

    socket->connect(_BGPSessions[sessionID]->getPeerAddr(), TCP_PORT);
}

bool inet::bgp::BGPRouting::ospfExist ( IIPv4RoutingTable *  rtTable )

private

Referenced by decisionProcess().

{
    for (int i = 0; i < rtTable->getNumRoutes(); i++) {
        if (rtTable->getRoute(i)->getSourceType() == IRoute::OSPF) {
            return true;
        }
    }
    return false;
}

void inet::bgp::BGPRouting::processMessage ( const BGPOpenMessage &  msg )

private

Referenced by socketDataArrived().

{
    EV_INFO << "Processing BGP OPEN message" << std::endl;
    _BGPSessions[_currSessionId]->getFSM()->OpenMsgEvent();
}

void inet::bgp::BGPRouting::processMessage ( const BGPKeepAliveMessage &  msg )

private

{
    EV_INFO << "Processing BGP Keep Alive message" << std::endl;
    _BGPSessions[_currSessionId]->getFSM()->KeepAliveMsgEvent();
}

void inet::bgp::BGPRouting::processMessage ( const BGPUpdateMessage &  msg )

private

{
    EV_INFO << "Processing BGP Update message" << std::endl;
    _BGPSessions[_currSessionId]->getFSM()->UpdateMsgEvent();

    unsigned char decisionProcessResult;
    IPv4Address netMask(IPv4Address::ALLONES_ADDRESS);
    RoutingTableEntry *entry = new RoutingTableEntry();
    const unsigned char length = msg.getNLRI().length;
    unsigned int ASValueCount = msg.getPathAttributeList(0).getAsPath(0).getValue(0).getAsValueArraySize();

    entry->setDestination(msg.getNLRI().prefix);
    netMask = IPv4Address::makeNetmask(length);
    entry->setNetmask(netMask);
    for (unsigned int j = 0; j < ASValueCount; j++) {
        entry->addAS(msg.getPathAttributeList(0).getAsPath(0).getValue(0).getAsValue(j));
    }

    decisionProcessResult = asLoopDetection(entry, _myAS);

    if (decisionProcessResult == ASLOOP_NO_DETECTED) {
        // RFC 4271, 9.1.  Decision Process
        decisionProcessResult = decisionProcess(msg, entry, _currSessionId);
        //RFC 4271, 9.2.  Update-Send Process
        if (decisionProcessResult != 0)
            updateSendProcess(decisionProcessResult, _currSessionId, entry);
    }
    else
        delete entry;
}

void inet::bgp::BGPRouting::processMessageFromTCP ( cMessage *  msg )

private

Referenced by handleMessage().

{
    TCPSocket *socket = _socketMap.findSocketFor(msg);
    if (!socket) {
        socket = new TCPSocket(msg);
        socket->readDataTransferModePar(*this);
        socket->setOutputGate(gate("tcpOut"));
        IPv4Address peerAddr = socket->getRemoteAddress().toIPv4();
        SessionID i = findIdFromPeerAddr(_BGPSessions, peerAddr);
        if (i == (SessionID)-1) {
            socket->close();
            delete socket;
            delete msg;
            return;
        }
        socket->setCallbackObject(this, (void *)i);

        _socketMap.addSocket(socket);
        _BGPSessions[i]->getSocket()->abort();
        _BGPSessions[i]->setSocket(socket);
    }

    socket->processMessage(msg);
}

virtual void inet::bgp::BGPRouting::socketClosed ( int  connId, void *  yourPtr  )

inlineoverrideprotectedvirtual

Reimplemented from inet::TCPSocket::CallbackInterface.

{}

void inet::bgp::BGPRouting::socketDataArrived ( int  connId, void *  yourPtr, cPacket *  msg, bool  urgent  )

overrideprotectedvirtual

Implements inet::TCPSocket::CallbackInterface.

{
    _currSessionId = findIdFromSocketConnId(_BGPSessions, connId);
    if (_currSessionId != (SessionID)-1) {
        BGPHeader *ptrHdr = check_and_cast<BGPHeader *>(msg);
        switch (ptrHdr->getType()) {
            case BGP_OPEN:
                //BGPOpenMessage* ptrMsg = check_and_cast<BGPOpenMessage*>(msg);
                processMessage(*check_and_cast<BGPOpenMessage *>(msg));
                break;

            case BGP_KEEPALIVE:
                processMessage(*check_and_cast<BGPKeepAliveMessage *>(msg));
                break;

            case BGP_UPDATE:
                processMessage(*check_and_cast<BGPUpdateMessage *>(msg));
                break;

            default:
                throw cRuntimeError("Invalid BGP message type %d", ptrHdr->getType());
        }
    }
    delete msg;
}

void inet::bgp::BGPRouting::socketEstablished ( int  connId, void *  yourPtr  )

overrideprotectedvirtual

Reimplemented from inet::TCPSocket::CallbackInterface.

{
    _currSessionId = findIdFromSocketConnId(_BGPSessions, connId);
    if (_currSessionId == (SessionID)-1) {
        throw cRuntimeError("socket id=%d is not established", connId);
    }

    //if it's an IGP Session, TCPConnectionConfirmed only if all EGP Sessions established
    if (_BGPSessions[_currSessionId]->getType() == IGP &&
        this->findNextSession(EGP) != (SessionID)-1)
    {
        _BGPSessions[_currSessionId]->getFSM()->TcpConnectionFails();
    }
    else {
        _BGPSessions[_currSessionId]->getFSM()->TcpConnectionConfirmed();
        _BGPSessions[_currSessionId]->getSocketListen()->abort();
    }

    if (_BGPSessions[_currSessionId]->getSocketListen()->getConnectionId() != connId &&
        _BGPSessions[_currSessionId]->getType() == EGP &&
        this->findNextSession(EGP) != (SessionID)-1)
    {
        _BGPSessions[_currSessionId]->getSocketListen()->abort();
    }
}

void inet::bgp::BGPRouting::socketFailure ( int  connId, void *  yourPtr, int  code  )

overrideprotectedvirtual

Reimplemented from inet::TCPSocket::CallbackInterface.

{
    _currSessionId = findIdFromSocketConnId(_BGPSessions, connId);
    if (_currSessionId != (SessionID)-1) {
        _BGPSessions[_currSessionId]->getFSM()->TcpConnectionFails();
    }
}

virtual void inet::bgp::BGPRouting::socketPeerClosed ( int  connId, void *  yourPtr  )

inlineoverrideprotectedvirtual

Reimplemented from inet::TCPSocket::CallbackInterface.

{}

bool inet::bgp::BGPRouting::tieBreakingProcess ( RoutingTableEntry *  oldEntry, RoutingTableEntry *  entry  )

private

RFC 4271: 9.1.2.2 Breaking Ties used when BGP speaker may have several routes to the same destination that have the same degree of preference.

Returns

bool, true if this process changed the route, false else

Referenced by decisionProcess().

{
    /*a) Remove from consideration all routes that are not tied for
         having the smallest number of AS numbers present in their
         AS_PATH attributes.*/
    if (entry->getASCount() < oldEntry->getASCount()) {
        deleteBGPRoutingEntry(oldEntry);
        return false;
    }

    /* b) Remove from consideration all routes that are not tied for
         having the lowest Origin number in their Origin attribute.*/
    if (entry->getPathType() < oldEntry->getPathType()) {
        deleteBGPRoutingEntry(oldEntry);
        return false;
    }
    return true;
}

void inet::bgp::BGPRouting::updateSendProcess ( const unsigned char  decisionProcessResult, SessionID  sessionIndex, RoutingTableEntry *  entry  )

protected

RFC 4271, 9.2 : Update-Send Process / Sent or not new UPDATE messages to its peers.

Referenced by processMessage(), and inet::bgp::BGPSession::updateSendProcess().

{
    //Don't send the update Message if the route exists in listOUTTable
    //SESSION = EGP : send an update message to all BGP Peer (EGP && IGP)
    //if it is not the currentSession and if the session is already established
    //SESSION = IGP : send an update message to External BGP Peer (EGP) only
    //if it is not the currentSession and if the session is already established
    for (auto & elem : _BGPSessions)
    {
        if (isInTable(_prefixListOUT, entry) != (unsigned long)-1 || isInASList(_ASListOUT, entry) ||
            ((elem).first == sessionIndex && type != NEW_SESSION_ESTABLISHED) ||
            (type == NEW_SESSION_ESTABLISHED && (elem).first != sessionIndex) ||
            !(elem).second->isEstablished())
        {
            continue;
        }
        if ((_BGPSessions[sessionIndex]->getType() == IGP && (elem).second->getType() == EGP) ||
            _BGPSessions[sessionIndex]->getType() == EGP ||
            type == ROUTE_DESTINATION_CHANGED ||
            type == NEW_SESSION_ESTABLISHED)
        {
            BGPUpdateNLRI NLRI;
            BGPUpdatePathAttributeList content;

            unsigned int nbAS = entry->getASCount();
            content.setAsPathArraySize(1);
            content.getAsPath(0).setValueArraySize(1);
            content.getAsPath(0).getValue(0).setType(AS_SEQUENCE);
            //RFC 4271 : set My AS in first position if it is not already
            if (entry->getAS(0) != _myAS) {
                content.getAsPath(0).getValue(0).setAsValueArraySize(nbAS + 1);
                content.getAsPath(0).getValue(0).setLength(1);
                content.getAsPath(0).getValue(0).setAsValue(0, _myAS);
                for (unsigned int j = 1; j < nbAS + 1; j++) {
                    content.getAsPath(0).getValue(0).setAsValue(j, entry->getAS(j - 1));
                }
            }
            else {
                content.getAsPath(0).getValue(0).setAsValueArraySize(nbAS);
                content.getAsPath(0).getValue(0).setLength(1);
                for (unsigned int j = 0; j < nbAS; j++) {
                    content.getAsPath(0).getValue(0).setAsValue(j, entry->getAS(j));
                }
            }

            InterfaceEntry *iftEntry = (elem).second->getLinkIntf();
            content.getOrigin().setValue((elem).second->getType());
            content.getNextHop().setValue(iftEntry->ipv4Data()->getIPAddress());
            IPv4Address netMask = entry->getNetmask();
            NLRI.prefix = entry->getDestination().doAnd(netMask);
            NLRI.length = (unsigned char)netMask.getNetmaskLength();
            {
                BGPUpdateMessage *updateMsg = new BGPUpdateMessage("BGPUpdate");
                updateMsg->setPathAttributeListArraySize(1);
                updateMsg->setPathAttributeList(content);
                updateMsg->setNLRI(NLRI);
                (elem).second->getSocket()->send(updateMsg);
                (elem).second->addUpdateMsgSent();
            }
        }
    }
}

Friends And Related Function Documentation

friend class BGPSession

friend

Referenced by createSession().

Member Data Documentation

std::vector<ASID> inet::bgp::BGPRouting::_ASListIN

private

Referenced by decisionProcess(), and loadASConfig().

std::vector<ASID> inet::bgp::BGPRouting::_ASListOUT

private

Referenced by loadASConfig(), and updateSendProcess().

RoutingTableEntryVector inet::bgp::BGPRouting::_BGPRoutingTable

private

Referenced by decisionProcess(), deleteBGPRoutingEntry(), and initialize().

std::map<SessionID, BGPSession *> inet::bgp::BGPRouting::_BGPSessions

private

Referenced by createSession(), decisionProcess(), findNextSession(), finish(), listenConnectionFromPeer(), loadConfigFromXML(), loadSessionConfig(), openTCPConnectionToPeer(), processMessage(), processMessageFromTCP(), socketDataArrived(), socketEstablished(), socketFailure(), updateSendProcess(), and ~BGPRouting().

SessionID inet::bgp::BGPRouting::_currSessionId = 0

private

Referenced by processMessage(), socketDataArrived(), socketEstablished(), and socketFailure().

IInterfaceTable* inet::bgp::BGPRouting::_inft = nullptr

private

Referenced by findMyAS(), initialize(), loadASConfig(), and loadSessionConfig().

ASID inet::bgp::BGPRouting::_myAS = 0

private

Referenced by createSession(), initialize(), loadASConfig(), loadConfigFromXML(), processMessage(), and updateSendProcess().

RoutingTableEntryVector inet::bgp::BGPRouting::_prefixListIN

private

Referenced by decisionProcess(), and loadASConfig().

RoutingTableEntryVector inet::bgp::BGPRouting::_prefixListINOUT

private

Referenced by loadASConfig(), and ~BGPRouting().

RoutingTableEntryVector inet::bgp::BGPRouting::_prefixListOUT

private

Referenced by loadASConfig(), and updateSendProcess().

IIPv4RoutingTable* inet::bgp::BGPRouting::_rt = nullptr

private

Referenced by createSession(), decisionProcess(), deleteBGPRoutingEntry(), findNextSession(), initialize(), and loadConfigFromXML().

TCPSocketMap inet::bgp::BGPRouting::_socketMap

private

Referenced by listenConnectionFromPeer(), openTCPConnectionToPeer(), and processMessageFromTCP().

const int inet::bgp::BGPRouting::BGP_TCP_CONNECT_CONFIRM = 72

staticprivate

const int inet::bgp::BGPRouting::BGP_TCP_CONNECT_FAILED = 73

staticprivate

const int inet::bgp::BGPRouting::BGP_TCP_CONNECT_OPEN_RCV = 74

staticprivate

const int inet::bgp::BGPRouting::BGP_TCP_CONNECT_VALID = 71

staticprivate

const int inet::bgp::BGPRouting::BGP_TCP_KEEP_ALIVE_RCV = 75

staticprivate

---

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

• BGPRouting.h
• BGPRouting.cc