inet::PacketFilter Class Reference

This class provides a generic filter for packets. More...

#include <PacketFilter.h>

Classes
class	DynamicExpressionResolver
class	PacketDissectorCallback

Public Member Functions
	PacketFilter ()
virtual	~PacketFilter ()
void	setPattern (const char *pattern)
void	setExpression (const char *expression)
void	setExpression (cDynamicExpression *expression)
void	setExpression (cOwnedDynamicExpression *expression)
void	setExpression (cValueHolder *expression)
void	setExpression (cObject *expression)
void	setExpression (cValue &expression)
bool	matches (const cPacket *packet) const

Protected Member Functions
const cObject *	findPacketTag (const char *className) const

Protected Attributes
cDynamicExpression *	filterExpression = nullptr
cMatchExpression *	matchExpression = nullptr
PacketDissectorCallback *	packetDissectorCallback = nullptr
const cPacket *	cpacket = nullptr
std::multimap< const Protocol *, Chunk * >	protocolToChunkMap
std::multimap< std::string, Chunk * >	classNameToChunkMap

Detailed Description

This class provides a generic filter for packets.

The filter is expressed as two patterns using the cMatchExpression format. One filter is applied to the Packet the other one is applied to each Chunk in the packet using the PacketDissector.

Constructor & Destructor Documentation

PacketFilter()

inet::PacketFilter::PacketFilter

(

)

{
    packetDissectorCallback = new PacketDissectorCallback(this);
}

~PacketFilter()

inet::PacketFilter::~PacketFilter ( )

virtual

{
    delete filterExpression;
    delete matchExpression;
    delete packetDissectorCallback;
}

Member Function Documentation

findPacketTag()

const cObject * inet::PacketFilter::findPacketTag ( const char *  className ) const

protected

{
    if (auto packet = dynamic_cast<const Packet *>(cpacket)) {
        for (int i = 0; i < packet->getNumTags(); i++) {
            const auto& tag = packet->getTag(i);
            std::string tagClassName = tag->getClassName();
            auto index = tagClassName.rfind("::");
            if (index != std::string::npos)
                tagClassName = tagClassName.substr(index + 2);
            if (!strcmp(tagClassName.c_str(), className))
                return tag.get();
        }
        return nullptr;
    }
    else
        return nullptr;
}

matches()

bool inet::PacketFilter::matches

(

const cPacket *

packet

)

const

{
    this->cpacket = cpacket;
    protocolToChunkMap.clear();
    classNameToChunkMap.clear();
    if (matchExpression == nullptr && filterExpression == nullptr)
        return true;
    else {
        bool result = true;
        if (matchExpression != nullptr) {
            cMatchableString matchableString(cpacket->getFullName());
            result &= matchExpression->matches(&matchableString);
        }
        if (filterExpression != nullptr) {
            if (auto packet = dynamic_cast<const Packet *>(cpacket)) {
                PacketDissector packetDissector(ProtocolDissectorRegistry::globalRegistry, *packetDissectorCallback);
                packetDissector.dissectPacket(const_cast<Packet *>(packet));
            }
            result &= filterExpression->evaluate().boolValue();
        }
        return result;
    }
}

Referenced by inet::PacketEmitter::emitPacket(), inet::StreamIdentifier::processPacket(), and inet::PcapRecorder::recordPacket().

setExpression() [1/6]

void inet::PacketFilter::setExpression

(

cDynamicExpression *

expression

)

{
    delete filterExpression;
    filterExpression = expression;
    filterExpression->setResolver(new DynamicExpressionResolver(this));
}

setExpression() [2/6]

void inet::PacketFilter::setExpression

(

cObject *

expression

)

{
    if (auto ownedDynamicExpression = dynamic_cast<cOwnedDynamicExpression *>(expression))
        setExpression(ownedDynamicExpression);
    else if (auto dynamicExpression = dynamic_cast<cDynamicExpression *>(expression))
        setExpression(dynamicExpression);
    else if (auto valueHolder = dynamic_cast<cValueHolder *>(expression))
        setExpression(valueHolder);
    else
        throw cRuntimeError("Unknown expression type");
}

setExpression() [3/6]

void inet::PacketFilter::setExpression

(

const char *

expression

)

{
    delete filterExpression;
    filterExpression = nullptr;
    if (strcmp(expression, "true")) {
        filterExpression = new cDynamicExpression();
        filterExpression->parse(expression, new DynamicExpressionResolver(this));
    }
}

Referenced by inet::StreamDecoder::configureMappings(), inet::PacketEmitter::initialize(), inet::PcapRecorder::initialize(), inet::Ipv4NatTable::parseConfig(), inet::StreamIdentifier::processPacket(), and setExpression().

setExpression() [4/6]

void inet::PacketFilter::setExpression

(

cOwnedDynamicExpression *

expression

)

{
    delete filterExpression;
    filterExpression = expression->dup();
    filterExpression->setResolver(new DynamicExpressionResolver(this));
}

setExpression() [5/6]

void inet::PacketFilter::setExpression

(

cValue &

expression

)

{
    if (expression.getType() == cValue::POINTER)
        setExpression(expression.objectValue());
    else
        setPattern(expression.stringValue());
}

setExpression() [6/6]

void inet::PacketFilter::setExpression

(

cValueHolder *

expression

)

{
    auto& value = expression->get();
    if (value.getType() == cValue::POINTER)
        setExpression(check_and_cast<cDynamicExpression *>(value.objectValue())->dup());
    else
        setPattern(value.stringValue());
}

setPattern()

void inet::PacketFilter::setPattern

(

const char *

pattern

)

{
    delete matchExpression;
    matchExpression = nullptr;
    if (strcmp(pattern, "*")) {
        matchExpression = new cMatchExpression();
        matchExpression->setPattern(pattern, false, true, true);
    }
}

Referenced by setExpression().

Member Data Documentation

classNameToChunkMap

std::multimap<std::string, Chunk *> inet::PacketFilter::classNameToChunkMap

mutableprotected

Referenced by matches(), inet::PacketFilter::DynamicExpressionResolver::readMember(), inet::PacketFilter::DynamicExpressionResolver::readVariable(), and inet::PacketFilter::PacketDissectorCallback::visitChunk().

cpacket

const cPacket* inet::PacketFilter::cpacket = nullptr

mutableprotected

Referenced by findPacketTag(), and matches().

filterExpression

cDynamicExpression* inet::PacketFilter::filterExpression = nullptr

protected

Referenced by matches(), setExpression(), and ~PacketFilter().

matchExpression

cMatchExpression* inet::PacketFilter::matchExpression = nullptr

protected

Referenced by matches(), setPattern(), and ~PacketFilter().

packetDissectorCallback

PacketDissectorCallback* inet::PacketFilter::packetDissectorCallback = nullptr

protected

Referenced by matches(), PacketFilter(), and ~PacketFilter().

protocolToChunkMap

std::multimap<const Protocol *, Chunk *> inet::PacketFilter::protocolToChunkMap

mutableprotected

Referenced by matches(), inet::PacketFilter::DynamicExpressionResolver::readMember(), inet::PacketFilter::DynamicExpressionResolver::readVariable(), and inet::PacketFilter::PacketDissectorCallback::visitChunk().

---

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

• common/packet/PacketFilter.h
• common/packet/PacketFilter.cc