inet::MultiFieldClassifier Class Reference

Absolute dropper. More...

#include <MultiFieldClassifier.h>

Inheritance diagram for inet::MultiFieldClassifier:

Classes
struct	Filter

Public Member Functions
	MultiFieldClassifier ()

Protected Member Functions
void	addFilter (const Filter &filter)
void	configureFilters (cXMLElement *config)
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	refreshDisplay () const override
virtual int	classifyPacket (cPacket *packet)

Protected Attributes
int	numOutGates = 0
std::vector< Filter >	filters
int	numRcvd = 0

Static Protected Attributes
static simsignal_t	pkClassSignal = registerSignal("pkClass")

Detailed Description

Absolute dropper.

Constructor & Destructor Documentation

inet::MultiFieldClassifier::MultiFieldClassifier ( )

inline

{}

Member Function Documentation

void inet::MultiFieldClassifier::addFilter ( const Filter &  filter )

protected

{
    if (filter.gateIndex < 0 || filter.gateIndex >= numOutGates)
        throw cRuntimeError("no output gate for gate index %d", filter.gateIndex);
    if (!filter.srcAddr.isUnspecified() && ((filter.srcAddr.getType() == L3Address::IPv6 && filter.srcPrefixLength > 128) ||
                                            (filter.srcAddr.getType() == L3Address::IPv4 && filter.srcPrefixLength > 32)))
        throw cRuntimeError("srcPrefixLength is invalid");
    if (!filter.destAddr.isUnspecified() && ((filter.destAddr.getType() == L3Address::IPv6 && filter.destPrefixLength > 128) ||
                                             (filter.destAddr.getType() == L3Address::IPv4 && filter.destPrefixLength > 32)))
        throw cRuntimeError("srcPrefixLength is invalid");
    if (filter.protocol != -1 && (filter.protocol < 0 || filter.protocol > 0xff))
        throw cRuntimeError("protocol is not a valid protocol number");
    if (filter.tos != -1 && (filter.tos < 0 || filter.tos > 0xff))
        throw cRuntimeError("tos is not valid");
    if (filter.tosMask < 0 || filter.tosMask > 0xff)
        throw cRuntimeError("tosMask is not valid");
    if (filter.srcPortMin != -1 && (filter.srcPortMin < 0 || filter.srcPortMin > 0xffff))
        throw cRuntimeError("srcPortMin is not a valid port number");
    if (filter.srcPortMax != -1 && (filter.srcPortMax < 0 || filter.srcPortMax > 0xffff))
        throw cRuntimeError("srcPortMax is not a valid port number");
    if (filter.srcPortMin != -1 && filter.srcPortMin > filter.srcPortMax)
        throw cRuntimeError("srcPortMin > srcPortMax");
    if (filter.destPortMin != -1 && (filter.destPortMin < 0 || filter.destPortMin > 0xffff))
        throw cRuntimeError("destPortMin is not a valid port number");
    if (filter.destPortMax != -1 && (filter.destPortMax < 0 || filter.destPortMax > 0xffff))
        throw cRuntimeError("destPortMax is not a valid port number");
    if (filter.destPortMin != -1 && filter.destPortMin > filter.destPortMax)
        throw cRuntimeError("destPortMin > destPortMax");

    filters.push_back(filter);
}

int inet::MultiFieldClassifier::classifyPacket ( cPacket *  packet )

protectedvirtual

{
    for ( ; packet; packet = packet->getEncapsulatedPacket()) {
#ifdef WITH_IPv4
        IPv4Datagram *ipv4Datagram = dynamic_cast<IPv4Datagram *>(packet);
        if (ipv4Datagram) {
            for (auto & elem : filters)
                if (elem.matches(ipv4Datagram))
                    return elem.gateIndex;

            return -1;
        }
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
        IPv6Datagram *ipv6Datagram = dynamic_cast<IPv6Datagram *>(packet);
        if (ipv6Datagram) {
            for (auto & elem : filters)
                if (elem.matches(ipv6Datagram))
                    return elem.gateIndex;

            return -1;
        }
#endif // ifdef WITH_IPv6
    }

    return -1;
}

void inet::MultiFieldClassifier::configureFilters ( cXMLElement *  config )

protected

{
    L3AddressResolver addressResolver;
    cXMLElementList filterElements = config->getChildrenByTagName("filter");
    for (auto & filterElements_i : filterElements) {
        cXMLElement *filterElement = filterElements_i;
        try {
            const char *gateAttr = getRequiredAttribute(filterElement, "gate");
            const char *srcAddrAttr = filterElement->getAttribute("srcAddress");
            const char *srcPrefixLengthAttr = filterElement->getAttribute("srcPrefixLength");
            const char *destAddrAttr = filterElement->getAttribute("destAddress");
            const char *destPrefixLengthAttr = filterElement->getAttribute("destPrefixLength");
            const char *protocolAttr = filterElement->getAttribute("protocol");
            const char *tosAttr = filterElement->getAttribute("tos");
            const char *tosMaskAttr = filterElement->getAttribute("tosMask");
            const char *srcPortAttr = filterElement->getAttribute("srcPort");
            const char *srcPortMinAttr = filterElement->getAttribute("srcPortMin");
            const char *srcPortMaxAttr = filterElement->getAttribute("srcPortMax");
            const char *destPortAttr = filterElement->getAttribute("destPort");
            const char *destPortMinAttr = filterElement->getAttribute("destPortMin");
            const char *destPortMaxAttr = filterElement->getAttribute("destPortMax");

            Filter filter;
            filter.gateIndex = parseIntAttribute(gateAttr, "gate");
            if (srcAddrAttr)
                filter.srcAddr = addressResolver.resolve(srcAddrAttr);
            if (srcPrefixLengthAttr)
                filter.srcPrefixLength = parseIntAttribute(srcPrefixLengthAttr, "srcPrefixLength");
            else if (srcAddrAttr)
                filter.srcPrefixLength = filter.srcAddr.getType() == L3Address::IPv6 ? 128 : 32;
            if (destAddrAttr)
                filter.destAddr = addressResolver.resolve(destAddrAttr);
            if (destPrefixLengthAttr)
                filter.destPrefixLength = parseIntAttribute(destPrefixLengthAttr, "destPrefixLength");
            else if (destAddrAttr)
                filter.destPrefixLength = filter.destAddr.getType() == L3Address::IPv6 ? 128 : 32;
            if (protocolAttr)
                filter.protocol = parseProtocol(protocolAttr, "protocol");
            if (tosAttr)
                filter.tos = parseIntAttribute(tosAttr, "tos");
            if (tosMaskAttr)
                filter.tosMask = parseIntAttribute(tosMaskAttr, "tosMask");
            if (srcPortAttr)
                filter.srcPortMin = filter.srcPortMax = parseIntAttribute(srcPortAttr, "srcPort");
            if (srcPortMinAttr)
                filter.srcPortMin = parseIntAttribute(srcPortMinAttr, "srcPortMin");
            if (srcPortMaxAttr)
                filter.srcPortMax = parseIntAttribute(srcPortMaxAttr, "srcPortMax");
            if (destPortAttr)
                filter.destPortMin = filter.destPortMax = parseIntAttribute(destPortAttr, "destPort");
            if (destPortMinAttr)
                filter.destPortMin = parseIntAttribute(destPortMinAttr, "destPortMin");
            if (destPortMaxAttr)
                filter.destPortMax = parseIntAttribute(destPortMaxAttr, "destPortMax");

            addFilter(filter);
        }
        catch (std::exception& e) {
            throw cRuntimeError("Error in XML <filter> element at %s: %s", filterElement->getSourceLocation(), e.what());
        }
    }
}

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

overrideprotectedvirtual

{
    cPacket *packet = check_and_cast<cPacket *>(msg);

    numRcvd++;
    int gateIndex = classifyPacket(packet);
    emit(pkClassSignal, gateIndex);

    if (gateIndex >= 0)
        send(packet, "outs", gateIndex);
    else
        send(packet, "defaultOut");
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        numOutGates = gateSize("outs");

        numRcvd = 0;
        WATCH(numRcvd);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {
        cXMLElement *config = par("filters").xmlValue();
        configureFilters(config);
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::MultiFieldClassifier::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[20] = "";
    if (numRcvd > 0)
        sprintf(buf + strlen(buf), "rcvd:%d ", numRcvd);
    getDisplayString().setTagArg("t", 0, buf);
}

Member Data Documentation

std::vector<Filter> inet::MultiFieldClassifier::filters

protected

int inet::MultiFieldClassifier::numOutGates = 0

protected

int inet::MultiFieldClassifier::numRcvd = 0

protected

simsignal_t inet::MultiFieldClassifier::pkClassSignal = registerSignal("pkClass")

staticprotected

Referenced by inet::MultiFieldClassifier::Filter::matches().

---

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

• MultiFieldClassifier.h
• MultiFieldClassifier.cc