inet::PcapngWriter Class Reference

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

#include <PcapngWriter.h>

Inheritance diagram for inet::PcapngWriter:

Public Member Functions
	PcapngWriter ()
	Constructor. More...
	~PcapngWriter ()
	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	writeInterface (NetworkInterface *networkInterface, PcapLinkType linkType)
	Records the interface into the output file. 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 Attributes
std::string	fileName
FILE *	dumpfile = nullptr
bool	flush = false
int	nextPcapngInterfaceId = 0
std::map< int, int >	interfaceModuleIdToPcapngInterfaceId

Detailed Description

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

Constructor & Destructor Documentation

PcapngWriter()

inet::PcapngWriter::PcapngWriter ( )

inline

Constructor.

It does not open the output file.

{}

~PcapngWriter()

inet::PcapngWriter::~PcapngWriter

(

)

Destructor.

It closes the output file if it is open.

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

Member Function Documentation

close()

void inet::PcapngWriter::close ( )

overridevirtual

Closes the output file if it is open.

Implements inet::IPcapWriter.

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

Referenced by ~PcapngWriter().

isOpen()

bool inet::PcapngWriter::isOpen ( ) const

inlineoverridevirtual

Returns true if the pcap file is currently open.

Implements inet::IPcapWriter.

{ return dumpfile != nullptr; }

open()

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

overridevirtual

Opens a PCAP file with the given file name.

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));
 
    flush = false;
 
    // header
    int blockTotalLength = 28;
    ASSERT(blockTotalLength % 4 == 0);
    struct pcapng_section_block_header sbh;
    sbh.blockTotalLength = blockTotalLength;
    sbh.byteOrderMagic = PCAP_MAGIC;
    sbh.majorVersion = 1;
    sbh.minorVersion = 0;
    sbh.sectionLength = -1L;
    fwrite(&sbh, sizeof(sbh), 1, dumpfile);
 
    // trailer
    struct pcapng_section_block_trailer sbt;
    sbt.blockTotalLength = blockTotalLength;
    fwrite(&sbt, sizeof(sbt), 1, dumpfile);
}

setFlush()

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

inlineoverridevirtual

Force flushing of pcap dump.

Implements inet::IPcapWriter.

{ this->flush = flush; }

writeInterface()

void inet::PcapngWriter::writeInterface	(	NetworkInterface *	networkInterface,
		PcapLinkType	linkType
	)

Records the interface into the output file.

{
    EV_INFO << "Writing interface to file" << EV_FIELD(fileName) << EV_FIELD(networkInterface) << EV_ENDL;
    if (!dumpfile)
        throw cRuntimeError("Cannot write interface: pcap output file is not open");
 
    std::string name = networkInterface->getInterfaceName();
    std::string fullPath = networkInterface->getInterfaceFullPath();
    fullPath = fullPath.substr(fullPath.find('.') + 1);
    uint32_t optionsLength = (4 + roundUp(name.length())) + (4 + roundUp(fullPath.length())) + (4 + 8) + (4 + 4 + 4) + 4;
    uint32_t blockTotalLength = 20 + optionsLength;
    ASSERT(blockTotalLength % 4 == 0);
 
    // header
    pcapng_interface_block_header ibh;
    ibh.blockTotalLength = blockTotalLength;
    ibh.linkType = linkType;
    ibh.reserved = 0;
    ibh.snaplen = 0;
    fwrite(&ibh, sizeof(ibh), 1, dumpfile);
 
    // interface name option
    pcapng_option_header doh;
    doh.code = 0x0002;
    doh.length = name.length();
    fwrite(&doh, sizeof(doh), 1, dumpfile);
    fwrite(name.c_str(), name.length(), 1, dumpfile);
    char padding[] = { 0, 0, 0, 0 };
    int paddingLength = pad(name.length());
    fwrite(padding, paddingLength, 1, dumpfile);
 
    // interface description option
    doh.code = 0x0003;
    doh.length = fullPath.length();
    fwrite(&doh, sizeof(doh), 1, dumpfile);
    fwrite(fullPath.c_str(), fullPath.length(), 1, dumpfile);
    paddingLength = pad(fullPath.length());
    fwrite(padding, paddingLength, 1, dumpfile);
 
    // MAC address option
    doh.code = 0x0006;
    doh.length = 6;
    fwrite(&doh, sizeof(doh), 1, dumpfile);
    uint8_t macAddressBytes[6];
    networkInterface->getMacAddress().getAddressBytes(macAddressBytes);
    fwrite(macAddressBytes, 6, 1, dumpfile);
    fwrite(padding, 2, 1, dumpfile);
 
    // IP address/netmask option
    doh.code = 0x0004;
    doh.length = 4 + 4;
    fwrite(&doh, sizeof(doh), 1, dumpfile);
    uint8_t ipAddressBytes[4];
    auto ipv4Address = networkInterface->getIpv4Address();
    for (int i = 0; i < 4; i++) ipAddressBytes[i] = ipv4Address.getDByte(i);
    fwrite(ipAddressBytes, 4, 1, dumpfile);
    auto ipv4Netmask = networkInterface->getIpv4Netmask();
    for (int i = 0; i < 4; i++) ipAddressBytes[i] = ipv4Netmask.getDByte(i);
    fwrite(ipAddressBytes, 4, 1, dumpfile);
 
    // end of options
    uint32_t endOfOptions = 0;
    fwrite(&endOfOptions, sizeof(endOfOptions), 1, dumpfile);
 
    // trailer
    pcapng_interface_block_trailer ibt;
    ibt.blockTotalLength = blockTotalLength;
    fwrite(&ibt, sizeof(ibt), 1, dumpfile);
}

Referenced by writePacket().

writePacket()

void inet::PcapngWriter::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.

{
    EV_INFO << "Writing packet to file" << EV_FIELD(fileName) << EV_FIELD(packet) << EV_ENDL;
    if (!dumpfile)
        throw cRuntimeError("Cannot write frame: pcap output file is not open");
 
    auto it = interfaceModuleIdToPcapngInterfaceId.find(networkInterface->getId());
    int pcapngInterfaceId;
    if (it != interfaceModuleIdToPcapngInterfaceId.end())
        pcapngInterfaceId = it->second;
    else {
        writeInterface(networkInterface, linkType);
        pcapngInterfaceId = nextPcapngInterfaceId++;
        interfaceModuleIdToPcapngInterfaceId[networkInterface->getId()] = pcapngInterfaceId;
    }
 
    if (networkInterface == nullptr)
        throw cRuntimeError("The interface entry not found for packet");
 
    uint32_t optionsLength = (4 + 4) + 4;
    uint32_t blockTotalLength = 32 + roundUp(packet->getByteLength()) + optionsLength;
    ASSERT(blockTotalLength % 4 == 0);
 
    // header
    struct pcapng_packet_block_header pbh;
    pbh.blockTotalLength = blockTotalLength;
    pbh.interfaceId = pcapngInterfaceId;
    pbh.timestampHigh = (int32_t)stime.inUnit(SIMTIME_S);
    pbh.timestampLow = (uint32_t)(stime.inUnit(SIMTIME_US) - (uint32_t)1000000 * stime.inUnit(SIMTIME_S));
    pbh.capturedPacketLength = packet->getByteLength();
    pbh.originalPacketLength = packet->getByteLength();
    fwrite(&pbh, sizeof(pbh), 1, dumpfile);
 
    // packet data
    auto data = packet->peekDataAsBytes();
    auto bytes = data->getBytes();
    fwrite(bytes.data(), packet->getByteLength(), 1, dumpfile);
 
    // packet padding
    char padding[] = { 0, 0, 0, 0 };
    int paddingLength = pad(packet->getByteLength());
    fwrite(padding, paddingLength, 1, dumpfile);
 
    // direction option
    pcapng_option_header doh;
    doh.code = 0x0002;
    doh.length = 4;
    uint32_t flagsOptionValue = 0;
    switch (direction) {
        case DIRECTION_INBOUND:
            flagsOptionValue = 0b01;
            break;
        case DIRECTION_OUTBOUND:
            flagsOptionValue = 0b10;
            break;
        default:
            throw cRuntimeError("Unknown direction value");
    }
    fwrite(&doh, sizeof(doh), 1, dumpfile);
    fwrite(&flagsOptionValue, sizeof(flagsOptionValue), 1, dumpfile);
 
    // end of options
    uint32_t endOfOptions = 0;
    fwrite(&endOfOptions, sizeof(endOfOptions), 1, dumpfile);
 
    // trailer
    struct pcapng_packet_block_trailer pbt;
    pbt.blockTotalLength = blockTotalLength;
    fwrite(&pbt, sizeof(pbt), 1, dumpfile);
 
    if (flush)
        fflush(dumpfile);
}

Member Data Documentation

dumpfile

FILE* inet::PcapngWriter::dumpfile = nullptr

protected

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

fileName

std::string inet::PcapngWriter::fileName

protected

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

flush

bool inet::PcapngWriter::flush = false

protected

Referenced by open().

interfaceModuleIdToPcapngInterfaceId

std::map<int, int> inet::PcapngWriter::interfaceModuleIdToPcapngInterfaceId

protected

Referenced by writePacket().

nextPcapngInterfaceId

int inet::PcapngWriter::nextPcapngInterfaceId = 0

protected

Referenced by writePacket().

---

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

• PcapngWriter.h
• PcapngWriter.cc