PfRingDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_PF_RING_DEVICE
#define PCAPPP_PF_RING_DEVICE

#include "Device.h"
#include "MacAddress.h"
#include "SystemUtils.h"
#include "Packet.h"
#include <thread>
#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();
        };

        pfring** m_PfRingDescriptors;
        uint8_t m_NumOfOpenedRxChannels;
        std::string m_DeviceName;
        int m_InterfaceIndex;
        MacAddress m_MacAddress;
        int m_DeviceMTU;
        CoreConfiguration m_CoreConfiguration[MAX_NUM_OF_CORES];
        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::condition_variable* startCond, std::mutex* startMutex, const int* startState);

        int openSingleRxChannel(const char* deviceName, pfring** ring);

        bool getIsHwClockEnable() { setPfRingDeviceAttributes(); return m_HwClockEnabled; }
        bool setPfRingDeviceClock(pfring* ring);

        void clearCoreConfiguration();
        int 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 m_NumOfOpenedRxChannels; }

        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();

        using IFilterableDevice::setFilter;

        bool setFilter(std::string filterAsString);

        bool clearFilter();
    };

} // namespace pcpp

#endif /* PCAPPP_PF_RING_DEVICE */