inet::PcapRecorder Class Reference

Dumps every packet using the IPacketWriter and PacketDump classes. More...

#include <PcapRecorder.h>

Inheritance diagram for inet::PcapRecorder:

Classes
class	IHelper

Public Member Functions
	PcapRecorder ()
virtual	~PcapRecorder ()
virtual const char *	resolveDirective (char directive) const override

Protected Types
typedef std::map< simsignal_t, Direction >	SignalList

Protected Member Functions
virtual void	initialize () override
virtual void	handleMessage (cMessage *msg) override
virtual void	refreshDisplay () const override
virtual void	updateDisplayString () const
virtual void	finish () override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual void	recordPacket (const cPacket *msg, Direction direction, cComponent *source)
virtual bool	matchesLinkType (PcapLinkType pcapLinkType, const Protocol *protocol) const
virtual Packet *	tryConvertToLinkType (const Packet *packet, PcapLinkType pcapLinkType, const Protocol *protocol) const
virtual PcapLinkType	protocolToLinkType (const Protocol *protocol) const

Protected Attributes
std::vector< const Protocol * >	dumpProtocols
SignalList	signalList
IPcapWriter *	pcapWriter = nullptr
unsigned int	snaplen = 0
bool	dumpBadFrames = false
PacketFilter	packetFilter
int	numRecorded = 0
bool	verbose = false
bool	recordPcap = false
std::vector< IHelper * >	helpers
PacketPrinter	packetPrinter

Static Protected Attributes
static simsignal_t	packetRecordedSignal = registerSignal("packetRecorded")

Detailed Description

Dumps every packet using the IPacketWriter and PacketDump classes.

Member Typedef Documentation

SignalList

typedef std::map<simsignal_t, Direction> inet::PcapRecorder::SignalList

protected

Constructor & Destructor Documentation

PcapRecorder()

inet::PcapRecorder::PcapRecorder

(

)

                           : cSimpleModule()
{
}

~PcapRecorder()

inet::PcapRecorder::~PcapRecorder ( )

virtual

{
    delete pcapWriter;
    for (auto helper : helpers)
        delete helper;
}

Member Function Documentation

finish()

void inet::PcapRecorder::finish ( )

overrideprotectedvirtual

{
    pcapWriter->close();
}

handleMessage()

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

overrideprotectedvirtual

{
    throw cRuntimeError("This module does not handle messages");
}

initialize()

void inet::PcapRecorder::initialize ( )

overrideprotectedvirtual

{
    verbose = par("verbose");
    snaplen = this->par("snaplen");
    dumpBadFrames = par("dumpBadFrames");
    signalList.clear();
    packetFilter.setExpression(par("packetFilter").objectValue());
 
    {
        cStringTokenizer signalTokenizer(par("sendingSignalNames"));
 
        while (signalTokenizer.hasMoreTokens())
            signalList[registerSignal(signalTokenizer.nextToken())] = DIRECTION_OUTBOUND;
    }
 
    {
        cStringTokenizer signalTokenizer(par("receivingSignalNames"));
 
        while (signalTokenizer.hasMoreTokens())
            signalList[registerSignal(signalTokenizer.nextToken())] = DIRECTION_INBOUND;
    }
 
    {
        cStringTokenizer protocolTokenizer(par("dumpProtocols"));
 
        while (protocolTokenizer.hasMoreTokens())
            dumpProtocols.push_back(Protocol::getProtocol(protocolTokenizer.nextToken()));
    }
 
    {
        cStringTokenizer protocolTokenizer(par("helpers"));
 
        while (protocolTokenizer.hasMoreTokens())
            helpers.push_back(check_and_cast<IHelper *>(createOne(protocolTokenizer.nextToken())));
    }
 
    const char *moduleNames = par("moduleNamePatterns");
    cStringTokenizer moduleTokenizer(moduleNames);
 
    while (moduleTokenizer.hasMoreTokens()) {
        bool found = false;
        std::string mname(moduleTokenizer.nextToken());
        bool isAllIndex = (mname.length() > 3) && mname.rfind("[*]") == mname.length() - 3;
 
        if (isAllIndex)
            mname.replace(mname.length() - 3, 3, "");
 
        if (mname[0] == '.') {
            for (auto& elem : signalList)
                getParentModule()->subscribe(elem.first, this);
            found = true;
        }
        else {
            for (cModule::SubmoduleIterator i(getParentModule()); !i.end(); i++) {
                cModule *submod = *i;
                if (0 == strcmp(isAllIndex ? submod->getName() : submod->getFullName(), mname.c_str())) {
                    found = true;
 
                    for (auto& elem : signalList) {
                        if (!submod->isSubscribed(elem.first, this)) {
                            submod->subscribe(elem.first, this);
                            EV_INFO << "Subscribing to " << submod->getFullPath() << ":" << getSignalName(elem.first) << EV_ENDL;
                        }
                    }
                }
            }
        }
 
        if (!found && !isAllIndex)
            EV_INFO << "The module " << mname << (isAllIndex ? "[*]" : "") << " not found" << EV_ENDL;
    }
 
    const char *file = par("pcapFile");
    const char *fileFormat = par("fileFormat");
    if (!strcmp(fileFormat, "pcap"))
        pcapWriter = new PcapWriter();
    else if (!strcmp(fileFormat, "pcapng"))
        pcapWriter = new PcapngWriter();
    else
        throw cRuntimeError("Unknown fileFormat parameter");
    recordPcap = *file != '\0';
    if (recordPcap) {
        pcapWriter->open(file, snaplen);
        pcapWriter->setFlush(par("alwaysFlush"));
    }
 
    WATCH(numRecorded);
}

matchesLinkType()

bool inet::PcapRecorder::matchesLinkType ( PcapLinkType  pcapLinkType, const Protocol *  protocol  ) const

protectedvirtual

{
    if (protocol == nullptr)
        return false;
    else if (*protocol == Protocol::ethernetPhy)
        return pcapLinkType == LINKTYPE_ETHERNET_MPACKET;
    else if (*protocol == Protocol::ethernetMac)
        return pcapLinkType == LINKTYPE_ETHERNET;
    else if (*protocol == Protocol::ppp)
        return pcapLinkType == LINKTYPE_PPP_WITH_DIR;
    else if (*protocol == Protocol::ieee80211Mac)
        return pcapLinkType == LINKTYPE_IEEE802_11;
    else if (*protocol == Protocol::ipv4)
        return pcapLinkType == LINKTYPE_RAW || pcapLinkType == LINKTYPE_IPV4;
    else if (*protocol == Protocol::ipv6)
        return pcapLinkType == LINKTYPE_RAW || pcapLinkType == LINKTYPE_IPV6;
    else if (*protocol == Protocol::ieee802154)
        return pcapLinkType == LINKTYPE_IEEE802_15_4 || pcapLinkType == LINKTYPE_IEEE802_15_4_NOFCS;
    else {
        for (auto helper : helpers) {
            if (helper->matchesLinkType(pcapLinkType, protocol))
                return true;
        }
    }
    return false;
}

Referenced by recordPacket().

protocolToLinkType()

PcapLinkType inet::PcapRecorder::protocolToLinkType ( const Protocol *  protocol ) const

protectedvirtual

{
    if (*protocol == Protocol::ethernetPhy)
        return LINKTYPE_ETHERNET_MPACKET;
    else if (*protocol == Protocol::ethernetMac)
        return LINKTYPE_ETHERNET;
    else if (*protocol == Protocol::ppp)
        return LINKTYPE_PPP_WITH_DIR;
    else if (*protocol == Protocol::ieee80211Mac)
        return LINKTYPE_IEEE802_11;
    else if (*protocol == Protocol::ipv4 || *protocol == Protocol::ipv6)
        return LINKTYPE_RAW;
    else if (*protocol == Protocol::ieee802154)
        return LINKTYPE_IEEE802_15_4;
    else {
        for (auto helper : helpers) {
            auto lt = helper->protocolToLinkType(protocol);
            if (lt != LINKTYPE_INVALID)
                return lt;
        }
    }
    return LINKTYPE_INVALID;
}

Referenced by recordPacket().

receiveSignal()

void inet::PcapRecorder::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    if (pcapWriter->isOpen()) {
        cPacket *packet = dynamic_cast<cPacket *>(obj);
 
        if (packet) {
            auto i = signalList.find(signalID);
            Direction direction = (i != signalList.end()) ? i->second : DIRECTION_UNDEFINED;
            recordPacket(packet, direction, source);
        }
    }
}

recordPacket()

void inet::PcapRecorder::recordPacket ( const cPacket *  msg, Direction  direction, cComponent *  source  )

protectedvirtual

{
    if (auto packet = dynamic_cast<const Packet *>(cpacket)) {
        EV_INFO << "Recording packet" << EV_FIELD(source, source->getFullPath()) << EV_FIELD(direction, direction) << EV_FIELD(packet) << EV_ENDL;
        if (verbose)
            EV_DEBUG << "Dumping packet" << EV_FIELD(packet, packetPrinter.printPacketToString(const_cast<Packet *>(packet), "%i")) << EV_ENDL;
        if (recordPcap && packetFilter.matches(packet) && (dumpBadFrames || !packet->hasBitError())) {
            // get Direction
            if (direction == DIRECTION_UNDEFINED) {
                if (auto directionTag = packet->findTag<DirectionTag>())
                    direction = directionTag->getDirection();
            }
 
            // get NetworkInterface
            auto srcModule = check_and_cast<cModule *>(source);
            auto networkInterface = findContainingNicModule(srcModule);
            if (networkInterface == nullptr) {
                int ifaceId = -1;
                if (direction == DIRECTION_OUTBOUND) {
                    if (auto ifaceTag = packet->findTag<InterfaceReq>())
                        ifaceId = ifaceTag->getInterfaceId();
                }
                else if (direction == DIRECTION_INBOUND) {
                    if (auto ifaceTag = packet->findTag<InterfaceInd>())
                        ifaceId = ifaceTag->getInterfaceId();
                }
                if (ifaceId != -1) {
                    auto ift = check_and_cast_nullable<InterfaceTable *>(getContainingNode(srcModule)->getSubmodule("interfaceTable"));
                    networkInterface = ift->getInterfaceById(ifaceId);
                }
            }
 
            const auto& packetProtocolTag = packet->getTag<PacketProtocolTag>();
            auto protocol = packetProtocolTag->getProtocol();
            if (packetProtocolTag->getFrontOffset() == b(0) && packetProtocolTag->getBackOffset() == b(0) && contains(dumpProtocols, protocol)) {
                auto pcapLinkType = protocolToLinkType(protocol);
                if (pcapLinkType == LINKTYPE_INVALID)
                    throw cRuntimeError("Cannot determine the PCAP link type from protocol '%s'", protocol->getName());
 
                if (matchesLinkType(pcapLinkType, protocol)) {
                    pcapWriter->writePacket(simTime(), packet, direction, networkInterface, pcapLinkType);
                    numRecorded++;
                    emit(packetRecordedSignal, packet);
                }
                else {
                    if (auto convertedPacket = tryConvertToLinkType(packet, pcapLinkType, protocol)) {
                        pcapWriter->writePacket(simTime(), convertedPacket, direction, networkInterface, pcapLinkType);
                        numRecorded++;
                        emit(packetRecordedSignal, packet);
                        delete convertedPacket;
                    }
                    else
                        throw cRuntimeError("The protocol '%s' doesn't match PCAP link type %d", protocol->getName(), pcapLinkType);
                }
            }
        }
    }
}

Referenced by receiveSignal().

refreshDisplay()

void inet::PcapRecorder::refreshDisplay ( ) const

overrideprotectedvirtual

{
    updateDisplayString();
}

resolveDirective()

const char * inet::PcapRecorder::resolveDirective ( char  directive ) const

overridevirtual

Implements inet::StringFormat::IDirectiveResolver.

{
    static std::string result;
    switch (directive) {
        case 'n':
            result = std::to_string(numRecorded);
            break;
        default:
            throw cRuntimeError("Unknown directive: %c", directive);
    }
    return result.c_str();
}

tryConvertToLinkType()

Packet * inet::PcapRecorder::tryConvertToLinkType ( const Packet *  packet, PcapLinkType  pcapLinkType, const Protocol *  protocol  ) const

protectedvirtual

{
    for (IHelper *helper : helpers) {
        if (auto newPacket = helper->tryConvertToLinkType(packet, pcapLinkType, protocol))
            return newPacket;
    }
    return nullptr;
}

Referenced by recordPacket().

updateDisplayString()

void inet::PcapRecorder::updateDisplayString ( ) const

protectedvirtual

{
    if (getEnvir()->isGUI()) {
        auto text = StringFormat::formatString(par("displayStringTextFormat"), this);
        getDisplayString().setTagArg("t", 0, text);
    }
}

Referenced by refreshDisplay().

Member Data Documentation

dumpBadFrames

bool inet::PcapRecorder::dumpBadFrames = false

protected

Referenced by initialize(), and recordPacket().

dumpProtocols

std::vector<const Protocol *> inet::PcapRecorder::dumpProtocols

protected

Referenced by initialize(), and recordPacket().

helpers

std::vector<IHelper *> inet::PcapRecorder::helpers

protected

Referenced by initialize(), matchesLinkType(), protocolToLinkType(), tryConvertToLinkType(), and ~PcapRecorder().

numRecorded

int inet::PcapRecorder::numRecorded = 0

protected

Referenced by initialize(), recordPacket(), and resolveDirective().

packetFilter

PacketFilter inet::PcapRecorder::packetFilter

protected

Referenced by initialize(), and recordPacket().

packetPrinter

PacketPrinter inet::PcapRecorder::packetPrinter

protected

Referenced by recordPacket().

packetRecordedSignal

simsignal_t inet::PcapRecorder::packetRecordedSignal = registerSignal("packetRecorded")

staticprotected

Referenced by recordPacket().

pcapWriter

IPcapWriter* inet::PcapRecorder::pcapWriter = nullptr

protected

Referenced by finish(), initialize(), receiveSignal(), recordPacket(), and ~PcapRecorder().

recordPcap

bool inet::PcapRecorder::recordPcap = false

protected

Referenced by initialize(), and recordPacket().

signalList

SignalList inet::PcapRecorder::signalList

protected

Referenced by initialize(), and receiveSignal().

snaplen

unsigned int inet::PcapRecorder::snaplen = 0

protected

Referenced by initialize().

verbose

bool inet::PcapRecorder::verbose = false

protected

Referenced by initialize(), and recordPacket().

---

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

• PcapRecorder.h
• PcapRecorder.cc