PcapDevice.h

Go to the documentation of this file.

#pragma once
 
#include "Device.h"
 
// forward declaration for the pcap descriptor defined in pcap.h
struct pcap;
typedef pcap pcap_t;
struct pcap_pkthdr;
 
 
namespace pcpp
{
    // Forward Declaration - required for IPcapDevice::matchPacketWithFilter
    class GeneralFilter;
 
    namespace internal
    {
        struct PcapStats
        {
            uint64_t packetsRecv;
            uint64_t packetsDrop;
            uint64_t packetsDropByInterface;
        };
 
        class PcapHandle
        {
        public:
            constexpr PcapHandle() noexcept = default;
            explicit PcapHandle(pcap_t* pcapDescriptor) noexcept;
 
            PcapHandle(const PcapHandle&) = delete;
            PcapHandle(PcapHandle&& other) noexcept;
 
            PcapHandle& operator=(const PcapHandle&) = delete;
            PcapHandle& operator=(PcapHandle&& other) noexcept;
            PcapHandle& operator=(std::nullptr_t) noexcept;
 
            ~PcapHandle();
 
            bool isValid() const noexcept
            {
                return m_PcapDescriptor != nullptr;
            }
 
            pcap_t* get() const noexcept
            {
                return m_PcapDescriptor;
            }
 
            pcap_t* release() noexcept;
 
            void reset(pcap_t* pcapDescriptor = nullptr) noexcept;
 
            char const* getLastError() const noexcept;
 
            bool setFilter(std::string const& filter);
 
            bool clearFilter();
 
            bool getStatistics(PcapStats& stats) const;
 
            explicit operator bool() const noexcept
            {
                return isValid();
            }
 
            bool operator==(std::nullptr_t) const noexcept
            {
                return !isValid();
            }
            bool operator!=(std::nullptr_t) const noexcept
            {
                return isValid();
            }
 
        private:
            pcap_t* m_PcapDescriptor = nullptr;
        };
    }  // namespace internal
 
    class IPcapStatisticsProvider
    {
    public:
        virtual ~IPcapStatisticsProvider() = default;
 
        using PcapStats = internal::PcapStats;
 
        PcapStats getStatistics() const;
 
        virtual void getStatistics(PcapStats& stats) const = 0;
    };
 
    class IPcapDevice : public IDevice, public IFilterableDevice, public IPcapStatisticsProvider
    {
    protected:
        internal::PcapHandle m_PcapDescriptor;
 
        // c'tor should not be public
        IPcapDevice() : IDevice()
        {}
 
    public:
        virtual ~IPcapDevice() = default;
 
        static std::string getPcapLibVersionInfo();
 
        static bool matchPacketWithFilter(GeneralFilter& filter, RawPacket* rawPacket);
 
        // implement abstract methods
 
        using IFilterableDevice::setFilter;
 
        bool setFilter(std::string filterAsString) override;
 
        bool clearFilter() override;
    };
}  // namespace pcpp