inet::PcapWriter Class Reference

Dumps packets into a PCAP file; see the "pcap-savefile" man page or http://www.tcpdump.org/ for details on the file format. More...

#include <PcapWriter.h>

Inheritance diagram for inet::PcapWriter:

Public Member Functions
	PcapWriter ()
	Constructor. More...
	~PcapWriter ()
	Destructor. More...
void	open (const char *filename, unsigned int snaplen) override
	Opens a PCAP file with the given file name. More...
bool	isOpen () const override
	Returns true if the pcap file is currently open. More...
void	writePacket (simtime_t time, const Packet *packet, Direction direction, NetworkInterface *ie, PcapLinkType linkType) override
	Records the given packet into the output file if it is open, and throws an exception otherwise. More...
void	close () override
	Closes the output file if it is open. More...
void	setFlush (bool flush) override
	Force flushing of pcap dump. More...
Public Member Functions inherited from inet::IPcapWriter
virtual	~IPcapWriter ()

Protected Member Functions
void	writeHeader (PcapLinkType linkType)

Protected Attributes
std::string	fileName
FILE *	dumpfile = nullptr
unsigned int	snaplen = 0
PcapLinkType	network = LINKTYPE_INVALID
bool	flush = false
bool	needHeader = true

Detailed Description

Dumps packets into a PCAP file; see the "pcap-savefile" man page or http://www.tcpdump.org/ for details on the file format.

Note: The file is currently recorded in the "classic" format, not in the "Next Generation" file format also on tcpdump.org.

Constructor & Destructor Documentation

PcapWriter()

inet::PcapWriter::PcapWriter ( )

inline

Constructor.

It does not open the output file.

{}

~PcapWriter()

inet::PcapWriter::~PcapWriter

(

)

Destructor.

It closes the output file if it is open.

{
    PcapWriter::close(); // NOTE: admitting that this will not call overridden methods from the destructor
}

Member Function Documentation

close()

void inet::PcapWriter::close ( )

overridevirtual

Closes the output file if it is open.

Implements inet::IPcapWriter.

{
    if (dumpfile) {
        fclose(dumpfile);
        dumpfile = nullptr;
    }
}

Referenced by inet::queueing::PcapFilePacketConsumer::finish(), and ~PcapWriter().

isOpen()

bool inet::PcapWriter::isOpen ( ) const

inlineoverridevirtual

Returns true if the pcap file is currently open.

Implements inet::IPcapWriter.

{ return dumpfile != nullptr; }

open()

void inet::PcapWriter::open ( const char *  filename, unsigned int  snaplen  )

overridevirtual

Opens a PCAP file with the given file name.

The snaplen parameter is the length that packets will be truncated to. Throws an exception if the file cannot be opened.

Implements inet::IPcapWriter.

{
    if (opp_isempty(filename))
        throw cRuntimeError("Cannot open pcap file: file name is empty");
 
    inet::utils::makePathForFile(filename);
    dumpfile = fopen(filename, "wb");
    fileName = filename;
 
    if (!dumpfile)
        throw cRuntimeError("Cannot open pcap file [%s] for writing: %s", filename, strerror(errno));
 
    snaplen = snaplen_par;
    needHeader = true;
    network = LINKTYPE_INVALID;
 
    flush = false;
}

Referenced by inet::queueing::PcapFilePacketConsumer::initialize().

setFlush()

void inet::PcapWriter::setFlush ( bool  flush )

inlineoverridevirtual

Force flushing of pcap dump.

Implements inet::IPcapWriter.

{ this->flush = flush; }

Referenced by inet::queueing::PcapFilePacketConsumer::initialize().

writeHeader()

void inet::PcapWriter::writeHeader ( PcapLinkType  linkType )

protected

{
    struct pcap_hdr fh;
 
    fh.magic = PCAP_MAGIC;
    fh.version_major = 2;
    fh.version_minor = 4;
    fh.thiszone = 0;
    fh.sigfigs = 0;
    fh.snaplen = snaplen;
    fh.network = linkType;
    fwrite(&fh, sizeof(fh), 1, dumpfile);
}

Referenced by writePacket().

writePacket()

void inet::PcapWriter::writePacket ( simtime_t  time, const Packet *  packet, Direction  direction, NetworkInterface *  ie, PcapLinkType  linkType  )

overridevirtual

Records the given packet into the output file if it is open, and throws an exception otherwise.

Implements inet::IPcapWriter.

{
    if (!dumpfile)
        throw cRuntimeError("Cannot write frame: pcap output file is not open");
 
    if (needHeader) {
        if (linkTypePar == LINKTYPE_INVALID)
            throw cRuntimeError("invalid linktype arrived");
        writeHeader(linkTypePar);
        network = linkTypePar;
        needHeader = false;
    }
    else {
        if (network != linkTypePar)
            throw cRuntimeError("linktype mismatch error: required linktype = %d, arrived linktype = %d", network, linkTypePar);
    }
 
    (void)direction; // unused
    (void)ie; // unused
 
    EV_INFO << "Writing packet" << EV_FIELD(packet) << EV_FIELD(fileName) << EV_ENDL;
    uint8_t buf[MAXBUFLENGTH];
    memset(buf, 0, sizeof(buf));
 
    struct pcaprec_hdr ph;
    ph.ts_sec = (int32_t)stime.inUnit(SIMTIME_S);
    ph.ts_usec = (uint32_t)(stime.inUnit(SIMTIME_US) - (uint32_t)1000000 * stime.inUnit(SIMTIME_S));
    auto data = packet->peekDataAsBytes();
    auto bytes = data->getBytes();
    for (size_t i = 0; i < bytes.size(); i++) {
        buf[i] = bytes[i];
    }
    ph.orig_len = B(data->getChunkLength()).get();
 
    ph.incl_len = ph.orig_len > snaplen ? snaplen : ph.orig_len;
    fwrite(&ph, sizeof(ph), 1, dumpfile);
    fwrite(buf, ph.incl_len, 1, dumpfile);
    if (flush)
        fflush(dumpfile);
}

Referenced by inet::queueing::PcapFilePacketConsumer::pushPacket().

Member Data Documentation

dumpfile

FILE* inet::PcapWriter::dumpfile = nullptr

protected

Referenced by close(), open(), writeHeader(), and writePacket().

fileName

std::string inet::PcapWriter::fileName

protected

Referenced by open(), and writePacket().

flush

bool inet::PcapWriter::flush = false

protected

Referenced by open(), and writePacket().

needHeader

bool inet::PcapWriter::needHeader = true

protected

Referenced by open(), and writePacket().

network

PcapLinkType inet::PcapWriter::network = LINKTYPE_INVALID

protected

Referenced by open(), and writePacket().

snaplen

unsigned int inet::PcapWriter::snaplen = 0

protected

Referenced by open(), writeHeader(), and writePacket().

---

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

• PcapWriter.h
• PcapWriter.cc