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() const;
 
 
        //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() const;
 
        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) : IFileReaderDevice(fileName), m_PcapLinkLayerType(LINKTYPE_ETHERNET) {}
 
        virtual ~PcapFileReaderDevice() {}
 
        LinkLayerType getLinkLayerType() const { return m_PcapLinkLayerType; }
 
 
        //overridden methods
 
        bool getNextPacket(RawPacket& rawPacket);
 
        bool open();
 
        void getStatistics(pcap_stat& stats) const;
    };
 
 
    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() const;
 
        std::string getHardware() const;
 
        std::string getCaptureApplication() const;
 
        std::string getCaptureFileComment() const;
 
        bool getNextPacket(RawPacket& rawPacket, std::string& packetComment);
 
        //overridden methods
 
        bool getNextPacket(RawPacket& rawPacket);
 
        bool open();
 
        void getStatistics(pcap_stat& stats) const;
 
        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) const;
    };
 
 
    class PcapNgFileWriterDevice : public IFileWriterDevice
    {
    private:
        void* m_LightPcapNg;
        int m_CompressionLevel;
        struct bpf_program m_Bpf;
        bool m_BpfInitialized;
        int m_BpfLinkType;
        std::string m_CurFilter;
 
        // private copy c'tor
        PcapNgFileWriterDevice(const PcapFileWriterDevice& other);
        PcapNgFileWriterDevice& operator=(const PcapNgFileWriterDevice& other);
 
        bool matchPacketWithFilter(const uint8_t* packetData, size_t packetLen, timeval packetTimestamp, uint16_t linkType);
 
    public:
 
        PcapNgFileWriterDevice(const char* fileName, int compressionLevel = 0);
 
        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) const;
 
        bool setFilter(std::string filterAsString);
 
    };
 
}// namespace pcpp
 
#endif