inet::Mpls Class Reference

Implements the MPLS protocol; see the NED file for more info. More...

#include <Mpls.h>

Inheritance diagram for inet::Mpls:

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	processPacketFromL3 (Packet *msg)
virtual void	processPacketFromL2 (Packet *msg)
virtual void	processMplsPacketFromL2 (Packet *mplsPacket)
virtual bool	tryLabelAndForwardIpv4Datagram (Packet *ipdatagram)
virtual void	labelAndForwardIpv4Datagram (Packet *ipdatagram)
virtual void	sendToL2 (Packet *msg)
virtual void	sendToL3 (Packet *msg)
void	pushLabel (Packet *packet, Ptr< MplsHeader > &newMplsHeader)
void	swapLabel (Packet *packet, Ptr< MplsHeader > &newMplsHeader)
void	popLabel (Packet *packet)
virtual void	doStackOps (Packet *packet, const LabelOpVector &outLabel)
virtual void	handleRegisterInterface (const NetworkInterface &interface, cGate *in, cGate *out) override
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override

Protected Attributes
simtime_t	delay1
ModuleRefByPar< LibTable >	lt
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< IIngressClassifier >	pct

Additional Inherited Members
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override

Detailed Description

Implements the MPLS protocol; see the NED file for more info.

Member Function Documentation

doStackOps()

void inet::Mpls::doStackOps ( Packet *  packet, const LabelOpVector &  outLabel  )

protectedvirtual

{
    unsigned int n = outLabel.size();
 
    EV_INFO << "doStackOps: " << outLabel << endl;
 
    for (unsigned int i = 0; i < n; i++) {
        switch (outLabel[i].optcode) {
            case PUSH_OPER: {
                auto mplsHeader = makeShared<MplsHeader>();
                mplsHeader->setLabel(outLabel[i].label);
                pushLabel(packet, mplsHeader);
                break;
            }
            case SWAP_OPER: {
                auto mplsHeader = makeShared<MplsHeader>();
                mplsHeader->setLabel(outLabel[i].label);
                swapLabel(packet, mplsHeader);
                break;
            }
            case POP_OPER:
                popLabel(packet);
                break;
 
            default:
                throw cRuntimeError("Unknown MPLS OptCode %d", outLabel[i].optcode);
                break;
        }
    }
}

Referenced by processMplsPacketFromL2(), and tryLabelAndForwardIpv4Datagram().

handleMessage()

void inet::Mpls::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    Packet *pk = check_and_cast<Packet *>(msg);
    if (msg->getArrivalGate()->isName("ifIn")) {
        EV_INFO << "Processing message from L2: " << pk << endl;
        processPacketFromL2(pk);
    }
    else if (msg->getArrivalGate()->isName("netwIn")) {
        EV_INFO << "Processing message from L3: " << pk << endl;
        processPacketFromL3(pk);
    }
    else {
        throw cRuntimeError("unexpected message: %s", msg->getName());
    }
}

handleRegisterInterface()

void inet::Mpls::handleRegisterInterface ( const NetworkInterface &  interface, cGate *  in, cGate *  out  )

overrideprotectedvirtual

Implements inet::IInterfaceRegistrationListener.

{
    if (!strcmp("ifIn", in->getBaseName()))
        registerInterface(interface, gate("netwIn"), gate("netwOut"));
}

handleRegisterProtocol()

void inet::Mpls::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (!strcmp("ifIn", g->getName()))
        registerProtocol(protocol, gate("netwOut"), servicePrimitive);
    else if (!strcmp("ifOut", g->getName()))
        ;
    else if (!strcmp("netwOut", g->getName()))
        registerProtocol(protocol, gate("ifIn"), servicePrimitive);
    else if (!strcmp("netwIn", g->getName()))
        ; // void
    else
        throw cRuntimeError("Unknown gate: %s", g->getName());
}

handleRegisterService()

void inet::Mpls::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
    if (!strcmp("ifOut", g->getName()))
        registerService(protocol, gate("netwIn"), servicePrimitive);
    else if (!strcmp("ifIn", g->getName()))
        ;
    else if (!strcmp("netwOut", g->getName()))
        registerService(protocol, gate("ifIn"), servicePrimitive);
    else if (!strcmp("netwIn", g->getName()))
        ;
    else
        throw cRuntimeError("Unknown gate: %s", g->getName());
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        // interfaceTable must be initialized
 
        lt.reference(this, "libTableModule", true);
        ift.reference(this, "interfaceTableModule", true);
        pct.reference(this, "classifierModule", true);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        registerService(Protocol::mpls, gate("netwIn"), gate("netwOut"));
        registerProtocol(Protocol::mpls, gate("ifOut"), gate("ifIn"));
    }
}

labelAndForwardIpv4Datagram()

void inet::Mpls::labelAndForwardIpv4Datagram ( Packet *  ipdatagram )

protectedvirtual

{
    if (tryLabelAndForwardIpv4Datagram(ipdatagram))
        return;
 
    // handling our outgoing Ipv4 traffic that didn't match any FEC/LSP
    // do not use labelAndForwardIPv4Datagram for packets arriving to ingress!
 
    EV_INFO << "FEC not resolved, doing regular L3 routing" << endl;
 
    sendToL2(ipdatagram);
}

Referenced by processPacketFromL3().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

popLabel()

void inet::Mpls::popLabel ( Packet *  packet )

protected

{
    ASSERT(packet->getTag<PacketProtocolTag>()->getProtocol()->getId() == Protocol::mpls.getId());
    auto oldMplsHeader = packet->popAtFront<MplsHeader>();
    if (oldMplsHeader->getS()) {
        packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::ipv4);
    }
}

Referenced by doStackOps().

processMplsPacketFromL2()

void inet::Mpls::processMplsPacketFromL2 ( Packet *  mplsPacket )

protectedvirtual

{
    int incomingInterfaceId = packet->getTag<InterfaceInd>()->getInterfaceId();
    NetworkInterface *ie = ift->getInterfaceById(incomingInterfaceId);
    std::string incomingInterfaceName = ie->getInterfaceName();
    const auto& mplsHeader = packet->peekAtFront<MplsHeader>();
 
    EV_INFO << "Received " << packet << " from L2, label=" << mplsHeader->getLabel() << " inInterface=" << incomingInterfaceName << endl;
 
    if (mplsHeader->getLabel() == (uint32_t)-1) { // FIXME
        // This is a Ipv4 native packet (RSVP/TED traffic)
        // Decapsulate the message and pass up to L3
        EV_INFO << ": decapsulating and sending up\n";
        packet->popAtFront<MplsHeader>();
        packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::ipv4);
        sendToL3(packet);
        return;
    }
 
    LabelOpVector outLabel;
    std::string outInterface;
    int color;
 
    bool found = lt->resolveLabel(incomingInterfaceName, mplsHeader->getLabel(), outLabel, outInterface, color);
    if (!found) {
        EV_INFO << "discarding packet, incoming label not resolved" << endl;
 
        delete packet;
        return;
    }
 
    NetworkInterface *outgoingInterface = CHK(ift->findInterfaceByName(outInterface.c_str()));
 
    doStackOps(packet, outLabel);
 
    if ((packet->getTag<PacketProtocolTag>()->getProtocol()->getId() == Protocol::mpls.getId())) {
        // forward labeled packet
        EV_INFO << "forwarding packet to " << outInterface << endl;
 
        if (packet->hasPar("color")) {
            packet->par("color") = color;
        }
        else {
            packet->addPar("color") = color;
        }
 
//        ASSERT(labelIf[outgoingPort]);
        packet->removeTagIfPresent<DispatchProtocolReq>();
        packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(outgoingInterface->getInterfaceId());
        packet->trim();
        sendToL2(packet);
    }
    else {
        // last label popped, decapsulate and send out Ipv4 datagram
 
        EV_INFO << "decapsulating Ipv4 datagram" << endl;
        ASSERT(packet->getTag<PacketProtocolTag>()->getProtocol()->getId() == Protocol::ipv4.getId());
 
        if (outgoingInterface) {
            packet->trim();
            packet->removeTagIfPresent<DispatchProtocolReq>();
            packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(outgoingInterface->getInterfaceId());
            sendToL2(packet);
        }
        else {
            sendToL3(packet);
        }
    }
}

Referenced by processPacketFromL2().

processPacketFromL2()

void inet::Mpls::processPacketFromL2 ( Packet *  msg )

protectedvirtual

{
    int protocolId = packet->getTag<PacketProtocolTag>()->getProtocol()->getId();
    if (protocolId == Protocol::mpls.getId()) {
        processMplsPacketFromL2(packet);
    }
    else if (protocolId == Protocol::ipv4.getId()) {
        // Ipv4 datagram arrives at Ingress router. We'll try to classify it
        // and add an MPLS header
 
        if (!tryLabelAndForwardIpv4Datagram(packet)) {
            sendToL3(packet);
        }
    }
    else {
        throw cRuntimeError("Unknown message received");
        // FIXME remove throw below
        sendToL3(packet);
    }
}

Referenced by handleMessage().

processPacketFromL3()

void inet::Mpls::processPacketFromL3 ( Packet *  msg )

protectedvirtual

{
    using namespace tcp;
 
    const Protocol *protocol = msg->getTag<PacketProtocolTag>()->getProtocol();
    if (protocol != &Protocol::ipv4) {
        // only the Ipv4 protocol supported yet
        sendToL2(msg);
        return;
    }
 
    const auto& ipHeader = msg->peekAtFront<Ipv4Header>();
 
    // TODO temporary solution, until TcpSocket and Ipv4 are extended to support nam tracing
    if (ipHeader->getProtocolId() == IP_PROT_TCP) {
        const auto& seg = msg->peekDataAt<TcpHeader>(ipHeader->getChunkLength());
        if (seg->getDestPort() == LDP_PORT || seg->getSrcPort() == LDP_PORT) {
            ASSERT(!msg->hasPar("color"));
            msg->addPar("color") = LDP_TRAFFIC;
        }
    }
    else if (ipHeader->getProtocolId() == IP_PROT_ICMP) {
//        ASSERT(!msg->hasPar("color")); TODO this did not hold sometimes...
        if (!msg->hasPar("color"))
            msg->addPar("color") = ICMP_TRAFFIC;
    }
    // TODO end of temporary area
 
    labelAndForwardIpv4Datagram(msg);
}

Referenced by handleMessage().

pushLabel()

void inet::Mpls::pushLabel ( Packet *  packet, Ptr< MplsHeader > &  newMplsHeader  )

protected

{
    packet->trimFront();
    newMplsHeader->setS(packet->getTag<PacketProtocolTag>()->getProtocol()->getId() != Protocol::mpls.getId());
    packet->insertAtFront(newMplsHeader);
    packet->getTagForUpdate<PacketProtocolTag>()->setProtocol(&Protocol::mpls);
}

Referenced by doStackOps().

sendToL2()

void inet::Mpls::sendToL2 ( Packet *  msg )

protectedvirtual

{
    ASSERT(msg->findTag<InterfaceReq>());
    ASSERT(msg->findTag<PacketProtocolTag>());
    send(msg, "ifOut");
}

Referenced by labelAndForwardIpv4Datagram(), processMplsPacketFromL2(), processPacketFromL3(), and tryLabelAndForwardIpv4Datagram().

sendToL3()

void inet::Mpls::sendToL3 ( Packet *  msg )

protectedvirtual

{
    ASSERT(msg->findTag<InterfaceInd>());
    ASSERT(msg->findTag<DispatchProtocolReq>());
    send(msg, "netwOut");
}

Referenced by processMplsPacketFromL2(), and processPacketFromL2().

swapLabel()

void inet::Mpls::swapLabel ( Packet *  packet, Ptr< MplsHeader > &  newMplsHeader  )

protected

{
    ASSERT(packet->getTag<PacketProtocolTag>()->getProtocol()->getId() == Protocol::mpls.getId());
    packet->trimFront();
    auto oldMplsHeader = packet->removeAtFront<MplsHeader>();
    newMplsHeader->setS(oldMplsHeader->getS());
    packet->insertAtFront(newMplsHeader);
}

Referenced by doStackOps().

tryLabelAndForwardIpv4Datagram()

bool inet::Mpls::tryLabelAndForwardIpv4Datagram ( Packet *  ipdatagram )

protectedvirtual

{
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    (void)ipv4Header; // unused variable
    LabelOpVector outLabel;
    std::string outInterface; // FIXME set based on interfaceID
    int color;
 
    if (!pct->lookupLabel(packet, outLabel, outInterface, color)) {
        EV_WARN << "no mapping exists for this packet" << endl;
        return false;
    }
    int outInterfaceId = CHK(ift->findInterfaceByName(outInterface.c_str()))->getInterfaceId();
 
    ASSERT(outLabel.size() > 0);
 
    doStackOps(packet, outLabel);
 
    EV_INFO << "forwarding packet to " << outInterface << endl;
 
    packet->addPar("color") = color;
 
    packet->trim();
    packet->removeTagIfPresent<DispatchProtocolReq>();
    packet->addTagIfAbsent<InterfaceReq>()->setInterfaceId(outInterfaceId);
    sendToL2(packet);
 
    return true;
}

Referenced by labelAndForwardIpv4Datagram(), and processPacketFromL2().

Member Data Documentation

delay1

simtime_t inet::Mpls::delay1

protected

ift

ModuleRefByPar<IInterfaceTable> inet::Mpls::ift

protected

Referenced by initialize(), processMplsPacketFromL2(), and tryLabelAndForwardIpv4Datagram().

lt

ModuleRefByPar<LibTable> inet::Mpls::lt

protected

Referenced by initialize(), and processMplsPacketFromL2().

pct

ModuleRefByPar<IIngressClassifier> inet::Mpls::pct

protected

Referenced by initialize(), and tryLabelAndForwardIpv4Datagram().

---

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

• Mpls.h
• Mpls.cc