inet::RsvpClassifier Class Reference

TODO documentation. More...

#include <RsvpClassifier.h>

Inheritance diagram for inet::RsvpClassifier:

Classes
struct	FecEntry

Public Member Functions
	RsvpClassifier ()
Public Member Functions inherited from inet::IScriptable
virtual	~IScriptable ()
Public Member Functions inherited from inet::IRsvpClassifier
virtual	~IRsvpClassifier ()
Public Member Functions inherited from inet::IIngressClassifier
virtual	~IIngressClassifier ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	processCommand (const cXMLElement &node) override
	Called by ScenarioManager whenever a script command needs to be carried out by the module. 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	bind (const SessionObj &session, const SenderTemplateObj &sender, int inLabel) override
virtual void	readTableFromXML (const cXMLElement *fectable)
virtual void	readItemFromXML (const cXMLElement *fec)
std::vector< FecEntry >::iterator	findFEC (int fecid)

Protected Attributes
Ipv4Address	routerId
int	maxLabel = 0
std::vector< FecEntry >	bindings
ModuleRefByPar< LibTable >	lt
ModuleRefByPar< RsvpTe >	rsvp

Detailed Description

TODO documentation.

Constructor & Destructor Documentation

RsvpClassifier()

inet::RsvpClassifier::RsvpClassifier ( )

inline

{}

Member Function Documentation

bind()

void inet::RsvpClassifier::bind ( const SessionObj &  session, const SenderTemplateObj &  sender, int  inLabel  )

overrideprotectedvirtual

Implements inet::IRsvpClassifier.

{
    for (auto& elem : bindings) {
        if (elem.session != session)
            continue;
 
        if (elem.sender != sender)
            continue;
 
        elem.inLabel = inLabel;
    }
}

findFEC()

std::vector< RsvpClassifier::FecEntry >::iterator inet::RsvpClassifier::findFEC ( int  fecid )

protected

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

handleMessage()

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

overrideprotectedvirtual

{
    ASSERT(false);
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        maxLabel = 0;
        WATCH_VECTOR(bindings);
    }
    // TODO INITSTAGE
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        IIpv4RoutingTable *rt = getModuleFromPar<IIpv4RoutingTable>(par("routingTableModule"), this);
        routerId = rt->getRouterId();
 
        lt.reference(this, "libTableModule", true);
        rsvp.reference(this, "rsvpModule", true);
 
        readTableFromXML(par("config"));
    }
}

lookupLabel()

bool inet::RsvpClassifier::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.

{
    // never label OSPF(TED) and RSVP traffic
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
 
    switch (ipv4Header->getProtocolId()) {
        case IP_PROT_OSPF:
        case IP_PROT_RSVP:
            return false;
 
        default:
            break;
    }
 
    // forwarding decision for non-labeled datagrams
 
    for (auto& elem : bindings) {
        if (!elem.dest.isUnspecified() && !elem.dest.equals(ipv4Header->getDestAddress()))
            continue;
 
        if (!elem.src.isUnspecified() && !elem.src.equals(ipv4Header->getSrcAddress()))
            continue;
 
        EV_DETAIL << "packet belongs to fecid=" << elem.id << endl;
 
        if (elem.inLabel < 0)
            return false;
 
        return lt->resolveLabel("", elem.inLabel, outLabel, outInterface, color);
    }
 
    return false;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processCommand()

void inet::RsvpClassifier::processCommand ( const cXMLElement &  node )

overrideprotectedvirtual

Called by ScenarioManager whenever a script command needs to be carried out by the module.

The command is represented by the XML element or element tree. The command name can be obtained as:

const char *command = node->getTagName()

Parameters are XML attributes, e.g. a "neighbour" parameter can be retrieved as:

const char *attr = node->getAttribute("neighbour")

More complex input can be passed in child elements.

See also

cXMLElement

Implements inet::IScriptable.

{
    if (!strcmp(node.getTagName(), "bind-fec")) {
        readItemFromXML(&node);
    }
    else
        ASSERT(false);
}

readItemFromXML()

void inet::RsvpClassifier::readItemFromXML ( const cXMLElement *  fec )

protectedvirtual

{
    ASSERT(fec);
    ASSERT(!strcmp(fec->getTagName(), "fecentry") || !strcmp(fec->getTagName(), "bind-fec"));
 
    int fecid = getParameterIntValue(fec, "id");
 
    auto it = findFEC(fecid);
 
    if (getUniqueChildIfExists(fec, "label")) {
        // bind-fec to label
        checkTags(fec, "id label destination source");
 
        EV_INFO << "binding to a given label" << endl;
 
        FecEntry newFec;
 
        newFec.id = fecid;
        newFec.dest = getParameterIPAddressValue(fec, "destination");
        newFec.src = getParameterIPAddressValue(fec, "source", Ipv4Address());
 
        newFec.inLabel = getParameterIntValue(fec, "label");
 
        if (it == bindings.end()) {
            // create new binding
            bindings.push_back(newFec);
        }
        else {
            // update existing binding
            *it = newFec;
        }
    }
    else if (getUniqueChildIfExists(fec, "lspid")) {
        // bind-fec to LSP
        checkTags(fec, "id destination source tunnel_id extended_tunnel_id endpoint lspid");
 
        EV_INFO << "binding to a given path" << endl;
 
        FecEntry newFec;
 
        newFec.id = fecid;
        newFec.dest = getParameterIPAddressValue(fec, "destination");
        newFec.src = getParameterIPAddressValue(fec, "source", Ipv4Address());
 
        newFec.session.Tunnel_Id = getParameterIntValue(fec, "tunnel_id");
        newFec.session.Extended_Tunnel_Id = getParameterIPAddressValue(fec, "extened_tunnel_id", routerId).getInt();
        newFec.session.DestAddress = getParameterIPAddressValue(fec, "endpoint", newFec.dest); // ??? always use newFec.dest ???
 
        newFec.sender.Lsp_Id = getParameterIntValue(fec, "lspid");
        newFec.sender.SrcAddress = routerId;
 
        newFec.inLabel = rsvp->getInLabel(newFec.session, newFec.sender);
 
        if (it == bindings.end()) {
            // create new binding
            bindings.push_back(newFec);
        }
        else {
            // update existing binding
            *it = newFec;
        }
    }
    else {
        // un-bind
        checkTags(fec, "id");
 
        if (it != bindings.end()) {
            bindings.erase(it);
        }
    }
}

readTableFromXML()

void inet::RsvpClassifier::readTableFromXML ( const cXMLElement *  fectable )

protectedvirtual

{
    ASSERT(fectable);
    ASSERT(!strcmp(fectable->getTagName(), "fectable"));
    checkTags(fectable, "fecentry");
    cXMLElementList list = fectable->getChildrenByTagName("fecentry");
    for (auto& elem : list)
        readItemFromXML(elem);
}

Member Data Documentation

bindings

std::vector<FecEntry> inet::RsvpClassifier::bindings

protected

lt

ModuleRefByPar<LibTable> inet::RsvpClassifier::lt

protected

maxLabel

int inet::RsvpClassifier::maxLabel = 0

protected

routerId

Ipv4Address inet::RsvpClassifier::routerId

protected

rsvp

ModuleRefByPar<RsvpTe> inet::RsvpClassifier::rsvp

protected

---

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

• RsvpClassifier.h
• RsvpClassifier.cc