inet::Ldp Class Reference

LDP (rfc 3036) protocol implementation. More...

#include <Ldp.h>

Inheritance diagram for inet::Ldp:

Classes
struct	fec_bind_t
struct	fec_t
struct	peer_info
struct	pending_req_t

Public Types
typedef std::vector< fec_t >	FecVector
typedef std::vector< fec_bind_t >	FecBindVector
typedef std::vector< pending_req_t >	PendingVector
typedef std::vector< peer_info >	PeerVector

Public Member Functions
	Ldp ()
virtual	~Ldp ()
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::TcpSocket::ReceiveQueueBasedCallback
virtual void	socketDataArrived (TcpSocket *socket, Packet *packet, bool urgent) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
Public Member Functions inherited from inet::TcpSocket::ICallback
virtual	~ICallback ()
Public Member Functions inherited from inet::UdpSocket::ICallback
virtual	~ICallback ()
Public Member Functions inherited from inet::IIngressClassifier
virtual	~IIngressClassifier ()

Protected Member Functions
virtual Ipv4Address	locateNextHop (Ipv4Address dest)
	This method finds next peer in upstream direction. More...
virtual Ipv4Address	findPeerAddrFromInterface (std::string interfaceName)
	This method maps the peerIP with the interface name in routing table. More...
std::string	findInterfaceFromPeerAddr (Ipv4Address peerIP)
virtual int	findPeer (Ipv4Address peerAddr)
	Utility: return peer's index in myPeers table, or -1 if not found. More...
virtual TcpSocket *	getPeerSocket (Ipv4Address peerAddr)
	Utility: return socket for given peer. More...
virtual TcpSocket *	findPeerSocket (Ipv4Address peerAddr)
	Utility: return socket for given peer, and nullptr if session doesn't exist. More...
virtual void	sendToPeer (Ipv4Address dest, Packet *msg)
FecVector::iterator	findFecEntry (FecVector &fecs, Ipv4Address addr, int length)
FecBindVector::iterator	findFecEntry (FecBindVector &fecs, int fecid, Ipv4Address peer)
virtual void	sendMappingRequest (Ipv4Address dest, Ipv4Address addr, int length)
virtual void	sendMapping (int type, Ipv4Address dest, int label, Ipv4Address addr, int length)
virtual void	sendNotify (int status, Ipv4Address dest, Ipv4Address addr, int length)
virtual void	rebuildFecList ()
virtual void	updateFecList (Ipv4Address nextHop)
virtual void	updateFecListEntry (fec_t oldItem)
virtual void	announceLinkChange (int tedlinkindex)
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	sendHelloTo (Ipv4Address dest)
virtual void	openTCPConnectionToPeer (int peerIndex)
virtual void	processLDPHello (Packet *msg)
virtual void	processHelloTimeout (cMessage *msg)
virtual void	processLdpPacketFromTcp (Ptr< const LdpPacket > &ldpPacket)
virtual void	processLABEL_MAPPING (Ptr< const LdpPacket > &ldpPacket)
virtual void	processLABEL_REQUEST (Ptr< const LdpPacket > &ldpPacket)
virtual void	processLABEL_RELEASE (Ptr< const LdpPacket > &ldpPacket)
virtual void	processLABEL_WITHDRAW (Ptr< const LdpPacket > &ldpPacket)
virtual void	processNOTIFICATION (Ptr< const LdpPacket > &ldpPacket, bool rescheduled)
TcpSocket::ICallback callback methods
virtual void	socketDataArrived (TcpSocket *socket) override
virtual void	socketAvailable (TcpSocket *socket, TcpAvailableInfo *availableInfo) override
virtual void	socketEstablished (TcpSocket *socket) override
virtual void	socketPeerClosed (TcpSocket *socket) override
virtual void	socketClosed (TcpSocket *socket) override
virtual void	socketFailure (TcpSocket *socket, int code) override
virtual void	socketStatusArrived (TcpSocket *socket, TcpStatusInfo *status) override
virtual void	socketDeleted (TcpSocket *socket) override
UdpSocket::ICallback methods
virtual void	socketDataArrived (UdpSocket *socket, Packet *packet) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
virtual void	socketErrorArrived (UdpSocket *socket, Indication *indication) override
	Notifies about error indication arrival, indication ownership is transferred to the callee. More...
virtual void	socketClosed (UdpSocket *socket) override
	Notifies about socket closed, indication ownership is transferred to the callee. More...
virtual bool	lookupLabel (Packet *ipdatagram, LabelOpVector &outLabel, std::string &outInterface, int &color) override
	The packet argument is an input parameter, the rest (outLabel, outInterface, color) are output parameters only. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
simtime_t	holdTime
simtime_t	helloInterval
FecVector	fecList
FecBindVector	fecUp
FecBindVector	fecDown
PendingVector	pending
PeerVector	myPeers
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< IIpv4RoutingTable >	rt
ModuleRefByPar< LibTable >	lt
ModuleRefByPar< Ted >	tedmod
UdpSocket	udpSocket
std::vector< UdpSocket >	udpSockets
TcpSocket	serverSocket
SocketMap	socketMap
cMessage *	sendHelloMsg = nullptr
int	maxFecid = 0
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

LDP (rfc 3036) protocol implementation.

Member Typedef Documentation

FecBindVector

typedef std::vector<fec_bind_t> inet::Ldp::FecBindVector

FecVector

typedef std::vector<fec_t> inet::Ldp::FecVector

PeerVector

typedef std::vector<peer_info> inet::Ldp::PeerVector

PendingVector

typedef std::vector<pending_req_t> inet::Ldp::PendingVector

Constructor & Destructor Documentation

Ldp()

inet::Ldp::Ldp

(

)

{
}

~Ldp()

inet::Ldp::~Ldp ( )

virtual

{
    for (auto& elem : myPeers)
        cancelAndDelete(elem.timeout);
 
    cancelAndDelete(sendHelloMsg);
    // this causes segfault at the end of simulation       -- Vojta
//    socketMap.deleteSockets();
}

Member Function Documentation

announceLinkChange()

void inet::Ldp::announceLinkChange ( int  tedlinkindex )

protectedvirtual

{
    TedChangeInfo d;
    d.setTedLinkIndicesArraySize(1);
    d.setTedLinkIndices(0, tedlinkindex);
    emit(tedChangedSignal, &d);
}

Referenced by processHelloTimeout(), and processLDPHello().

findFecEntry() [1/2]

Ldp::FecBindVector::iterator inet::Ldp::findFecEntry ( FecBindVector &  fecs, int  fecid, Ipv4Address  peer  )

protected

{
    auto it = fecs.begin();
    for (; it != fecs.end(); it++) {
        if ((it->fecid == fecid) && (it->peer == peer))
            break;
    }
    return it;
}

findFecEntry() [2/2]

Ldp::FecVector::iterator inet::Ldp::findFecEntry ( FecVector &  fecs, Ipv4Address  addr, int  length  )

protected

{
    auto it = fecs.begin();
    for (; it != fecs.end(); it++) {
        if ((it->length == length) && (it->addr == addr)) // TODO compare only relevant part (?)
            break;
    }
    return it;
}

Referenced by lookupLabel(), processLABEL_MAPPING(), processLABEL_RELEASE(), processLABEL_REQUEST(), processLABEL_WITHDRAW(), processNOTIFICATION(), rebuildFecList(), and updateFecListEntry().

findInterfaceFromPeerAddr()

std::string inet::Ldp::findInterfaceFromPeerAddr ( Ipv4Address  peerIP )

protected

{
/*
    int i;
    for (unsigned int i=0;i<myPeers.size();i++)
    {
        if (myPeers[i].peerIP == peerIP)
            return string(myPeers[i].linkInterface);
    }
    return string("X");
 */
    // Rely on port index to find the interface name
 
    // this function is a misnomer, we must recognize our own address too
    if (rt->isLocalAddress(peerIP))
        return "lo0";
 
    NetworkInterface *ie = rt->getInterfaceForDestAddr(peerIP);
    if (!ie)
        throw cRuntimeError("findInterfaceFromPeerAddr(): %s is not routable", peerIP.str().c_str());
    return ie->getInterfaceName();
}

Referenced by lookupLabel(), processLABEL_MAPPING(), processLABEL_REQUEST(), and updateFecListEntry().

findPeer()

int inet::Ldp::findPeer ( Ipv4Address  peerAddr )

protectedvirtual

Utility: return peer's index in myPeers table, or -1 if not found.

{
    for (auto i = myPeers.begin(); i != myPeers.end(); ++i)
        if (i->peerIP == peerAddr)
            return i - myPeers.begin();
 
    return -1;
}

Referenced by findPeerSocket(), processLDPHello(), and socketAvailable().

findPeerAddrFromInterface()

Ipv4Address inet::Ldp::findPeerAddrFromInterface ( std::string  interfaceName )

protectedvirtual

This method maps the peerIP with the interface name in routing table.

It is expected that for MPLS host, entries linked to MPLS peers are available. In case no corresponding peerIP found, a peerIP (not deterministic) will be returned.

{
    int i = 0;
    int k = 0;
    NetworkInterface *ie = ift->findInterfaceByName(interfaceName.c_str());
    if (ie == nullptr)
        return Ipv4Address();
 
    const Ipv4Route *anEntry;
 
    for (i = 0; i < rt->getNumRoutes(); i++) {
        for (k = 0; k < (int)myPeers.size(); k++) {
            anEntry = rt->getRoute(i);
            if (anEntry->getDestination() == myPeers[k].peerIP && anEntry->getInterface() == ie) {
                return myPeers[k].peerIP;
            }
//            addresses->push_back(peerIP[k]);
        }
    }
 
    // Return any IP which has default route - not in routing table entries
    for (i = 0; i < (int)myPeers.size(); i++) {
        for (k = 0; k < rt->getNumRoutes(); k++) {
            anEntry = rt->getRoute(i);
            if (anEntry->getDestination() == myPeers[i].peerIP)
                break;
        }
        if (k == rt->getNumRoutes())
            break;
    }
 
    // return the peer's address if found, unspecified address otherwise
    return i == (int)myPeers.size() ? Ipv4Address() : myPeers[i].peerIP;
}

Referenced by locateNextHop().

findPeerSocket()

TcpSocket * inet::Ldp::findPeerSocket ( Ipv4Address  peerAddr )

protectedvirtual

Utility: return socket for given peer, and nullptr if session doesn't exist.

{
    // find peer in table and return its socket
    int i = findPeer(peerAddr);
    if (i == -1 || !(myPeers[i].socket) || myPeers[i].socket->getState() != TcpSocket::CONNECTED)
        return nullptr; // we don't have an LDP session to this peer
    return myPeers[i].socket;
}

Referenced by getPeerSocket(), processLABEL_REQUEST(), and updateFecListEntry().

getPeerSocket()

TcpSocket * inet::Ldp::getPeerSocket ( Ipv4Address  peerAddr )

protectedvirtual

Utility: return socket for given peer.

Throws error if there's no TCP connection

{
    TcpSocket *sock = findPeerSocket(peerAddr);
    ASSERT(sock);
    if (!sock)
        throw cRuntimeError("No LDP session to peer %s yet", peerAddr.str().c_str());
    return sock;
}

Referenced by sendToPeer().

handleCrashOperation()

void inet::Ldp::handleCrashOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    for (auto& elem : myPeers)
        cancelAndDelete(elem.timeout);
    myPeers.clear();
    cancelEvent(sendHelloMsg);
 
    udpSocket.destroy();
    for (auto& s : udpSockets)
        s.destroy();
    serverSocket.destroy();
    for (auto s : socketMap.getMap())
        s.second->destroy();
}

handleMessageWhenUp()

void inet::Ldp::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    EV_INFO << "Received: (" << msg->getClassName() << ")" << msg->getName() << "\n";
    if (msg == sendHelloMsg) {
        ASSERT(msg->isSelfMessage());
        // every LDP capable router periodically sends HELLO messages to the
        // "all routers in the sub-network" multicast address
        EV_INFO << "Multicasting LDP Hello to neighboring routers\n";
        sendHelloTo(Ipv4Address::ALL_ROUTERS_MCAST);
 
        // schedule next hello
        scheduleAfter(helloInterval, sendHelloMsg);
    }
    else if (msg->isSelfMessage()) {
        EV_INFO << "Timer " << msg->getName() << " expired\n";
        if (!strcmp(msg->getName(), "HelloTimeout")) {
            processHelloTimeout(msg);
        }
        else {
            auto ldpPacket = check_and_cast<Packet *>(msg)->popAtFront<LdpPacket>();
            processNOTIFICATION(ldpPacket, /*rescheduled*/ true);
            delete msg;
        }
    }
    else {
        ISocket *socket = socketMap.findSocketFor(msg);
        if (socket) {
            socket->processMessage(msg);
        }
        else if (serverSocket.belongsToSocket(msg)) {
            serverSocket.processMessage(msg);
        }
        else if (udpSocket.belongsToSocket(msg)) {
            udpSocket.processMessage(msg);
        }
        else {
            auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
            int socketId = tags.getTag<SocketInd>()->getSocketId();
            for (auto& s : udpSockets) {
                if (s.getSocketId() == socketId) {
                    s.processMessage(msg);
                    return;
                }
            }
            throw cRuntimeError("model error: no socket found for msg '%s' with socketId %d", msg->getName(), socketId);
        }
    }
    // TODO move to separate function and reuse from socketClosed
    if (operationalState == State::STOPPING_OPERATION) {
        if (udpSocket.isOpen() || serverSocket.isOpen())
            return;
        // TODO check for empty sockets?
        for (auto& s : udpSockets)
            if (s.isOpen())
                return;
        for (auto s : socketMap.getMap())
            if (s.second->isOpen())
                return;
        udpSockets.clear();
        socketMap.deleteSockets();
        startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
    }
}

handleStartOperation()

void inet::Ldp::handleStartOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    scheduleAfter(exponential(0.1), sendHelloMsg);
}

handleStopOperation()

void inet::Ldp::handleStopOperation ( LifecycleOperation *  operation )

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    for (auto& elem : myPeers)
        cancelAndDelete(elem.timeout);
    myPeers.clear();
    cancelEvent(sendHelloMsg);
    udpSocket.close();
    for (auto& s : udpSockets)
        s.close();
    serverSocket.close();
    for (auto s : socketMap.getMap())
        s.second->close();
    delayActiveOperationFinish(par("stopOperationTimeout"));
}

initialize()

void inet::Ldp::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    RoutingProtocolBase::initialize(stage);
 
    // FIXME move bind() and listen() calls to a new startModule() function, and call it from initialize() and from handleOperationStage()
    // FIXME register to NetworkInterface changes, for detecting the interface add/delete, and detecting multicast config changes:
    // should be refresh the udpSockets vector when interface added/deleted, or isMulticast() value changed.
 
    if (stage == INITSTAGE_LOCAL) {
        holdTime = par("holdTime");
        helloInterval = par("helloInterval");
 
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
        lt.reference(this, "libTableModule", true);
        tedmod.reference(this, "tedModule", true);
 
        WATCH_VECTOR(myPeers);
        WATCH_VECTOR(fecUp);
        WATCH_VECTOR(fecDown);
        WATCH_VECTOR(fecList);
        WATCH_VECTOR(pending);
 
        maxFecid = 0;
        sendHelloMsg = new cMessage("LDPSendHello");
    }
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        // bind UDP socket
        udpSocket.setOutputGate(gate("socketOut"));
        udpSocket.bind(LDP_PORT);
        for (int i = 0; i < ift->getNumInterfaces(); ++i) {
            NetworkInterface *ie = ift->getInterface(i);
            if (ie->isMulticast()) {
                udpSockets.push_back(UdpSocket());
                udpSockets.back().setOutputGate(gate("socketOut"));
                udpSockets.back().setMulticastLoop(false);
                udpSockets.back().setMulticastOutputInterface(ie->getInterfaceId());
            }
        }
 
        // start listening for incoming TCP conns
        EV_INFO << "Starting to listen on port " << LDP_PORT << " for incoming LDP sessions\n";
        serverSocket.setOutputGate(gate("socketOut"));
        serverSocket.bind(LDP_PORT);
        serverSocket.listen();
 
        // build list of recognized FECs
        rebuildFecList();
 
        // listen for routing table modifications
        cModule *host = getContainingNode(this);
        host->subscribe(routeAddedSignal, this);
        host->subscribe(routeDeletedSignal, this);
    }
}

locateNextHop()

Ipv4Address inet::Ldp::locateNextHop ( Ipv4Address  dest )

protectedvirtual

This method finds next peer in upstream direction.

{
    // Mapping L3 IP-host of next hop to L2 peer address.
 
    // Lookup the routing table, rfc3036
    // "When the FEC for which a label is requested is a Prefix FEC Element or
    //  a Host Address FEC Element, the receiving LSR uses its routing table to determine
    //  its response. Unless its routing table includes an entry that exactly matches
    //  the requested Prefix or Host Address, the LSR must respond with a
    //  No Route Notification message."
    //
    // FIXME the code below (though seems like that's what the RFC refers to) doesn't work
    // -- we can't reasonably expect the destination host to be exaplicitly in an
    // LSR's routing table!!! Use simple IP routing instead. --Andras
    //
    // Wrong code:
//    int i;
//    for (i=0; i < rt->getNumRoutes(); i++)
//       if (rt->getRoute(i)->host == dest)
//           break;
//
//    if (i == rt->getNumRoutes())
//        return Ipv4Address();  // Signal an NOTIFICATION of NO ROUTE
//
    NetworkInterface *ie = rt->getInterfaceForDestAddr(dest);
    if (!ie)
        return Ipv4Address(); // no route
 
    std::string iName = ie->getInterfaceName(); // FIXME why use name for lookup?
    return findPeerAddrFromInterface(iName);
}

lookupLabel()

bool inet::Ldp::lookupLabel ( Packet *  packet, LabelOpVector &  outLabel, std::string &  outInterface, int &  color  )

overrideprotectedvirtual

The packet argument is an input parameter, the rest (outLabel, outInterface, color) are output parameters only.

In subclasses, this function should be implemented to determine the forwarding equivalence class for the Ipv4 datagram passed, and map it to an outLabel and outInterface.

The color parameter (which can be set to an arbitrary value) will only be used for the NAM trace if one will be recorded.

Implements inet::IIngressClassifier.

{
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    Ipv4Address destAddr = ipv4Header->getDestAddress();
    int protocol = ipv4Header->getProtocolId();
 
    // never match and always route via L3 if:
 
    // OSPF traffic (Ted)
    if (protocol == IP_PROT_OSPF)
        return false;
 
    // LDP traffic (both discovery...
    if (protocol == IP_PROT_UDP) {
        const auto& udpHeader = packet->peekDataAt<UdpHeader>(ipv4Header->getChunkLength());
        if (udpHeader->getDestinationPort() == LDP_PORT)
            return false;
    }
    else if (protocol == IP_PROT_TCP) {
        // ...and session)
        const auto& tcpHeader = packet->peekDataAt<tcp::TcpHeader>(ipv4Header->getChunkLength());
        if (tcpHeader->getDestPort() == LDP_PORT || tcpHeader->getSrcPort() == LDP_PORT)
            return false;
    }
 
    // regular traffic, classify, label etc.
 
    for (auto& elem : fecList) {
        if (!destAddr.prefixMatches(elem.addr, elem.length))
            continue;
 
        EV_DETAIL << "FEC matched: " << elem << endl;
 
        auto dit = findFecEntry(fecDown, elem.fecid, elem.nextHop);
        if (dit != fecDown.end()) {
            outLabel = LibTable::pushLabel(dit->label);
            outInterface = findInterfaceFromPeerAddr(elem.nextHop);
            color = LDP_USER_TRAFFIC;
            EV_DETAIL << "mapping found, outLabel=" << outLabel << ", outInterface=" << outInterface << endl;
            return true;
        }
        else {
            EV_DETAIL << "no mapping for this FEC exists" << endl;
            return false;
        }
    }
    return false;
}

numInitStages()

virtual int inet::Ldp::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

openTCPConnectionToPeer()

void inet::Ldp::openTCPConnectionToPeer ( int  peerIndex )

protectedvirtual

{
    TcpSocket *socket = new TcpSocket();
    socket->setOutputGate(gate("socketOut"));
    socket->setCallback(this);
    socket->setUserData((void *)((intptr_t)peerIndex));
    socket->bind(rt->getRouterId(), 0);
    socketMap.addSocket(socket);
    myPeers[peerIndex].socket = socket;
 
    socket->connect(myPeers[peerIndex].peerIP, LDP_PORT);
}

Referenced by processLDPHello().

processHelloTimeout()

void inet::Ldp::processHelloTimeout ( cMessage *  msg )

protectedvirtual

{
    // peer is gone
 
    unsigned int i;
    for (i = 0; i < myPeers.size(); i++)
        if (myPeers[i].timeout == msg)
            break;
 
    ASSERT(i < myPeers.size());
 
    Ipv4Address peerIP = myPeers[i].peerIP;
 
    EV_INFO << "peer=" << peerIP << " is gone, removing adjacency" << endl;
 
    ASSERT(!myPeers[i].timeout->isScheduled());
    delete myPeers[i].timeout;
    ASSERT(myPeers[i].socket);
    myPeers[i].socket->abort(); // should we only close?
    delete myPeers[i].socket;
    myPeers.erase(myPeers.begin() + i);
 
    EV_INFO << "removing (stale) bindings from fecDown for peer=" << peerIP << endl;
 
    for (auto dit = fecDown.begin(); dit != fecDown.end();) {
        if (dit->peer != peerIP) {
            dit++;
            continue;
        }
 
        EV_DETAIL << "label=" << dit->label << endl;
 
        // send release message just in case (?)
        // what happens if peer is not really down and
        // hello messages just disappeared?
        // does the protocol recover on its own (TODO check this)
 
        dit = fecDown.erase(dit);
    }
 
    EV_INFO << "removing bindings from sent to peer=" << peerIP << " from fecUp" << endl;
 
    for (auto uit = fecUp.begin(); uit != fecUp.end();) {
        if (uit->peer != peerIP) {
            uit++;
            continue;
        }
 
        EV_DETAIL << "label=" << uit->label << endl;
 
        // send withdraw message just in case (?)
        // see comment above...
 
        uit = fecUp.erase(uit);
    }
 
    EV_INFO << "updating fecList" << endl;
 
    updateFecList(peerIP);
 
    // update TED and routing table
 
    unsigned int index = tedmod->linkIndex(rt->getRouterId(), peerIP);
    tedmod->ted[index].state = false;
    announceLinkChange(index);
    tedmod->rebuildRoutingTable();
}

Referenced by handleMessageWhenUp().

processLABEL_MAPPING()

void inet::Ldp::processLABEL_MAPPING ( Ptr< const LdpPacket > &  ldpPacket )

protectedvirtual

{
    const auto& packet = CHK(dynamicPtrCast<const LdpLabelMapping>(ldpPacket));
    FecTlv fec = packet->getFec();
    int label = packet->getLabel();
    Ipv4Address fromIP = packet->getSenderAddress();
 
    EV_INFO << "Label mapping label=" << label << " received for fec=" << fec << " from " << fromIP << endl;
 
    ASSERT(label > 0);
 
    auto it = findFecEntry(fecList, fec.addr, fec.length);
    if (it == fecList.end())
        throw cRuntimeError("Model error: fec not in fecList");
 
    auto dit = findFecEntry(fecDown, it->fecid, fromIP);
    if (dit != fecDown.end())
        throw cRuntimeError("Model error: found in fecDown");
 
    // insert among received mappings
 
    fec_bind_t newItem;
    newItem.fecid = it->fecid;
    newItem.peer = fromIP;
    newItem.label = label;
    fecDown.push_back(newItem);
 
    // respond to pending requests
 
    for (auto pit = pending.begin(); pit != pending.end();) {
        if (pit->fecid != it->fecid) {
            pit++;
            continue;
        }
 
        EV_DETAIL << "there's pending request for this FEC from " << pit->peer << ", sending mapping" << endl;
 
        std::string inInterface = findInterfaceFromPeerAddr(pit->peer);
        std::string outInterface = findInterfaceFromPeerAddr(fromIP);
        LabelOpVector outLabel = LibTable::swapLabel(label);
 
        fec_bind_t newItem;
        newItem.fecid = it->fecid;
        newItem.peer = pit->peer;
        newItem.label = lt->installLibEntry(-1, inInterface, outLabel, outInterface, LDP_USER_TRAFFIC);
        fecUp.push_back(newItem);
 
        EV_DETAIL << "installed LIB entry inLabel=" << newItem.label << " inInterface=" << inInterface
                  << " outLabel=" << outLabel << " outInterface=" << outInterface << endl;
 
        sendMapping(LABEL_MAPPING, pit->peer, newItem.label, it->addr, it->length);
 
        // remove request from the list
        pit = pending.erase(pit);
    }
}

Referenced by processLdpPacketFromTcp().

processLABEL_RELEASE()

void inet::Ldp::processLABEL_RELEASE ( Ptr< const LdpPacket > &  ldpPacket )

protectedvirtual

{
    const auto& packet = CHK(dynamicPtrCast<const LdpLabelMapping>(ldpPacket));
    FecTlv fec = packet->getFec();
    int label = packet->getLabel();
    Ipv4Address fromIP = packet->getSenderAddress();
 
    EV_INFO << "Mapping release received for label=" << label << " fec=" << fec << " from " << fromIP << endl;
 
    ASSERT(label > 0);
 
    // remove label from fecUp
 
    auto it = findFecEntry(fecList, fec.addr, fec.length);
    if (it == fecList.end()) {
        EV_INFO << "FEC no longer recognized here, ignoring" << endl;
        return;
    }
 
    auto uit = findFecEntry(fecUp, it->fecid, fromIP);
    if (uit == fecUp.end() || label != uit->label) {
        // this is ok and may happen; e.g. we removed the mapping because downstream
        // neighbour withdrew its mapping. we sent withdraw upstream as well and
        // this is upstream's response
        EV_INFO << "mapping not found among sent mappings, ignoring" << endl;
        return;
    }
 
    EV_DETAIL << "removing from LIB table label=" << uit->label << endl;
    lt->removeLibEntry(uit->label);
 
    EV_DETAIL << "removing label from list of sent mappings" << endl;
    fecUp.erase(uit);
}

Referenced by processLdpPacketFromTcp().

processLABEL_REQUEST()

void inet::Ldp::processLABEL_REQUEST ( Ptr< const LdpPacket > &  ldpPacket )

protectedvirtual

{
    const auto& packet = CHK(dynamicPtrCast<const LdpLabelRequest>(ldpPacket));
    FecTlv fec = packet->getFec();
    Ipv4Address srcAddr = packet->getSenderAddress();
 
    EV_INFO << "Label Request from LSR " << srcAddr << " for FEC " << fec << endl;
 
    auto it = findFecEntry(fecList, fec.addr, fec.length);
    if (it == fecList.end()) {
        EV_DETAIL << "FEC not recognized, sending back No route message" << endl;
 
        sendNotify(NO_ROUTE, srcAddr, fec.addr, fec.length);
        return;
    }
 
    // do we already have mapping for this fec from our downstream peer?
 
    //
    // TODO this code duplicates rebuildFecList
    //
 
    // does upstream have mapping from us?
    auto uit = findFecEntry(fecUp, it->fecid, srcAddr);
 
    // shouldn't!
    ASSERT(uit == fecUp.end());
 
    // do we have mapping from downstream?
    auto dit = findFecEntry(fecDown, it->fecid, it->nextHop);
 
    // is next hop our LDP peer?
    bool ER = !findPeerSocket(it->nextHop);
 
    ASSERT(!(ER && dit != fecDown.end())); // can't be egress and have mapping at the same time
 
    if (ER || dit != fecDown.end()) {
        fec_bind_t newItem;
        newItem.fecid = it->fecid;
        newItem.label = -1;
        newItem.peer = srcAddr;
        fecUp.push_back(newItem);
        uit = fecUp.end() - 1;
    }
 
    std::string inInterface = findInterfaceFromPeerAddr(srcAddr);
    std::string outInterface = findInterfaceFromPeerAddr(it->nextHop);
 
    if (ER) {
        // we are egress, that's easy:
        LabelOpVector outLabel = LibTable::popLabel();
 
        uit->label = lt->installLibEntry(uit->label, inInterface, outLabel, outInterface, 0);
 
        EV_DETAIL << "installed (egress) LIB entry inLabel=" << uit->label << " inInterface=" << inInterface
                  << " outLabel=" << outLabel << " outInterface=" << outInterface << endl;
 
        // We are egress, let our upstream peer know
        // about it by sending back a Label Mapping message
 
        sendMapping(LABEL_MAPPING, srcAddr, uit->label, fec.addr, fec.length);
    }
    else if (dit != fecDown.end()) {
        // we have mapping from DS, that's easy
        LabelOpVector outLabel = LibTable::swapLabel(dit->label);
        uit->label = lt->installLibEntry(uit->label, inInterface, outLabel, outInterface, LDP_USER_TRAFFIC);
 
        EV_DETAIL << "installed LIB entry inLabel=" << uit->label << " inInterface=" << inInterface
                  << " outLabel=" << outLabel << " outInterface=" << outInterface << endl;
 
        // We already have a mapping for this FEC, let our upstream peer know
        // about it by sending back a Label Mapping message
 
        sendMapping(LABEL_MAPPING, srcAddr, uit->label, fec.addr, fec.length);
    }
    else {
        // no mapping from DS, mark as pending
 
        EV_DETAIL << "no mapping for this FEC from the downstream router, marking as pending" << endl;
 
        pending_req_t newItem;
        newItem.fecid = it->fecid;
        newItem.peer = srcAddr;
        pending.push_back(newItem);
    }
}

Referenced by processLdpPacketFromTcp().

processLABEL_WITHDRAW()

void inet::Ldp::processLABEL_WITHDRAW ( Ptr< const LdpPacket > &  ldpPacket )

protectedvirtual

{
    const auto& ldpLabelMapping = CHK(dynamicPtrCast<const LdpLabelMapping>(ldpPacket));
    FecTlv fec = ldpLabelMapping->getFec();
    int label = ldpLabelMapping->getLabel();
    Ipv4Address fromIP = ldpLabelMapping->getSenderAddress();
 
    EV_INFO << "Mapping withdraw received for label=" << label << " fec=" << fec << " from " << fromIP << endl;
 
    ASSERT(label > 0);
 
    // remove label from fecDown
 
    auto it = findFecEntry(fecList, fec.addr, fec.length);
    if (it == fecList.end()) {
        EV_INFO << "matching FEC not found, ignoring withdraw message" << endl;
        return;
    }
 
    auto dit = findFecEntry(fecDown, it->fecid, fromIP);
 
    if (dit == fecDown.end() || label != dit->label) {
        EV_INFO << "matching mapping not found, ignoring withdraw message" << endl;
        return;
    }
 
    ASSERT(dit != fecDown.end());
    ASSERT(label == dit->label);
 
    EV_INFO << "removing label from list of received mappings" << endl;
    fecDown.erase(dit);
 
    EV_INFO << "sending back relase message" << endl;
    auto reply = makeShared<LdpLabelMapping>(*ldpLabelMapping.get());
    reply->setType(LABEL_RELEASE);
    auto pk = new Packet("LDP_RELEASE", reply);
//    pk->addTag<PacketProtocolTag>()->setProtocol(&Protocol::ldp) //FIXME
    // send msg to peer over TCP
    sendToPeer(fromIP, pk);
 
    updateFecListEntry(*it);
}

Referenced by processLdpPacketFromTcp().

processLDPHello()

void inet::Ldp::processLDPHello ( Packet *  msg )

protectedvirtual

{
    int socketId = msg->getTag<SocketInd>()->getSocketId();
    ASSERT(socketId == udpSocket.getSocketId());
 
    const auto& ldpHello = msg->peekAtFront<LdpHello>();
//    Ipv4Address peerAddr = controlInfo->getSrcAddr().toIPv4();
    Ipv4Address peerAddr = ldpHello->getSenderAddress();
    int interfaceId = msg->getTag<InterfaceInd>()->getInterfaceId();
    delete msg;
 
    EV_INFO << "Received LDP Hello from " << peerAddr << ", ";
 
    if (peerAddr.isUnspecified() || peerAddr == rt->getRouterId()) {
        // must be ourselves (we're also in the all-routers multicast group), ignore
        EV_INFO << "that's myself, ignore\n";
        return;
    }
 
    // mark link as working if it was failed, and rebuild table
    unsigned int index = tedmod->linkIndex(rt->getRouterId(), peerAddr);
    if (!tedmod->ted[index].state) {
        tedmod->ted[index].state = true;
        tedmod->rebuildRoutingTable();
        announceLinkChange(index);
    }
 
    // peer already in table?
    int i = findPeer(peerAddr);
    if (i != -1) {
        EV_DETAIL << "already in my peer table, rescheduling timeout" << endl;
        ASSERT(myPeers[i].timeout);
        rescheduleAfter(holdTime, myPeers[i].timeout);
        return;
    }
 
    // not in table, add it
    peer_info info;
    info.peerIP = peerAddr;
    info.linkInterface = ift->getInterfaceById(interfaceId)->getInterfaceName();
    info.activeRole = peerAddr.getInt() > rt->getRouterId().getInt();
    info.socket = nullptr;
    info.timeout = new cMessage("HelloTimeout");
    scheduleAfter(holdTime, info.timeout);
    myPeers.push_back(info);
    int peerIndex = myPeers.size() - 1;
 
    EV_INFO << "added to peer table\n";
    EV_INFO << "We'll be " << (info.activeRole ? "ACTIVE" : "PASSIVE") << " in this session\n";
 
    // introduce ourselves with a Hello, then connect if we're in ACTIVE role
    sendHelloTo(peerAddr);
    if (info.activeRole) {
        EV_INFO << "Establishing session with it\n";
        openTCPConnectionToPeer(peerIndex);
    }
}

Referenced by socketDataArrived().

processLdpPacketFromTcp()

void inet::Ldp::processLdpPacketFromTcp ( Ptr< const LdpPacket > &  ldpPacket )

protectedvirtual

{
    switch (ldpPacket->getType()) {
        case HELLO:
            throw cRuntimeError("Received LDP HELLO over TCP (should arrive over UDP)");
            break;
 
        case ADDRESS:
//            processADDRESS(ldpPacket);
            throw cRuntimeError("Received LDP ADDRESS message, unsupported in this version");
            break;
 
        case ADDRESS_WITHDRAW:
//            processADDRESS_WITHDRAW(ldpPacket);
            throw cRuntimeError("LDP PROC DEBUG: Received LDP ADDRESS_WITHDRAW message, unsupported in this version");
            break;
 
        case LABEL_MAPPING:
            processLABEL_MAPPING(ldpPacket);
            break;
 
        case LABEL_REQUEST:
            processLABEL_REQUEST(ldpPacket);
            break;
 
        case LABEL_WITHDRAW:
            processLABEL_WITHDRAW(ldpPacket);
            break;
 
        case LABEL_RELEASE:
            processLABEL_RELEASE(ldpPacket);
            break;
 
        case NOTIFICATION:
            processNOTIFICATION(ldpPacket, /*rescheduled*/ false);
            break;
 
        default:
            throw cRuntimeError("LDP PROC DEBUG: Unrecognized LDP Message Type, type is %d", ldpPacket->getType());
            break;
    }
}

Referenced by socketDataArrived().

processNOTIFICATION()

void inet::Ldp::processNOTIFICATION ( Ptr< const LdpPacket > &  ldpPacket, bool  rescheduled  )

protectedvirtual

{
    const auto& packet = CHK(dynamicPtrCast<const LdpNotify>(ldpPacket));
    FecTlv fec = packet->getFec();
    Ipv4Address srcAddr = packet->getSenderAddress();
    int status = packet->getStatus();
 
    // FIXME NO_ROUTE processing should probably be split into two functions,
    // this is not the cleanest thing I ever wrote :)   --Vojta
 
    if (rescheduled) {
        // re-scheduled by ourselves
        EV_INFO << "notification retry for peer=" << srcAddr << " fec=" << fec << " status=" << status << endl;
    }
    else {
        // received via network
        EV_INFO << "notification received from=" << srcAddr << " fec=" << fec << " status=" << status << endl;
    }
 
    switch (status) {
        case NO_ROUTE: {
            EV_INFO << "route does not exit on that peer" << endl;
 
            auto it = findFecEntry(fecList, fec.addr, fec.length);
            if (it != fecList.end()) {
                if (it->nextHop == srcAddr) {
                    if (!rescheduled) {
                        EV_DETAIL << "we are still interesed in this mapping, we will retry later" << endl;
                        auto pk = new Packet(0, ldpPacket);
                        scheduleAfter(1.0 /* FIXME */, pk);
                        return;
                    }
                    else {
                        EV_DETAIL << "reissuing request" << endl;
 
                        sendMappingRequest(srcAddr, fec.addr, fec.length);
                    }
                }
                else
                    EV_DETAIL << "and we still recognize this FEC, but we use different next hop, forget it" << endl;
            }
            else
                EV_DETAIL << "and we do not recognize this any longer, forget it" << endl;
 
            break;
        }
 
        default:
            ASSERT(false);
            break;
    }
}

Referenced by handleMessageWhenUp(), and processLdpPacketFromTcp().

rebuildFecList()

void inet::Ldp::rebuildFecList ( )

protectedvirtual

{
    EV_INFO << "make list of recognized FECs" << endl;
 
    FecVector oldList = fecList;
    fecList.clear();
 
    for (int i = 0; i < rt->getNumRoutes(); i++) {
        // every entry in the routing table
 
        const Ipv4Route *re = rt->getRoute(i);
 
        // ignore multicast routes
        if (re->getDestination().isMulticast())
            continue;
 
        // find out current next hop according to routing table
        Ipv4Address nextHop = (re->getGateway().isUnspecified()) ? re->getDestination() : re->getGateway();
        ASSERT(!nextHop.isUnspecified());
 
        EV_INFO << "nextHop <-- " << nextHop << endl;
 
        auto it = findFecEntry(oldList, re->getDestination(), re->getNetmask().getNetmaskLength());
 
        if (it == oldList.end()) {
            // fec didn't exist, it was just created
            fec_t newItem;
            newItem.fecid = ++maxFecid;
            newItem.addr = re->getDestination();
            newItem.length = re->getNetmask().getNetmaskLength();
            newItem.nextHop = nextHop;
            updateFecListEntry(newItem);
            fecList.push_back(newItem);
        }
        else if (it->nextHop != nextHop) {
            // next hop for this FEC changed,
            it->nextHop = nextHop;
            updateFecListEntry(*it);
            fecList.push_back(*it);
            oldList.erase(it);
        }
        else {
            // FEC didn't change, reusing old values
            fecList.push_back(*it);
            oldList.erase(it);
            continue;
        }
    }
 
    // our own addresses (TODO is it needed?)
 
    for (int i = 0; i < ift->getNumInterfaces(); ++i) {
        NetworkInterface *ie = ift->getInterface(i);
 
        // TODO should replace to ie->isUp() or drop this code:
//        if (ie->getNetworkLayerGateIndex() < 0)
//            continue;
 
        auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
        if (!ipv4Data)
            continue;
 
        auto it = findFecEntry(oldList, ipv4Data->getIPAddress(), 32);
        if (it == oldList.end()) {
            fec_t newItem;
            newItem.fecid = ++maxFecid;
            newItem.addr = ipv4Data->getIPAddress();
            newItem.length = 32;
            newItem.nextHop = ipv4Data->getIPAddress();
            fecList.push_back(newItem);
        }
        else {
            fecList.push_back(*it);
            oldList.erase(it);
        }
    }
 
    if (oldList.size() > 0) {
        EV_INFO << "there are " << oldList.size() << " deprecated FECs, removing them" << endl;
 
        for (auto& elem : oldList) {
            EV_DETAIL << "removing FEC= " << elem << endl;
 
            for (auto& _dit : fecDown) {
                if (_dit.fecid != elem.fecid)
                    continue;
 
                EV_DETAIL << "sending release label=" << _dit.label << " downstream to " << _dit.peer << endl;
 
                sendMapping(LABEL_RELEASE, _dit.peer, _dit.label, elem.addr, elem.length);
            }
 
            for (auto& _uit : fecUp) {
                if (_uit.fecid != elem.fecid)
                    continue;
 
                EV_DETAIL << "sending withdraw label=" << _uit.label << " upstream to " << _uit.peer << endl;
 
                sendMapping(LABEL_WITHDRAW, _uit.peer, _uit.label, elem.addr, elem.length);
 
                EV_DETAIL << "removing entry inLabel=" << _uit.label << " from LIB" << endl;
 
                lt->removeLibEntry(_uit.label);
            }
        }
    }
 
    // we must keep this list sorted for matching to work correctly
    // this is probably slower than it must be
    std::stable_sort(fecList.begin(), fecList.end(), fecPrefixCompare);
}

Referenced by initialize(), and receiveSignal().

receiveSignal()

void inet::Ldp::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    printSignalBanner(signalID, obj, details);
 
    ASSERT(signalID == routeAddedSignal || signalID == routeDeletedSignal);
 
    EV_INFO << "routing table changed, rebuild list of known FEC" << endl;
 
    rebuildFecList();
}

sendHelloTo()

void inet::Ldp::sendHelloTo ( Ipv4Address  dest )

protectedvirtual

{
    Packet *pk = new Packet("LDP-Hello");
    const auto& hello = makeShared<LdpHello>();
    hello->setChunkLength(LDP_HEADER_BYTES);
    hello->setType(HELLO);
    hello->setSenderAddress(rt->getRouterId());
//    hello->setReceiverAddress(...);
    hello->setHoldTime(SIMTIME_DBL(holdTime));
//    hello->setRbit(...);
//    hello->setTbit(...);
    pk->insertAtBack(hello);
    pk->addPar("color") = LDP_HELLO_TRAFFIC;
 
    if (dest.isMulticast()) {
        for (size_t i = 0; i < udpSockets.size(); ++i) {
            Packet *msg = (i == udpSockets.size() - 1) ? pk : pk->dup();
            udpSockets[i].sendTo(msg, dest, LDP_PORT);
        }
        if (udpSockets.size() == 0)
            delete pk;
    }
    else
        udpSocket.sendTo(pk, dest, LDP_PORT);
}

Referenced by handleMessageWhenUp(), and processLDPHello().

sendMapping()

void inet::Ldp::sendMapping ( int  type, Ipv4Address  dest, int  label, Ipv4Address  addr, int  length  )

protectedvirtual

{
    // Send LABEL MAPPING downstream
    Packet *packet = new Packet("Lb-Mapping");
    const auto& lmMessage = makeShared<LdpLabelMapping>();
    lmMessage->setChunkLength(LDP_HEADER_BYTES); // FIXME find out actual length
    lmMessage->setType(type);
    lmMessage->setReceiverAddress(dest);
    lmMessage->setSenderAddress(rt->getRouterId());
    lmMessage->setLabel(label);
 
    FecTlv fec;
    fec.addr = addr;
    fec.length = length;
 
    lmMessage->setFec(fec);
    packet->insertAtBack(lmMessage);
 
    sendToPeer(dest, packet);
}

Referenced by processLABEL_MAPPING(), processLABEL_REQUEST(), rebuildFecList(), and updateFecListEntry().

sendMappingRequest()

void inet::Ldp::sendMappingRequest ( Ipv4Address  dest, Ipv4Address  addr, int  length  )

protectedvirtual

{
    Packet *pk = new Packet("Lb-Req");
    const auto& requestMsg = makeShared<LdpLabelRequest>();
    requestMsg->setChunkLength(LDP_HEADER_BYTES); // FIXME find out actual length
    requestMsg->setType(LABEL_REQUEST);
 
    FecTlv fec;
    fec.addr = addr;
    fec.length = length;
    requestMsg->setFec(fec);
 
    requestMsg->setReceiverAddress(dest);
    requestMsg->setSenderAddress(rt->getRouterId());
    pk->insertAtBack(requestMsg);
 
    sendToPeer(dest, pk);
}

Referenced by processNOTIFICATION(), and updateFecListEntry().

sendNotify()

void inet::Ldp::sendNotify ( int  status, Ipv4Address  dest, Ipv4Address  addr, int  length  )

protectedvirtual

{
    // Send NOTIFY message
    Packet *packet = new Packet("Lb-Notify");
    const auto& lnMessage = makeShared<LdpNotify>();
    lnMessage->setChunkLength(LDP_HEADER_BYTES); // FIXME find out actual length
    lnMessage->setType(NOTIFICATION);
    lnMessage->setStatus(NO_ROUTE);
    lnMessage->setReceiverAddress(dest);
    lnMessage->setSenderAddress(rt->getRouterId());
 
    FecTlv fec;
    fec.addr = addr;
    fec.length = length;
 
    lnMessage->setFec(fec);
    packet->insertAtBack(lnMessage);
 
    sendToPeer(dest, packet);
}

Referenced by processLABEL_REQUEST().

sendToPeer()

void inet::Ldp::sendToPeer ( Ipv4Address  dest, Packet *  msg  )

protectedvirtual

{
    getPeerSocket(dest)->send(msg);
}

Referenced by processLABEL_WITHDRAW(), sendMapping(), sendMappingRequest(), and sendNotify().

socketAvailable()

void inet::Ldp::socketAvailable ( TcpSocket *  socket, TcpAvailableInfo *  availableInfo  )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    // TODO
    // not yet in socketMap, must be new incoming connection.
    // find which peer it is and register connection
    TcpSocket *newSocket = new TcpSocket(availableInfo);
    newSocket->setOutputGate(gate("socketOut"));
 
    // FIXME there seems to be some confusion here. Is it sure that
    // routerIds we use as peerAddrs are the same as IP addresses
    // the routing is based on? --Andras
    Ipv4Address peerAddr = newSocket->getRemoteAddress().toIpv4();
 
    int i = findPeer(peerAddr);
    if (i == -1 || myPeers[i].socket) {
        // nothing known about this guy, or already connected: refuse
        newSocket->close(); // reset()?
        delete newSocket;
        return;
    }
    myPeers[i].socket = newSocket;
    newSocket->setCallback(this);
    newSocket->setUserData((void *)((intptr_t)i));
    socketMap.addSocket(newSocket);
    socketocket->accept(availableInfo->getNewSocketId());
}

socketClosed() [1/2]

void inet::Ldp::socketClosed ( TcpSocket *  socket )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    peer_info& peer = myPeers[(uintptr_t)socket->getUserData()];
    EV_INFO << "TCP connection to peer " << peer.peerIP << " closed\n";
 
    ASSERT(false);
 
    // FIXME what now? reconnect after a delay?
}

socketClosed() [2/2]

void inet::Ldp::socketClosed ( UdpSocket *  socket )

overrideprotectedvirtual

Notifies about socket closed, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
}

socketDataArrived() [1/2]

void inet::Ldp::socketDataArrived ( TcpSocket *  socket )

overrideprotectedvirtual

Implements inet::TcpSocket::ReceiveQueueBasedCallback.

{
    peer_info& peer = myPeers[(uintptr_t)socket->getUserData()];
    EV_INFO << "Message arrived over TCP from peer " << peer.peerIP << "\n";
 
    auto queue = socket->getReceiveQueue();
    while (queue->has<LdpPacket>()) {
        auto header = queue->pop<LdpPacket>();
        processLdpPacketFromTcp(header);
    }
}

socketDataArrived() [2/2]

void inet::Ldp::socketDataArrived ( UdpSocket *  socket, Packet *  packet  )

overrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    // process incoming udp packet
    // FIXME add implementation
    processLDPHello(check_and_cast<Packet *>(packet));
}

socketDeleted()

virtual void inet::Ldp::socketDeleted ( TcpSocket *  socket )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{} // TODO

socketErrorArrived()

void inet::Ldp::socketErrorArrived ( UdpSocket *  socket, Indication *  indication  )

overrideprotectedvirtual

Notifies about error indication arrival, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    EV_WARN << "Ignoring UDP error report " << indication->getName() << endl;
    delete indication;
}

socketEstablished()

void inet::Ldp::socketEstablished ( TcpSocket *  socket )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    peer_info& peer = myPeers[(uintptr_t)socket->getUserData()];
    EV_INFO << "TCP connection established with peer " << peer.peerIP << "\n";
 
    // we must update all entries with nextHop == peerIP
    updateFecList(peer.peerIP);
 
    // FIXME start LDP session setup (if we're on the active side?)
}

socketFailure()

void inet::Ldp::socketFailure ( TcpSocket *  socket, int  code  )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    peer_info& peer = myPeers[(uintptr_t)socket->getUserData()];
    EV_INFO << "TCP connection to peer " << peer.peerIP << " broken\n";
 
    ASSERT(false);
 
    // FIXME what now? reconnect after a delay?
}

socketPeerClosed()

void inet::Ldp::socketPeerClosed ( TcpSocket *  socket )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    peer_info& peer = myPeers[(uintptr_t)socket->getUserData()];
    EV_INFO << "Peer " << peer.peerIP << " closed TCP connection\n";
 
    ASSERT(false);
 
/*
    // close the connection (if not already closed)
    if (socket.getState()==TcpSocket::PEER_CLOSED)
    {
        EV << "remote TCP closed, closing here as well\n";
        close();
    }
 */
}

socketStatusArrived()

virtual void inet::Ldp::socketStatusArrived ( TcpSocket *  socket, TcpStatusInfo *  status  )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{}

updateFecList()

void inet::Ldp::updateFecList ( Ipv4Address  nextHop )

protectedvirtual

{
    for (auto& elem : fecList) {
        if (elem.nextHop != nextHop)
            continue;
 
        updateFecListEntry(elem);
    }
}

Referenced by processHelloTimeout(), and socketEstablished().

updateFecListEntry()

void inet::Ldp::updateFecListEntry ( Ldp::fec_t  oldItem )

protectedvirtual

{
    // do we have mapping from downstream?
    auto dit = findFecEntry(fecDown, oldItem.fecid, oldItem.nextHop);
 
    // is next hop our LDP peer?
    bool ER = findPeerSocket(oldItem.nextHop) == nullptr;
 
    ASSERT(!(ER && dit != fecDown.end())); // can't be egress and have mapping at the same time
 
    // adjust upstream mappings
    for (auto uit = fecUp.begin(); uit != fecUp.end();) {
        if (uit->fecid != oldItem.fecid) {
            uit++;
            continue;
        }
 
        std::string inInterface = findInterfaceFromPeerAddr(uit->peer);
        std::string outInterface = findInterfaceFromPeerAddr(oldItem.nextHop);
        if (ER) {
            // we are egress, that's easy:
            LabelOpVector outLabel = LibTable::popLabel();
            uit->label = lt->installLibEntry(uit->label, inInterface, outLabel, outInterface, LDP_USER_TRAFFIC);
 
            EV_DETAIL << "installed (egress) LIB entry inLabel=" << uit->label << " inInterface=" << inInterface
                      << " outLabel=" << outLabel << " outInterface=" << outInterface << endl;
            uit++;
        }
        else if (dit != fecDown.end()) {
            // we have mapping from DS, that's easy
            LabelOpVector outLabel = LibTable::swapLabel(dit->label);
            uit->label = lt->installLibEntry(uit->label, inInterface, outLabel, outInterface, LDP_USER_TRAFFIC);
 
            EV_DETAIL << "installed LIB entry inLabel=" << uit->label << " inInterface=" << inInterface
                      << " outLabel=" << outLabel << " outInterface=" << outInterface << endl;
            uit++;
        }
        else {
            // no mapping from DS, withdraw mapping US
            EV_INFO << "sending withdraw message upstream" << endl;
            sendMapping(LABEL_WITHDRAW, uit->peer, uit->label, oldItem.addr, oldItem.length);
 
            // remove from US mappings
            uit = fecUp.erase(uit);
        }
    }
 
    if (!ER && dit == fecDown.end()) {
        // and ask DS for mapping
        EV_INFO << "sending request message downstream" << endl;
        sendMappingRequest(oldItem.nextHop, oldItem.addr, oldItem.length);
    }
}

Referenced by processLABEL_WITHDRAW(), rebuildFecList(), and updateFecList().

Member Data Documentation

fecDown

FecBindVector inet::Ldp::fecDown

protected

Referenced by initialize(), lookupLabel(), processHelloTimeout(), processLABEL_MAPPING(), processLABEL_REQUEST(), processLABEL_WITHDRAW(), rebuildFecList(), and updateFecListEntry().

fecList

FecVector inet::Ldp::fecList

protected

Referenced by initialize(), lookupLabel(), processLABEL_MAPPING(), processLABEL_RELEASE(), processLABEL_REQUEST(), processLABEL_WITHDRAW(), processNOTIFICATION(), rebuildFecList(), and updateFecList().

fecUp

FecBindVector inet::Ldp::fecUp

protected

Referenced by initialize(), processHelloTimeout(), processLABEL_MAPPING(), processLABEL_RELEASE(), processLABEL_REQUEST(), rebuildFecList(), and updateFecListEntry().

helloInterval

simtime_t inet::Ldp::helloInterval

protected

Referenced by handleMessageWhenUp(), and initialize().

holdTime

simtime_t inet::Ldp::holdTime

protected

Referenced by initialize(), processLDPHello(), and sendHelloTo().

ift

ModuleRefByPar<IInterfaceTable> inet::Ldp::ift

protected

Referenced by findPeerAddrFromInterface(), initialize(), processLDPHello(), and rebuildFecList().

lt

ModuleRefByPar<LibTable> inet::Ldp::lt

protected

Referenced by initialize(), processLABEL_MAPPING(), processLABEL_RELEASE(), processLABEL_REQUEST(), rebuildFecList(), and updateFecListEntry().

maxFecid

int inet::Ldp::maxFecid = 0

protected

Referenced by initialize(), and rebuildFecList().

myPeers

PeerVector inet::Ldp::myPeers

protected

Referenced by findPeer(), findPeerAddrFromInterface(), findPeerSocket(), handleCrashOperation(), handleStopOperation(), initialize(), openTCPConnectionToPeer(), processHelloTimeout(), processLDPHello(), socketAvailable(), socketClosed(), socketDataArrived(), socketEstablished(), socketFailure(), socketPeerClosed(), and ~Ldp().

pending

PendingVector inet::Ldp::pending

protected

Referenced by initialize(), processLABEL_MAPPING(), and processLABEL_REQUEST().

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Ldp::rt

protected

Referenced by findInterfaceFromPeerAddr(), findPeerAddrFromInterface(), initialize(), locateNextHop(), openTCPConnectionToPeer(), processHelloTimeout(), processLDPHello(), rebuildFecList(), sendHelloTo(), sendMapping(), sendMappingRequest(), and sendNotify().

sendHelloMsg

cMessage* inet::Ldp::sendHelloMsg = nullptr

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStartOperation(), handleStopOperation(), initialize(), and ~Ldp().

serverSocket

TcpSocket inet::Ldp::serverSocket

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), and initialize().

socketMap

SocketMap inet::Ldp::socketMap

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), openTCPConnectionToPeer(), and socketAvailable().

tedmod

ModuleRefByPar<Ted> inet::Ldp::tedmod

protected

Referenced by initialize(), processHelloTimeout(), and processLDPHello().

udpSocket

UdpSocket inet::Ldp::udpSocket

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), initialize(), processLDPHello(), and sendHelloTo().

udpSockets

std::vector<UdpSocket> inet::Ldp::udpSockets

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), initialize(), and sendHelloTo().

---

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

• Ldp.h
• Ldp.cc