KniDevice.h

Go to the documentation of this file.

#ifndef PCAPPP_KNI_DEVICE
#define PCAPPP_KNI_DEVICE

// 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;

    typedef bool (*OnKniPacketArriveCallback)(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:
        /* Information getters */

        inline bool isInitialized() const { return !(m_Device == NULL || m_MBufMempool == NULL); }
        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);

        /* Information setters */

        bool setLinkState(KniLinkState state);
        bool setMacAddress(MacAddress mac);
        bool setMtu(uint16_t mtu);
        bool setPromiscuous(KniPromiscuousMode mode);
        KniLinkState updateLinkState(KniLinkState state);

        /* Requests */

        bool handleRequests();
        bool startRequestHandlerThread(long sleepSeconds, long sleepNanoSeconds = 0);
        void stopRequestHandlerThread();

        /* Packet receive */

        uint16_t receivePackets(MBufRawPacketVector& rawPacketsArr);
        uint16_t receivePackets(MBufRawPacket** rawPacketsArr, uint16_t rawPacketArrLength);
        uint16_t receivePackets(Packet** packetsArr, uint16_t packetsArrLength);

        /* Packet send */

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

        /* Packet capture */

        bool startCapture(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie);
        int startCaptureBlockingMode(OnKniPacketArriveCallback onPacketArrives, void* onPacketArrivesUserCookie, int timeout);
        void stopCapture();

        /* Device control */

        bool open();
        void close();

    private:
        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 != NULL; }
            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

#endif /* PCAPPP_KNI_DEVICE */