inet::SimpleClassifier Class Reference

TODO documentation. More...

#include <SimpleClassifier.h>

Inheritance diagram for inet::SimpleClassifier:

Classes
struct	FECEntry

Public Member Functions
	SimpleClassifier ()
Public Member Functions inherited from inet::IScriptable
virtual	~IScriptable ()
Public Member Functions inherited from inet::IRSVPClassifier
virtual	~IRSVPClassifier ()
Public Member Functions inherited from inet::IClassifier
virtual	~IClassifier ()

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 (IPv4Datagram *ipdatagram, LabelOpVector &outLabel, std::string &outInterface, int &color) override
	The ipdatagram argument is an input parameter, the rest (outLabel, outInterface, color) are output parameters only. More...
virtual void	bind (const SessionObj_t &session, const SenderTemplateObj_t &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
LIBTable *	lt = nullptr
RSVP *	rsvp = nullptr

Detailed Description

TODO documentation.

Constructor & Destructor Documentation

inet::SimpleClassifier::SimpleClassifier ( )

inline

{}

Member Function Documentation

void inet::SimpleClassifier::bind ( const SessionObj_t &  session, const SenderTemplateObj_t &  sender, int  inLabel  )

overrideprotectedvirtual

Implements inet::IRSVPClassifier.

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

        if (elem.sender != sender)
            continue;

        elem.inLabel = inLabel;
    }
}

std::vector< SimpleClassifier::FECEntry >::iterator inet::SimpleClassifier::findFEC ( int  fecid )

protected

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

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

overrideprotectedvirtual

{
    ASSERT(false);
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        maxLabel = 0;
        WATCH_VECTOR(bindings);
    }
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        IIPv4RoutingTable *rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        routerId = rt->getRouterId();

        lt = getModuleFromPar<LIBTable>(par("libTableModule"), this);

        rsvp = getModuleFromPar<RSVP>(par("rsvpModule"), this);

        readTableFromXML(par("config").xmlValue());
    }
}

bool inet::SimpleClassifier::lookupLabel ( IPv4Datagram *  ipdatagram, LabelOpVector &  outLabel, std::string &  outInterface, int &  color  )

overrideprotectedvirtual

The ipdatagram 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::IClassifier.

{
    // never label OSPF(TED) and RSVP traffic

    switch (ipdatagram->getTransportProtocol()) {
        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(ipdatagram->getDestAddress()))
            continue;

        if (!elem.src.isUnspecified() && !elem.src.equals(ipdatagram->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;
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::SimpleClassifier::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);
}

void inet::SimpleClassifier::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);
        }
    }
}

void inet::SimpleClassifier::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

std::vector<FECEntry> inet::SimpleClassifier::bindings

protected

LIBTable* inet::SimpleClassifier::lt = nullptr

protected

int inet::SimpleClassifier::maxLabel = 0

protected

IPv4Address inet::SimpleClassifier::routerId

protected

RSVP* inet::SimpleClassifier::rsvp = nullptr

protected

---

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

• SimpleClassifier.h
• SimpleClassifier.cc