KniDevice.h

Go to the documentation of this file.

#pragma once
 
// GCOVR_EXCL_START
 
#include <string>
#include <atomic>
 
#include "Device.h"
#include "MacAddress.h"
#include "MBufRawPacket.h"
#include "LinuxNicInformationSocket.h"
 
struct rte_kni;
 
namespace pcpp
{
    class KniDevice;
    class KniDeviceList;
 
    using OnKniPacketArriveCallback = bool (*)(MBufRawPacket* packets, uint32_t numOfPackets, KniDevice* device,
                                               void* userCookie);
 
    class KniDevice : public IDevice
    {
        friend class KniDeviceList;
        friend class MBufRawPacket;
 
    public:
        enum KniLinkState
        {
            LINK_NOT_SUPPORTED = -2,
            LINK_ERROR = -1,
            LINK_DOWN = 0,
            LINK_UP = 1
        };
        enum KniInfoState
        {
            INFO_CACHED = 0,
            INFO_RENEW = 1
        };
        enum KniPromiscuousMode
        {
            PROMISC_DISABLE = 0,
            PROMISC_ENABLE = 1
        };
 
        struct KniIoctlCallbacks
        {
            int (*change_mtu)(uint16_t port_id, unsigned int new_mtu);
            int (*config_network_if)(uint16_t port_id, uint8_t if_up);
            int (*config_mac_address)(uint16_t port_id, uint8_t mac_addr[]);
            int (*config_promiscusity)(uint16_t port_id, uint8_t to_on);
        };
 
        struct KniOldIoctlCallbacks
        {
            int (*change_mtu)(uint8_t port_id, unsigned int new_mtu);
            int (*config_network_if)(uint8_t port_id, uint8_t if_up);
        };
 
        struct KniDeviceConfiguration
        {
            std::string name;
            union {
                KniIoctlCallbacks* callbacks;
                KniOldIoctlCallbacks* oldCallbacks;
            };
            MacAddress mac;
            uint16_t portId;
            uint16_t mtu;
            bool bindKthread;
            uint32_t kthreadCoreId;
        };
 
    private:
        KniDevice(const KniDeviceConfiguration& conf, size_t mempoolSize, int unique);
        KniDevice(const KniDevice&);
        KniDevice& operator=(const KniDevice&);
        ~KniDevice();
 
    public:
        inline bool isInitialized() const
        {
            return !(m_Device == nullptr || m_MBufMempool == nullptr);
        }
        inline std::string getName() const
        {
            return std::string(m_DeviceInfo.name);
        }
        inline uint16_t getPort() const
        {
            return m_DeviceInfo.portId;
        }
        KniLinkState getLinkState(KniInfoState state = INFO_CACHED);
        MacAddress getMacAddress(KniInfoState state = INFO_CACHED);
        uint16_t getMtu(KniInfoState state = INFO_CACHED);
        KniPromiscuousMode getPromiscuous(KniInfoState state = INFO_CACHED);
 
        bool setLinkState(KniLinkState state);
        bool setMacAddress(const MacAddress& mac);
        bool setMtu(uint16_t mtu);
        bool setPromiscuous(KniPromiscuousMode mode);
        KniLinkState updateLinkState(KniLinkState state);
 
        bool handleRequests();
        bool startRequestHandlerThread(long sleepSeconds, long sleepNanoSeconds = 0);
        void stopRequestHandlerThread();
 
        uint16_t receivePackets(MBufRawPacketVector& rawPacketsArr);
        uint16_t receivePackets(MBufRawPacket** rawPacketsArr, uint16_t rawPacketArrLength);
        uint16_t receivePackets(Packet** packetsArr, uint16_t packetsArrLength);
 
        uint16_t sendPackets(MBufRawPacket** rawPacketsArr, uint16_t arrLength);
        uint16_t sendPackets(Packet** packetsArr, uint16_t arrLength);
        uint16_t sendPackets(MBufRawPacketVector& rawPacketsVec);
        uint16_t sendPackets(RawPacketVector& rawPacketsVec);
        bool sendPacket(RawPacket& rawPacket);
        bool sendPacket(MBufRawPacket& rawPacket);
        bool sendPacket(Packet& packet);
 
        bool startCapture(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie);
 
        int startCaptureBlockingMode(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie,
                                     int timeout);
        void stopCapture();
 
        bool open();
        void close();
 
        bool isOpened() const override
        {
            return m_DeviceOpened;
        }
 
    private:
        bool m_DeviceOpened = false;
 
        struct rte_kni* m_Device;
        struct rte_mempool* m_MBufMempool;
        struct KniDeviceInfo
        {
            LinuxNicInformationSocket soc;
            KniLinkState link;
            KniPromiscuousMode promisc;
            uint16_t portId;
            uint16_t mtu;
            MacAddress mac;
            std::string name;
 
            bool init(const KniDeviceConfiguration& conf);
        } m_DeviceInfo;
        struct KniThread;
        struct KniCapturing
        {
            OnKniPacketArriveCallback callback;
            void* userCookie;
            KniThread* thread;
 
            static void runCapture(void* devicePointer, std::atomic<bool>& stopThread);
            inline bool isRunning() const
            {
                return thread != nullptr;
            }
            void cleanup();
        } m_Capturing;
        struct KniRequests
        {
            long sleepS;
            long sleepNs;
            KniThread* thread;
 
            static void runRequests(void* devicePointer, std::atomic<bool>& stopThread);
            void cleanup();
        } m_Requests;
    };
 
}  // namespace pcpp
 
// GCOVR_EXCL_STOP