inet::bgp::BgpSession Class Reference

#include <BgpSession.h>

Inheritance diagram for inet::bgp::BgpSession:

Public Member Functions
	BgpSession (BgpRouter &bgpRouter)
virtual	~BgpSession ()
void	startConnection ()
void	restartsHoldTimer ()
void	restartsKeepAliveTimer ()
void	restartsConnectRetryTimer (bool start=true)
void	sendOpenMessage ()
void	sendUpdateMessage (std::vector< BgpUpdatePathAttributes * > &content, BgpUpdateNlri &NLRI)
void	sendNotificationMessage ()
void	sendKeepAliveMessage ()
void	listenConnectionFromPeer ()
void	openTCPConnectionToPeer ()
SessionId	findAndStartNextSession (BgpSessionType type)
void	setInfo (SessionInfo info)
void	setTimers (simtime_t *delayTab)
void	setlinkIntf (NetworkInterface *intf)
void	setNextHopSelf (bool nextHopSelf)
void	setLocalPreference (int localPreference)
void	setSocket (TcpSocket *socket)
void	setSocketListen (TcpSocket *socket)
simtime_t	getStartEventTime () const
simtime_t	getConnectionRetryTime () const
simtime_t	getHoldTime () const
simtime_t	getKeepAliveTime () const
void	getStatistics (unsigned int *statTab)
bool	isEstablished () const
SessionId	getSessionID () const
BgpSessionType	getType () const
NetworkInterface *	getLinkIntf () const
bool	getCheckConnection () const
Ipv4Address	getPeerAddr () const
bool	getNextHopSelf () const
int	getLocalPreference () const
TcpSocket *	getSocket () const
TcpSocket *	getSocketListen () const
int	getEbgpMultihop () const
IIpv4RoutingTable *	getIPRoutingTable () const
std::vector< BgpRoutingTableEntry * >	getBGPRoutingTable () const
Macho::Machine< fsm::TopState > &	getFSM () const
void	updateSendProcess (BgpRoutingTableEntry *entry) const
bool	isRouteExcluded (const Ipv4Route &rtEntry) const

Static Public Member Functions
static const std::string	getTypeString (BgpSessionType sessionType)

Private Attributes
SessionInfo	_info
BgpRouter &	bgpRouter
simtime_t	_StartEventTime
cMessage *	_ptrStartEvent = nullptr
unsigned int	_connectRetryCounter = 0
simtime_t	_connectRetryTime = BGP_RETRY_TIME
cMessage *	_ptrConnectRetryTimer = nullptr
simtime_t	_holdTime = BGP_HOLD_TIME
cMessage *	_ptrHoldTimer = nullptr
simtime_t	_keepAliveTime = BGP_KEEP_ALIVE
cMessage *	_ptrKeepAliveTimer = nullptr
unsigned int	_openMsgSent = 0
unsigned int	_openMsgRcv = 0
unsigned int	_updateMsgSent = 0
unsigned int	_updateMsgRcv = 0
unsigned int	_notificationMsgSent = 0
unsigned int	_notificationMsgRcv = 0
unsigned int	_keepAliveMsgSent = 0
unsigned int	_keepAliveMsgRcv = 0
fsm::TopState::Box *	_box
Macho::Machine< fsm::TopState > *	_fsm

Friends
struct	fsm::Idle
struct	fsm::Connect
struct	fsm::Active
struct	fsm::OpenSent
struct	fsm::OpenConfirm
struct	fsm::Established

Constructor & Destructor Documentation

BgpSession()

inet::bgp::BgpSession::BgpSession

(

BgpRouter &

bgpRouter

)

                                           : bgpRouter(bgpRouter)
{
    _box = new fsm::TopState::Box(*this);
    _fsm = new Macho::Machine<fsm::TopState>(_box);
    _info.sessionEstablished = false;
};

~BgpSession()

inet::bgp::BgpSession::~BgpSession ( )

virtual

{
    bgpRouter.getCancelAndDelete(_ptrConnectRetryTimer);
    bgpRouter.getCancelAndDelete(_ptrStartEvent);
    bgpRouter.getCancelAndDelete(_ptrHoldTimer);
    bgpRouter.getCancelAndDelete(_ptrKeepAliveTimer);
    delete _info.socket;
    delete _info.socketListen;
    delete _fsm;
}

Member Function Documentation

findAndStartNextSession()

SessionId inet::bgp::BgpSession::findAndStartNextSession ( BgpSessionType  type )

inline

{ return bgpRouter.findNextSession(type, true); }

getBGPRoutingTable()

std::vector<BgpRoutingTableEntry *> inet::bgp::BgpSession::getBGPRoutingTable ( ) const

inline

{ return bgpRouter.getBGPRoutingTable(); }

getCheckConnection()

bool inet::bgp::BgpSession::getCheckConnection ( ) const

inline

{ return _info.checkConnection; }

getConnectionRetryTime()

simtime_t inet::bgp::BgpSession::getConnectionRetryTime ( ) const

inline

{ return _connectRetryTime; }

Referenced by inet::bgp::operator<<().

getEbgpMultihop()

int inet::bgp::BgpSession::getEbgpMultihop ( ) const

inline

{ return _info.ebgpMultihop; }

getFSM()

Macho::Machine<fsm::TopState>& inet::bgp::BgpSession::getFSM ( ) const

inline

{ return *_fsm; }

Referenced by inet::bgp::Bgp::handleTimer(), inet::bgp::operator<<(), and inet::bgp::BgpRouter::processMessage().

getHoldTime()

simtime_t inet::bgp::BgpSession::getHoldTime ( ) const

inline

{ return _holdTime; }

Referenced by inet::bgp::operator<<().

getIPRoutingTable()

IIpv4RoutingTable* inet::bgp::BgpSession::getIPRoutingTable ( ) const

inline

{ return bgpRouter.getIPRoutingTable(); }

getKeepAliveTime()

simtime_t inet::bgp::BgpSession::getKeepAliveTime ( ) const

inline

{ return _keepAliveTime; }

Referenced by inet::bgp::operator<<().

getLinkIntf()

NetworkInterface* inet::bgp::BgpSession::getLinkIntf ( ) const

inline

{ return _info.linkIntf; }

getLocalPreference()

int inet::bgp::BgpSession::getLocalPreference ( ) const

inline

{ return _info.localPreference; }

getNextHopSelf()

bool inet::bgp::BgpSession::getNextHopSelf ( ) const

inline

{ return _info.nextHopSelf; }

Referenced by inet::bgp::operator<<().

getPeerAddr()

Ipv4Address inet::bgp::BgpSession::getPeerAddr ( ) const

inline

{ return _info.peerAddr; }

Referenced by inet::bgp::operator<<(), inet::bgp::BgpRouter::printSessionSummary(), and inet::bgp::BgpRouter::processMessage().

getSessionID()

SessionId inet::bgp::BgpSession::getSessionID ( ) const

inline

{ return _info.sessionID; }

Referenced by inet::bgp::operator<<().

getSocket()

TcpSocket* inet::bgp::BgpSession::getSocket ( ) const

inline

{ return _info.socket; }

getSocketListen()

TcpSocket* inet::bgp::BgpSession::getSocketListen ( ) const

inline

{ return _info.socketListen; }

getStartEventTime()

simtime_t inet::bgp::BgpSession::getStartEventTime ( ) const

inline

{ return _StartEventTime; }

Referenced by inet::bgp::operator<<(), and inet::bgp::BgpRouter::printSessionSummary().

getStatistics()

void inet::bgp::BgpSession::getStatistics

(

unsigned int *

statTab

)

{
    statTab[0] += _openMsgSent;
    statTab[1] += _openMsgRcv;
    statTab[2] += _keepAliveMsgSent;
    statTab[3] += _keepAliveMsgRcv;
    statTab[4] += _updateMsgSent;
    statTab[5] += _updateMsgRcv;
}

getType()

BgpSessionType inet::bgp::BgpSession::getType ( ) const

inline

{ return _info.sessionType; }

Referenced by inet::bgp::operator<<(), and inet::bgp::BgpRouter::printSessionSummary().

getTypeString()

const std::string inet::bgp::BgpSession::getTypeString ( BgpSessionType  sessionType )

static

{
    if (sessionType == IGP)
        return "IGP";
    else if (sessionType == EGP)
        return "EGP";
    else if (sessionType == INCOMPLETE)
        return "INCOMPLETE";
 
    return "Unknown";
}

Referenced by inet::bgp::BgpRouter::listenConnectionFromPeer(), inet::bgp::operator<<(), and inet::bgp::BgpRouter::printUpdateMessage().

isEstablished()

bool inet::bgp::BgpSession::isEstablished ( ) const

inline

{ return _info.sessionEstablished; }

Referenced by inet::bgp::operator<<().

isRouteExcluded()

bool inet::bgp::BgpSession::isRouteExcluded ( const Ipv4Route &  rtEntry ) const

inline

{ return bgpRouter.isRouteExcluded(rtEntry); }

listenConnectionFromPeer()

void inet::bgp::BgpSession::listenConnectionFromPeer ( )

inline

{ bgpRouter.listenConnectionFromPeer(_info.sessionID); }

openTCPConnectionToPeer()

void inet::bgp::BgpSession::openTCPConnectionToPeer ( )

inline

{ bgpRouter.openTCPConnectionToPeer(_info.sessionID); }

restartsConnectRetryTimer()

void inet::bgp::BgpSession::restartsConnectRetryTimer

(

bool

start = true

)

{
    bgpRouter.getCancelEvent(_ptrConnectRetryTimer);
    if (!start) {
        bgpRouter.getScheduleAt(simTime() + _connectRetryTime, _ptrConnectRetryTimer);
    }
}

restartsHoldTimer()

void inet::bgp::BgpSession::restartsHoldTimer

(

)

{
    if (_holdTime != 0) {
        bgpRouter.getCancelEvent(_ptrHoldTimer);
        bgpRouter.getScheduleAt(simTime() + _holdTime, _ptrHoldTimer);
    }
}

restartsKeepAliveTimer()

void inet::bgp::BgpSession::restartsKeepAliveTimer

(

)

{
    bgpRouter.getCancelEvent(_ptrKeepAliveTimer);
    bgpRouter.getScheduleAt(simTime() + _keepAliveTime, _ptrKeepAliveTimer);
}

sendKeepAliveMessage()

void inet::bgp::BgpSession::sendKeepAliveMessage

(

)

{
    const auto& keepAliveMsg = makeShared<BgpKeepAliveMessage>();
 
    EV_INFO << "Sending BGP Keep-alive message to " << _info.peerAddr.str(false)
            << " on interface " << _info.linkIntf->getInterfaceName()
            << "[" << _info.linkIntf->getInterfaceId() << "] \n";
    bgpRouter.printKeepAliveMessage(*keepAliveMsg);
 
    Packet *pk = new Packet("BgpKeepAlive");
    pk->insertAtFront(keepAliveMsg);
 
    _info.socket->send(pk);
    _keepAliveMsgSent++;
}

sendNotificationMessage()

void inet::bgp::BgpSession::sendNotificationMessage

(

)

{
    // TODO
 
//    const auto& updateMsg = makeShared<BgpNotificationMessage>();
 
//    EV_INFO << "Sending BGP Notification message to " << _info.peerAddr.str(false)
//            << " on interface " << _info.linkIntf->getInterfaceName()
//            << "[" << _info.linkIntf->getInterfaceId() << "] with contents:\n";
 
//    Packet *pk = new Packet("BgpNotification");
//    pk->insertAtFront(updateMsg);
 
//    _info.socket->send(pk);
//    _notificationMsgSent++;
}

sendOpenMessage()

void inet::bgp::BgpSession::sendOpenMessage

(

)

{
    const auto& openMsg = makeShared<BgpOpenMessage>();
    openMsg->setMyAS(_info.ASValue);
    openMsg->setHoldTime(_holdTime);
    openMsg->setBGPIdentifier(_info.socket->getLocalAddress().toIpv4());
 
    EV_INFO << "Sending BGP Open message to " << _info.peerAddr.str(false)
            << " on interface " << _info.linkIntf->getInterfaceName()
            << "[" << _info.linkIntf->getInterfaceId() << "] with contents:\n";
    bgpRouter.printOpenMessage(*openMsg);
 
    Packet *pk = new Packet("BgpOpen");
    pk->insertAtFront(openMsg);
 
    _info.socket->send(pk);
    _openMsgSent++;
}

sendUpdateMessage()

void inet::bgp::BgpSession::sendUpdateMessage	(	std::vector< BgpUpdatePathAttributes * > &	content,
		BgpUpdateNlri &	NLRI
	)

{
    const auto& updateMsg = makeShared<BgpUpdateMessage>();
 
    updateMsg->setWithDrawnRoutesLength(0);
 
    size_t attrLength = 0;
    updateMsg->setPathAttributesArraySize(content.size());
    for (size_t i = 0; i < content.size(); i++) {
        attrLength += computePathAttributeBytes(*content[i]);
        updateMsg->setPathAttributes(i, content[i]);
    }
    updateMsg->setTotalPathAttributeLength(attrLength);
    updateMsg->addChunkLength(B(attrLength));
 
    updateMsg->setNLRIArraySize(1);
    updateMsg->setNLRI(0, NLRI);
    updateMsg->addChunkLength(B(1 + (NLRI.length + 7) / 8));
    updateMsg->setTotalLength(B(updateMsg->getChunkLength()).get());
 
    EV_INFO << "Sending BGP Update message to " << _info.peerAddr.str(false)
            << " on interface " << _info.linkIntf->getInterfaceName()
            << "[" << _info.linkIntf->getInterfaceId() << "] with contents:\n";
    bgpRouter.printUpdateMessage(*updateMsg);
 
    Packet *pk = new Packet("BgpUpdate");
    pk->insertAtFront(updateMsg);
 
    _info.socket->send(pk);
    _updateMsgSent++;
}

setInfo()

void inet::bgp::BgpSession::setInfo

(

SessionInfo

info

)

{
    _info.sessionType = info.sessionType;
    _info.ASValue = info.ASValue;
    _info.routerID = info.routerID;
    _info.peerAddr = info.peerAddr;
    _info.sessionID = info.sessionID;
    _info.linkIntf = info.linkIntf;
    _info.ebgpMultihop = info.ebgpMultihop;
    _info.socket = new TcpSocket();
}

Referenced by inet::bgp::BgpRouter::createEbgpSession(), and inet::bgp::BgpRouter::createIbgpSession().

setlinkIntf()

void inet::bgp::BgpSession::setlinkIntf ( NetworkInterface *  intf )

inline

{ _info.linkIntf = intf; }

setLocalPreference()

void inet::bgp::BgpSession::setLocalPreference ( int  localPreference )

inline

{ _info.localPreference = localPreference; }

setNextHopSelf()

void inet::bgp::BgpSession::setNextHopSelf ( bool  nextHopSelf )

inline

{ _info.nextHopSelf = nextHopSelf; }

setSocket()

void inet::bgp::BgpSession::setSocket ( TcpSocket *  socket )

inline

{ delete _info.socket; _info.socket = socket; }

setSocketListen()

void inet::bgp::BgpSession::setSocketListen ( TcpSocket *  socket )

inline

{ delete _info.socketListen; _info.socketListen = socket; }

setTimers()

void inet::bgp::BgpSession::setTimers

(

simtime_t *

delayTab

)

{
    _connectRetryTime = delayTab[0];
    _holdTime = delayTab[1];
    _keepAliveTime = delayTab[2];
    if (_info.sessionType == IGP) {
        _StartEventTime = delayTab[3];
        // if this BGP router does not establish any EGP connection, then start this IGP session
        if (bgpRouter.getNumEgpSessions() == 0) {
            _ptrStartEvent = new cMessage("BGP Start", START_EVENT_KIND);
            bgpRouter.getScheduleAt(simTime() + _StartEventTime, _ptrStartEvent);
            _ptrStartEvent->setContextPointer(this);
        }
    }
    else if (delayTab[3] != SIMTIME_ZERO) {
        _StartEventTime = delayTab[3];
        _ptrStartEvent = new cMessage("BGP Start", START_EVENT_KIND);
        bgpRouter.getScheduleAt(simTime() + _StartEventTime, _ptrStartEvent);
        _ptrStartEvent->setContextPointer(this);
    }
    _ptrConnectRetryTimer = new cMessage("BGP Connect Retry", CONNECT_RETRY_KIND);
    _ptrHoldTimer = new cMessage("BGP Hold Timer", HOLD_TIME_KIND);
    _ptrKeepAliveTimer = new cMessage("BGP Keep Alive Timer", KEEP_ALIVE_KIND);
 
    _ptrConnectRetryTimer->setContextPointer(this);
    _ptrHoldTimer->setContextPointer(this);
    _ptrKeepAliveTimer->setContextPointer(this);
}

startConnection()

void inet::bgp::BgpSession::startConnection

(

)

{
    if (_ptrStartEvent == nullptr)
        _ptrStartEvent = new cMessage("BGP Start", START_EVENT_KIND);
 
    if (_info.sessionType == IGP) {
        if (simTime() > _StartEventTime)
            _StartEventTime = simTime();
        if (!_ptrStartEvent->isScheduled())
            bgpRouter.getScheduleAt(_StartEventTime, _ptrStartEvent);
        _ptrStartEvent->setContextPointer(this);
    }
}

updateSendProcess()

void inet::bgp::BgpSession::updateSendProcess ( BgpRoutingTableEntry *  entry ) const

inline

{ return bgpRouter.updateSendProcess(NEW_SESSION_ESTABLISHED, _info.sessionID, entry); }

Friends And Related Function Documentation

fsm::Active

friend struct fsm::Active

friend

fsm::Connect

friend struct fsm::Connect

friend

fsm::Established

friend struct fsm::Established

friend

fsm::Idle

friend struct fsm::Idle

friend

fsm::OpenConfirm

friend struct fsm::OpenConfirm

friend

fsm::OpenSent

friend struct fsm::OpenSent

friend

Member Data Documentation

_box

fsm::TopState::Box* inet::bgp::BgpSession::_box

private

Referenced by BgpSession().

_connectRetryCounter

unsigned int inet::bgp::BgpSession::_connectRetryCounter = 0

private

_connectRetryTime

simtime_t inet::bgp::BgpSession::_connectRetryTime = BGP_RETRY_TIME

private

Referenced by restartsConnectRetryTimer(), and setTimers().

_fsm

Macho::Machine<fsm::TopState>* inet::bgp::BgpSession::_fsm

private

Referenced by BgpSession(), and ~BgpSession().

_holdTime

simtime_t inet::bgp::BgpSession::_holdTime = BGP_HOLD_TIME

private

Referenced by restartsHoldTimer(), sendOpenMessage(), and setTimers().

_info

SessionInfo inet::bgp::BgpSession::_info

private

Referenced by BgpSession(), sendKeepAliveMessage(), sendOpenMessage(), sendUpdateMessage(), setInfo(), setTimers(), startConnection(), and ~BgpSession().

_keepAliveMsgRcv

unsigned int inet::bgp::BgpSession::_keepAliveMsgRcv = 0

private

Referenced by getStatistics().

_keepAliveMsgSent

unsigned int inet::bgp::BgpSession::_keepAliveMsgSent = 0

private

Referenced by getStatistics(), and sendKeepAliveMessage().

_keepAliveTime

simtime_t inet::bgp::BgpSession::_keepAliveTime = BGP_KEEP_ALIVE

private

Referenced by restartsKeepAliveTimer(), and setTimers().

_notificationMsgRcv

unsigned int inet::bgp::BgpSession::_notificationMsgRcv = 0

private

_notificationMsgSent

unsigned int inet::bgp::BgpSession::_notificationMsgSent = 0

private

_openMsgRcv

unsigned int inet::bgp::BgpSession::_openMsgRcv = 0

private

Referenced by getStatistics().

_openMsgSent

unsigned int inet::bgp::BgpSession::_openMsgSent = 0

private

Referenced by getStatistics(), and sendOpenMessage().

_ptrConnectRetryTimer

cMessage* inet::bgp::BgpSession::_ptrConnectRetryTimer = nullptr

private

Referenced by restartsConnectRetryTimer(), setTimers(), and ~BgpSession().

_ptrHoldTimer

cMessage* inet::bgp::BgpSession::_ptrHoldTimer = nullptr

private

Referenced by restartsHoldTimer(), setTimers(), and ~BgpSession().

_ptrKeepAliveTimer

cMessage* inet::bgp::BgpSession::_ptrKeepAliveTimer = nullptr

private

Referenced by restartsKeepAliveTimer(), setTimers(), and ~BgpSession().

_ptrStartEvent

cMessage* inet::bgp::BgpSession::_ptrStartEvent = nullptr

private

Referenced by setTimers(), startConnection(), and ~BgpSession().

_StartEventTime

simtime_t inet::bgp::BgpSession::_StartEventTime

private

Referenced by setTimers(), and startConnection().

_updateMsgRcv

unsigned int inet::bgp::BgpSession::_updateMsgRcv = 0

private

Referenced by getStatistics().

_updateMsgSent

unsigned int inet::bgp::BgpSession::_updateMsgSent = 0

private

Referenced by getStatistics(), and sendUpdateMessage().

bgpRouter

BgpRouter& inet::bgp::BgpSession::bgpRouter

private

Referenced by restartsConnectRetryTimer(), restartsHoldTimer(), restartsKeepAliveTimer(), sendKeepAliveMessage(), sendOpenMessage(), sendUpdateMessage(), setTimers(), startConnection(), and ~BgpSession().

---

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

• BgpSession.h
• BgpSession.cc