inet::QosClassifier Class Reference

This module classifies and assigns User Priority to packets. More...

#include <QosClassifier.h>

Inheritance diagram for inet::QosClassifier:

Public Member Functions
	QosClassifier ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
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

Protected Member Functions
virtual int	parseUserPriority (const char *text)
virtual void	parseUserPriorityMap (const char *text, std::map< int, int > &upMap)
virtual int	getUserPriority (cMessage *msg)
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override

Protected Attributes
int	defaultUp
std::map< int, int >	ipProtocolUpMap
std::map< int, int >	udpPortUpMap
std::map< int, int >	tcpPortUpMap

Detailed Description

This module classifies and assigns User Priority to packets.

Constructor & Destructor Documentation

QosClassifier()

inet::QosClassifier::QosClassifier ( )

inline

{}

Member Function Documentation

getUserPriority()

int inet::QosClassifier::getUserPriority ( cMessage *  msg )

protectedvirtual

{
    int ipProtocol = -1;
 
#if defined(INET_WITH_ETHERNET) || defined(INET_WITH_IPv4) || defined(INET_WITH_IPv6) || defined(INET_WITH_UDP) || defined(INET_WITH_TCP_COMMON)
    auto packet = check_and_cast<Packet *>(msg);
    auto packetProtocol = packet->getTag<PacketProtocolTag>()->getProtocol();
    int ethernetMacProtocol = -1;
    b ethernetMacHeaderLength = b(0);
    b ipHeaderLength = b(-1);
#endif
 
#ifdef INET_WITH_ETHERNET
    if (packetProtocol == &Protocol::ethernetMac) {
        const auto& ethernetMacHeader = packet->peekAtFront<EthernetMacHeader>();
        ethernetMacProtocol = ethernetMacHeader->getTypeOrLength();
        ethernetMacHeaderLength = ethernetMacHeader->getChunkLength();
    }
#endif
 
#ifdef INET_WITH_IPv4
    if (ethernetMacProtocol == ETHERTYPE_IPv4 || packetProtocol == &Protocol::ipv4) {
        const auto& ipv4Header = packet->peekDataAt<Ipv4Header>(ethernetMacHeaderLength);
        ipProtocol = ipv4Header->getProtocolId();
        ipHeaderLength = ipv4Header->getChunkLength();
    }
#endif
 
#ifdef INET_WITH_IPv6
    if (ethernetMacProtocol == ETHERTYPE_IPv6 || packetProtocol == &Protocol::ipv6) {
        const auto& ipv6Header = packet->peekDataAt<Ipv6Header>(ethernetMacHeaderLength);
        ipProtocol = ipv6Header->getProtocolId();
        ipHeaderLength = ipv6Header->getChunkLength();
    }
#endif
 
    if (ipProtocol == -1)
        return defaultUp;
    auto it = ipProtocolUpMap.find(ipProtocol);
    if (it != ipProtocolUpMap.end())
        return it->second;
 
#ifdef INET_WITH_UDP
    if (ipProtocol == IP_PROT_UDP) {
        const auto& udpHeader = packet->peekDataAt<UdpHeader>(ethernetMacHeaderLength + ipHeaderLength);
        unsigned int srcPort = udpHeader->getSourcePort();
        unsigned int destPort = udpHeader->getDestinationPort();
        auto it = udpPortUpMap.find(destPort);
        if (it != udpPortUpMap.end())
            return it->second;
        it = udpPortUpMap.find(srcPort);
        if (it != udpPortUpMap.end())
            return it->second;
    }
#endif
 
#ifdef INET_WITH_TCP_COMMON
    if (ipProtocol == IP_PROT_TCP) {
        const auto& tcpHeader = packet->peekDataAt<tcp::TcpHeader>(ethernetMacHeaderLength + ipHeaderLength);
        unsigned int srcPort = tcpHeader->getSourcePort();
        unsigned int destPort = tcpHeader->getDestinationPort();
        auto it = tcpPortUpMap.find(destPort);
        if (it != tcpPortUpMap.end())
            return it->second;
        it = tcpPortUpMap.find(srcPort);
        if (it != tcpPortUpMap.end())
            return it->second;
    }
#endif
 
    return defaultUp;
}

Referenced by handleMessage().

handleMessage()

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

overridevirtual

{
    auto packet = check_and_cast<Packet *>(msg);
    packet->addTagIfAbsent<UserPriorityReq>()->setUserPriority(getUserPriority(msg));
    send(msg, "out");
}

handleRegisterProtocol()

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

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (!strcmp("in", g->getName()))
        registerProtocol(protocol, gate("out"), servicePrimitive);
    else if (!strcmp("out", g->getName()))
        registerService(protocol, gate("in"), servicePrimitive);
    else
        throw cRuntimeError("Unknown gate: %s", g->getName());
}

handleRegisterService()

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

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

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

initialize()

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

overridevirtual

{
    if (stage == INITSTAGE_LOCAL) {
        defaultUp = parseUserPriority(par("defaultUp"));
        parseUserPriorityMap(par("ipProtocolUpMap"), ipProtocolUpMap);
        parseUserPriorityMap(par("udpPortUpMap"), udpPortUpMap);
        parseUserPriorityMap(par("tcpPortUpMap"), tcpPortUpMap);
    }
}

numInitStages()

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

parseUserPriority()

int inet::QosClassifier::parseUserPriority ( const char *  text )

protectedvirtual

{
    if (!strcmp(text, "BE"))
        return UP_BE;
    else if (!strcmp(text, "BK"))
        return UP_BK;
    else if (!strcmp(text, "BK2"))
        return UP_BK2;
    else if (!strcmp(text, "EE"))
        return UP_EE;
    else if (!strcmp(text, "CL"))
        return UP_CL;
    else if (!strcmp(text, "VI"))
        return UP_VI;
    else if (!strcmp(text, "VO"))
        return UP_VO;
    else if (!strcmp(text, "NC"))
        return UP_NC;
    else
        throw cRuntimeError("Unknown user priority: '%s'", text);
}

Referenced by initialize(), and parseUserPriorityMap().

parseUserPriorityMap()

void inet::QosClassifier::parseUserPriorityMap ( const char *  text, std::map< int, int > &  upMap  )

protectedvirtual

{
    cStringTokenizer tokenizer(text);
    while (tokenizer.hasMoreTokens()) {
        const char *keyString = tokenizer.nextToken();
        const char *upString = tokenizer.nextToken();
        if (!keyString || !upString)
            throw cRuntimeError("Insufficient number of values in: '%s'", text);
        int key = std::atoi(keyString);
        int up = parseUserPriority(upString);
        upMap.insert(std::pair<int, int>(key, up));
    }
}

Referenced by initialize().

Member Data Documentation

defaultUp

int inet::QosClassifier::defaultUp

protected

Referenced by getUserPriority(), and initialize().

ipProtocolUpMap

std::map<int, int> inet::QosClassifier::ipProtocolUpMap

protected

Referenced by getUserPriority(), and initialize().

tcpPortUpMap

std::map<int, int> inet::QosClassifier::tcpPortUpMap

protected

Referenced by getUserPriority(), and initialize().

udpPortUpMap

std::map<int, int> inet::QosClassifier::udpPortUpMap

protected

Referenced by getUserPriority(), and initialize().

---

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

• QosClassifier.h
• QosClassifier.cc