PcapFileDevice.h

Go to the documentation of this file.

#pragma once
 
#include "PcapDevice.h"
#include "RawPacket.h"
#include <fstream>
 
// forward declaration for structs and typedefs defined in pcap.h
struct pcap_dumper;
typedef struct pcap_dumper pcap_dumper_t;
 
 
namespace pcpp
{
    namespace internal
    {
        struct LightPcapNgHandle;
    }  // namespace internal
 
    enum class FileTimestampPrecision : int8_t
    {
        Unknown = -1,
        Microseconds = 0,
        Nanoseconds = 1
    };
 
    class IFileDevice : public IPcapDevice
    {
    protected:
        bool m_DeviceOpened = false;
        std::string m_FileName;
 
        explicit IFileDevice(const std::string& fileName);
        virtual ~IFileDevice();
 
    public:
        std::string getFileName() const;
 
        // override methods
 
        void close() override;
 
        bool isOpened() const override
        {
            return m_DeviceOpened;
        }
 
        void getStatistics(PcapStats& stats) const override;
 
    protected:
        void reportPacketProcessed(uint64_t numPackets = 1)
        {
            m_NumOfPacketsProcessed += numPackets;
        }
 
        void reportPacketDropped(uint64_t numPackets = 1)
        {
            m_NumOfPacketsDropped += numPackets;
        }
 
        void resetStatisticCounters();
 
    private:
        uint64_t m_NumOfPacketsProcessed = 0;
        uint64_t m_NumOfPacketsDropped = 0;
    };
 
    class IFileReaderDevice : public IFileDevice
    {
    protected:
        IFileReaderDevice(const std::string& fileName);
 
    public:
        virtual ~IFileReaderDevice() = default;
 
        uint64_t getFileSize() const;
 
        virtual bool getNextPacket(RawPacket& rawPacket) = 0;
 
        int getNextPackets(RawPacketVector& packetVec, int numOfPacketsToRead = -1);
 
        static IFileReaderDevice* getReader(const std::string& fileName);
    };
 
    class IFileWriterDevice : public IFileDevice
    {
    protected:
        IFileWriterDevice(const std::string& fileName);
 
    public:
        virtual ~IFileWriterDevice() = default;
 
        virtual bool writePacket(RawPacket const& packet) = 0;
 
        virtual bool writePackets(const RawPacketVector& packets) = 0;
 
        using IFileDevice::open;
        virtual bool open(bool appendMode) = 0;
    };
 
    class PcapFileReaderDevice : public IFileReaderDevice
    {
    private:
        FileTimestampPrecision m_Precision;
        LinkLayerType m_PcapLinkLayerType;
 
        // private copy c'tor
        PcapFileReaderDevice(const PcapFileReaderDevice& other);
        PcapFileReaderDevice& operator=(const PcapFileReaderDevice& other);
 
    public:
        PcapFileReaderDevice(const std::string& fileName)
            : IFileReaderDevice(fileName), m_Precision(FileTimestampPrecision::Unknown),
              m_PcapLinkLayerType(LINKTYPE_ETHERNET)
        {}
 
        virtual ~PcapFileReaderDevice() = default;
 
        LinkLayerType getLinkLayerType() const
        {
            return m_PcapLinkLayerType;
        }
 
        FileTimestampPrecision getTimestampPrecision() const
        {
            return m_Precision;
        }
 
        static bool isNanoSecondPrecisionSupported();
 
        // overridden methods
 
        bool getNextPacket(RawPacket& rawPacket);
 
        bool open();
    };
 
    class PcapFileWriterDevice : public IFileWriterDevice
    {
    private:
        pcap_dumper_t* m_PcapDumpHandler;
        LinkLayerType m_PcapLinkLayerType;
        bool m_AppendMode;
        FileTimestampPrecision m_Precision;
        FILE* m_File;
 
        // private copy c'tor
        PcapFileWriterDevice(const PcapFileWriterDevice& other);
        PcapFileWriterDevice& operator=(const PcapFileWriterDevice& other);
 
        void closeFile();
 
    public:
        PcapFileWriterDevice(const std::string& fileName, LinkLayerType linkLayerType = LINKTYPE_ETHERNET,
                             bool nanosecondsPrecision = false);
 
        ~PcapFileWriterDevice()
        {
            PcapFileWriterDevice::close();
        }
 
        bool writePacket(RawPacket const& packet) override;
 
        bool writePackets(const RawPacketVector& packets) override;
 
        FileTimestampPrecision getTimestampPrecision() const
        {
            return m_Precision;
        }
 
        static bool isNanoSecondPrecisionSupported();
 
        // override methods
 
        bool open() override;
 
        bool open(bool appendMode) override;
 
        void close() override;
 
        void flush();
 
    private:
        bool openWrite();
        bool openAppend();
    };
 
    class PcapNgFileReaderDevice : public IFileReaderDevice
    {
    private:
        internal::LightPcapNgHandle* m_LightPcapNg;
        BpfFilterWrapper m_BpfWrapper;
 
        // private copy c'tor
        PcapNgFileReaderDevice(const PcapNgFileReaderDevice& other);
        PcapNgFileReaderDevice& operator=(const PcapNgFileReaderDevice& other);
 
    public:
        PcapNgFileReaderDevice(const std::string& 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();
 
        bool setFilter(std::string filterAsString);
 
        void close();
    };
 
    class PcapNgFileWriterDevice : public IFileWriterDevice
    {
    private:
        internal::LightPcapNgHandle* m_LightPcapNg;
        int m_CompressionLevel;
        BpfFilterWrapper m_BpfWrapper;
 
        // private copy c'tor
        PcapNgFileWriterDevice(const PcapFileWriterDevice& other);
        PcapNgFileWriterDevice& operator=(const PcapNgFileWriterDevice& other);
 
    public:
        PcapNgFileWriterDevice(const std::string& fileName, int compressionLevel = 0);
 
        virtual ~PcapNgFileWriterDevice()
        {
            PcapNgFileWriterDevice::close();
        }
 
        bool writePacket(RawPacket const& packet, const std::string& comment);
 
        // overridden methods
 
        bool writePacket(RawPacket const& packet) override;
 
        bool writePackets(const RawPacketVector& packets) override;
 
        bool open() override;
 
        bool open(bool appendMode) override;
 
        bool open(const std::string& os, const std::string& hardware, const std::string& captureApp,
                  const std::string& fileComment);
 
        void flush();
 
        void close() override;
 
        bool setFilter(std::string filterAsString) override;
 
    private:
        struct PcapNgMetadata
        {
            std::string os;
            std::string hardware;
            std::string captureApplication;
            std::string comment;
        };
 
        bool openWrite(PcapNgMetadata const* metadata = nullptr);
        bool openAppend();
    };
 
    class SnoopFileReaderDevice : public IFileReaderDevice
    {
    private:
#pragma pack(1)
        typedef struct
        {
            uint64_t identification_pattern;
            uint32_t version_number;
            uint32_t datalink_type;
        } snoop_file_header_t;
 
        typedef struct
        {
            uint32_t original_length;       
            uint32_t included_length;       
            uint32_t packet_record_length;  
            uint32_t ndrops_cumulative;     
            uint32_t time_sec;              
            uint32_t time_usec;             
        } snoop_packet_header_t;
#pragma pack()
 
        LinkLayerType m_PcapLinkLayerType;
        std::ifstream m_snoopFile;
 
        // private copy c'tor
        SnoopFileReaderDevice(const PcapFileReaderDevice& other);
        SnoopFileReaderDevice& operator=(const PcapFileReaderDevice& other);
 
    public:
        SnoopFileReaderDevice(const std::string& fileName)
            : IFileReaderDevice(fileName), m_PcapLinkLayerType(LINKTYPE_ETHERNET)
        {}
 
        virtual ~SnoopFileReaderDevice();
 
        LinkLayerType getLinkLayerType() const
        {
            return m_PcapLinkLayerType;
        }
 
        // overridden methods
 
        bool getNextPacket(RawPacket& rawPacket);
 
        bool open();
 
        void close();
    };
}  // namespace pcpp