PfRingDevice.h

Go to the documentation of this file.

#pragma once
 
// GCOVR_EXCL_START
 
#include "Device.h"
#include "MacAddress.h"
#include "SystemUtils.h"
#include "Packet.h"
#include <array>
#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include <condition_variable>
 
 
// forward declaration of PF_RING structs
struct __pfring;
typedef struct __pfring pfring;
 
namespace pcpp
{
 
    class PfRingDevice;
 
    typedef void (*OnPfRingPacketsArriveCallback)(RawPacket* packets, uint32_t numOfPackets, uint8_t threadId,
                                                  PfRingDevice* device, void* userCookie);
 
    class PfRingDevice : public IDevice, public IFilterableDevice
    {
        friend class PfRingDeviceList;
 
    private:
        struct CoreConfiguration
        {
            std::thread RxThread;
            pfring* Channel;
            bool IsInUse;
            bool IsAffinitySet;
 
            CoreConfiguration();
            void clear();
        };
 
        class StartupBlock
        {
        public:
            void notifyStartup();
            void waitForStartup();
 
        private:
            std::mutex m_Mutex;
            std::condition_variable m_Cv;
            bool m_Ready = false;
        };
 
        bool m_DeviceOpened = false;
 
        std::vector<pfring*> m_PfRingDescriptors;
        std::string m_DeviceName;
        int m_InterfaceIndex;
        MacAddress m_MacAddress;
        int m_DeviceMTU;
        std::array<CoreConfiguration, MAX_NUM_OF_CORES> m_CoreConfiguration;
        std::atomic<bool> m_StopThread;
        OnPfRingPacketsArriveCallback m_OnPacketsArriveCallback;
        void* m_OnPacketsArriveUserCookie;
        bool m_ReentrantMode;
        bool m_HwClockEnabled;
        bool m_IsFilterCurrentlySet;
 
        PfRingDevice(const char* deviceName);
 
        bool initCoreConfigurationByCoreMask(CoreMask coreMask);
        void captureThreadMain(std::shared_ptr<StartupBlock> startupBlock);
 
        int openSingleRxChannel(const char* deviceName, pfring*& ring);
        void closeAllRxChannels();
 
        bool getIsHwClockEnable()
        {
            setPfRingDeviceAttributes();
            return m_HwClockEnabled;
        }
        bool setPfRingDeviceClock(pfring* ring);
 
        void clearCoreConfiguration();
        size_t getCoresInUseCount() const;
 
        void setPfRingDeviceAttributes();
 
        bool sendData(const uint8_t* packetData, int packetDataLength, bool flushTxQueues);
 
    public:
        enum ChannelDistribution
        {
            RoundRobin,
            PerFlow
        };
 
        struct PfRingStats
        {
            uint64_t recv;
            uint64_t drop;
        };
 
        ~PfRingDevice();
 
        MacAddress getMacAddress()
        {
            setPfRingDeviceAttributes();
            return m_MacAddress;
        }
 
        int getInterfaceIndex()
        {
            setPfRingDeviceAttributes();
            return m_InterfaceIndex;
        }
 
        int getMtu()
        {
            setPfRingDeviceAttributes();
            return m_DeviceMTU;
        }
 
        bool isHwClockEnabledForDevice()
        {
            setPfRingDeviceAttributes();
            return m_HwClockEnabled;
        }
 
        std::string getDeviceName() const
        {
            return m_DeviceName;
        }
 
        bool startCaptureSingleThread(OnPfRingPacketsArriveCallback onPacketsArrive, void* onPacketsArriveUserCookie);
 
        bool startCaptureMultiThread(OnPfRingPacketsArriveCallback onPacketsArrive, void* onPacketsArriveUserCookie,
                                     CoreMask coreMask);
 
        void stopCapture();
 
        bool openSingleRxChannel(uint8_t channelId);
 
        bool openMultiRxChannels(const uint8_t* channelIds, int numOfChannelIds);
 
        bool openMultiRxChannels(uint8_t numOfRxChannelsToOpen, ChannelDistribution dist);
 
        uint8_t getNumOfOpenedRxChannels() const
        {
            return static_cast<uint8_t>(m_PfRingDescriptors.size());
        }
 
        uint8_t getTotalNumOfRxChannels() const;
 
        SystemCore getCurrentCoreId() const;
 
        void getThreadStatistics(SystemCore core, PfRingStats& stats) const;
 
        void getCurrentThreadStatistics(PfRingStats& stats) const;
 
        void getStatistics(PfRingStats& stats) const;
 
        bool isFilterCurrentlySet() const;
 
        bool sendPacket(const RawPacket& rawPacket);
 
        bool sendPacket(const uint8_t* packetData, int packetDataLength);
 
        bool sendPacket(const Packet& packet);
 
        int sendPackets(const RawPacket* rawPacketsArr, int arrLength);
 
        int sendPackets(const Packet** packetsArr, int arrLength);
 
        int sendPackets(const RawPacketVector& rawPackets);
 
        // implement abstract methods
 
        bool open();
 
        void close();
 
        bool isOpened() const override
        {
            return m_DeviceOpened;
        }
 
        using IFilterableDevice::setFilter;
 
        bool setFilter(std::string filterAsString);
 
        bool clearFilter();
    };
 
}  // namespace pcpp
 
// GCOVR_EXCL_STOP