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

#include <PcapRecorder.h>

Inheritance diagram for inet::PcapRecorder:

Public Member Functions
	PcapRecorder ()

	~PcapRecorder ()

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

Protected Member Functions
virtual void	initialize () override

virtual void	handleMessage (cMessage *msg) override

virtual void	finish () override

virtual void	receiveSignal (cComponent source, simsignal_t signalID, cObject obj, cObject *details) override

virtual void	recordPacket (cPacket *msg, bool l2r)

Protected Attributes
SignalList	signalList

PacketDump	packetDumper

PcapDump	pcapDumper

unsigned int	snaplen = 0

bool	dumpBadFrames = false

Detailed Description

Dumps every packet using the PcapDump and PacketDump classes.

Member Typedef Documentation

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

protected

Constructor & Destructor Documentation

inet::PcapRecorder::PcapRecorder ( )

                            : cSimpleModule(), pcapDumper()
 {
 }

inet::PcapRecorder::~PcapRecorder ( )

39 {

40 }

Member Function Documentation

void inet::PcapRecorder::finish ( )

overrideprotectedvirtual

 {
     packetDumper.dump("", "pcapRecorder finished");
     pcapDumper.closePcap();
 }

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

overrideprotectedvirtual

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

void inet::PcapRecorder::initialize ( )

overrideprotectedvirtual

 {
     const char *file = par("pcapFile");
     snaplen = this->par("snaplen");
     dumpBadFrames = par("dumpBadFrames").boolValue();
     packetDumper.setVerbose(par("verbose").boolValue());
     packetDumper.setOutStream(EVSTREAM);
     signalList.clear();
 
     {
         cStringTokenizer signalTokenizer(par("sendingSignalNames"));
 
         while (signalTokenizer.hasMoreTokens())
             signalList[registerSignal(signalTokenizer.nextToken())] = true;
     }
 
     {
         cStringTokenizer signalTokenizer(par("receivingSignalNames"));
 
         while (signalTokenizer.hasMoreTokens())
             signalList[registerSignal(signalTokenizer.nextToken())] = false;
     }
 
     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, "");
 
         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 << "PcapRecorder " << getFullPath() << " subscribed to "
                            << submod->getFullPath() << ":" << getSignalName(elem.first) << endl;
                     }
                 }
             }
         }
 
         if (!found) {
             EV << "The module " << mname << (isAllIndex ? "[*]" : "")
                << " not found for PcapRecorder " << getFullPath() << endl;
         }
     }
 
     if (*file) {
         pcapDumper.openPcap(file, snaplen);
         pcapDumper.setFlushParameter((bool)par("alwaysFlush"));
     }
 }

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

overrideprotectedvirtual

 {
     Enter_Method_Silent();
     cPacket *packet = dynamic_cast<cPacket *>(obj);
 
     if (packet) {
         SignalList::const_iterator i = signalList.find(signalID);
         bool l2r = (i != signalList.end()) ? i->second : true;
         recordPacket(packet, l2r);
     }
 }

void inet::PcapRecorder::recordPacket	(	cPacket *	msg,
		bool	l2r
	)

protectedvirtual

Referenced by receiveSignal().

 {
     EV << "PcapRecorder::recordPacket(" << msg->getFullPath() << ", " << l2r << ")\n";
     packetDumper.dumpPacket(l2r, msg);
 
 #if defined(WITH_IPv4) || defined(WITH_IPv6)
     if (!pcapDumper.isOpen())
         return;
 
     bool hasBitError = false;
 
 #ifdef WITH_IPv4
     IPv4Datagram *ip4Packet = nullptr;
 #endif // ifdef WITH_IPv4
 #ifdef WITH_IPv6
     IPv6Datagram *ip6Packet = nullptr;
 #endif // ifdef WITH_IPv6
     while (msg) {
         if (msg->hasBitError())
             hasBitError = true;
 #ifdef WITH_IPv4
         if (nullptr != (ip4Packet = dynamic_cast<IPv4Datagram *>(msg))) {
             break;
         }
 #endif // ifdef WITH_IPv4
 #ifdef WITH_IPv6
         if (nullptr != (ip6Packet = dynamic_cast<IPv6Datagram *>(msg))) {
             break;
         }
 #endif // ifdef WITH_IPv6
 
         msg = msg->getEncapsulatedPacket();
     }
 #endif // if defined(WITH_IPv4) || defined(WITH_IPv6)
 #ifdef WITH_IPv4
     if (ip4Packet && (dumpBadFrames || !hasBitError)) {
         const simtime_t stime = simTime();
         pcapDumper.writeFrame(stime, ip4Packet);
     }
 #endif // ifdef WITH_IPv4
 #ifdef WITH_IPv6
     if (ip6Packet && (dumpBadFrames || !hasBitError)) {
         const simtime_t stime = simTime();
         pcapDumper.writeIPv6Frame(stime, ip6Packet);
     }
 #endif // ifdef WITH_IPv6
 }