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 <pthread.h>
 
 
// 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
        {
            pthread_t RxThread;
            pfring* Channel;
            bool IsInUse;
            bool IsAffinitySet;
 
            CoreConfiguration();
            void clear();
        };
 
        pfring** m_PfRingDescriptors;
        uint8_t m_NumOfOpenedRxChannels;
        char m_DeviceName[30];
        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);
        static void* captureThreadMain(void *ptr);
 
        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 std::string(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 */