PcapFileDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_FILE_DEVICE
#define PCAPPP_FILE_DEVICE

#include "PcapDevice.h"
#include "RawPacket.h"


namespace pcpp
{

    class IFileDevice : public IPcapDevice
    {
    protected:
        char* m_FileName;

        IFileDevice(const char* fileName);
        virtual ~IFileDevice();

    public:

        std::string getFileName();


        //override methods

        virtual void close();
    };


    class IFileReaderDevice : public IFileDevice
    {
    protected:
        uint32_t m_NumOfPacketsRead;
        uint32_t m_NumOfPacketsNotParsed;

        IFileReaderDevice(const char* fileName);

    public:

        virtual ~IFileReaderDevice() {}

        uint64_t getFileSize();

        virtual bool getNextPacket(RawPacket& rawPacket) = 0;

        int getNextPackets(RawPacketVector& packetVec, int numOfPacketsToRead = -1);

        static IFileReaderDevice* getReader(const char* fileName);
    };


    class PcapFileReaderDevice : public IFileReaderDevice
    {
    private:
        LinkLayerType m_PcapLinkLayerType;

        // private copy c'tor
        PcapFileReaderDevice(const PcapFileReaderDevice& other);
        PcapFileReaderDevice& operator=(const PcapFileReaderDevice& other);

    public:
        PcapFileReaderDevice(const char* fileName);

        virtual ~PcapFileReaderDevice() {}

        LinkLayerType getLinkLayerType();


        //overridden methods

        bool getNextPacket(RawPacket& rawPacket);

        bool open();

        void getStatistics(pcap_stat& stats);
    };


    class PcapNgFileReaderDevice : public IFileReaderDevice
    {
    private:
        void* m_LightPcapNg;
        struct bpf_program m_Bpf;
        bool m_BpfInitialized;
        int m_BpfLinkType;
        std::string m_CurFilter;

        // private copy c'tor
        PcapNgFileReaderDevice(const PcapNgFileReaderDevice& other);
        PcapNgFileReaderDevice& operator=(const PcapNgFileReaderDevice& other);

        bool matchPacketWithFilter(const uint8_t* packetData, size_t packetLen, timeval packetTimestamp, uint16_t linkType);

    public:
        PcapNgFileReaderDevice(const char* fileName);

        virtual ~PcapNgFileReaderDevice() { close(); }

        std::string getOS();

        std::string getHardware();

        std::string getCaptureApplication();

        std::string getCaptureFileComment();

        bool getNextPacket(RawPacket& rawPacket, std::string& packetComment);

        //overridden methods

        bool getNextPacket(RawPacket& rawPacket);

        bool open();

        void getStatistics(pcap_stat& stats);

        bool setFilter(std::string filterAsString);

        void close();
    };


    class IFileWriterDevice : public IFileDevice
    {
    protected:
        uint32_t m_NumOfPacketsWritten;
        uint32_t m_NumOfPacketsNotWritten;

        IFileWriterDevice(const char* fileName);

    public:

        virtual ~IFileWriterDevice() {}

        virtual bool writePacket(RawPacket const& packet) = 0;

        virtual bool writePackets(const RawPacketVector& packets) = 0;

        using IFileDevice::open;
        virtual bool open(bool appendMode) = 0;
    };


    class PcapFileWriterDevice : public IFileWriterDevice
    {
    private:
        pcap_dumper_t* m_PcapDumpHandler;
        LinkLayerType m_PcapLinkLayerType;
        bool m_AppendMode;
        FILE* m_File;

        // private copy c'tor
        PcapFileWriterDevice(const PcapFileWriterDevice& other);
        PcapFileWriterDevice& operator=(const PcapFileWriterDevice& other);

        void closeFile();

    public:
        PcapFileWriterDevice(const char* fileName, LinkLayerType linkLayerType = LINKTYPE_ETHERNET);

        ~PcapFileWriterDevice();

        bool writePacket(RawPacket const& packet);

        bool writePackets(const RawPacketVector& packets);

        //override methods

        virtual bool open();

        bool open(bool appendMode);

        virtual void close();

        virtual void getStatistics(pcap_stat& stats);
    };


    class PcapNgFileWriterDevice : public IFileWriterDevice
    {
    private:

        void* m_LightPcapNg;

        // private copy c'tor
        PcapNgFileWriterDevice(const PcapFileWriterDevice& other);
        PcapNgFileWriterDevice& operator=(const PcapNgFileWriterDevice& other);

    public:

        PcapNgFileWriterDevice(const char* fileName);

        virtual ~PcapNgFileWriterDevice() { close(); }

        bool open(const char* os, const char* hardware, const char* captureApp, const char* fileComment);

        bool writePacket(RawPacket const& packet, const char* comment);

        //overridden methods

        bool writePacket(RawPacket const& packet);

        bool writePackets(const RawPacketVector& packets);

        bool open();

        bool open(bool appendMode);

        void close();

        void getStatistics(pcap_stat& stats);
    };

}// namespace pcpp

#endif