PfRingDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_PF_RING_DEVICE
#define PCAPPP_PF_RING_DEVICE

#include "PcapDevice.h"
#include "PcapFilter.h"
#include "MacAddress.h"
#include "SystemUtils.h"
#include "RawPacket.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 IPcapDevice
    {
        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);

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

        void clearCoreConfiguration();
        int getCoresInUseCount();

        void setPfRingDeviceAttributes();

        bool sendData(const uint8_t* packetData, int packetDataLength, bool flushTxQueues);
    public:

        enum ChannelDistribution
        {
            RoundRobin,
            PerFlow
        };

        ~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; }

        inline std::string getDeviceName() { 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);

        inline uint8_t getNumOfOpenedRxChannels() { return m_NumOfOpenedRxChannels; }

        uint8_t getTotalNumOfRxChannels();

        SystemCore getCurrentCoreId();

        void getThreadStatistics(SystemCore core, pcap_stat& stats);

        void getCurrentThreadStatistics(pcap_stat& stats);



        // implement abstract methods


        bool open();

        void close();

        void getStatistics(pcap_stat& stats);


        bool setFilter(GeneralFilter& filter);

        bool setFilter(std::string filterAsString);

        bool removeFilter();

        bool isFilterCurrentlySet();


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

} // namespace pcpp

#endif /* PCAPPP_PF_RING_DEVICE */