PcapLiveDevice.h

Go to the documentation of this file.

//TODO: replace all these defines with #pragma once
#ifndef PCAPPP_LIVE_DEVICE
#define PCAPPP_LIVE_DEVICE

#include "PcapDevice.h"
#include <vector>
#include <string.h>
#include "IpAddress.h"
#include "Packet.h"

// forward declarations for structs and typedefs that are defined in pcap.h
struct pcap_if;
typedef pcap_if pcap_if_t;
struct pcap_addr;
typedef struct pcap_addr pcap_addr_t;


namespace pcpp
{

    class PcapLiveDevice;

    typedef void (*OnPacketArrivesCallback)(RawPacket* pPacket, PcapLiveDevice* pDevice, void* userCookie);

    typedef bool (*OnPacketArrivesStopBlocking)(RawPacket* pPacket, PcapLiveDevice* pDevice, void* userData);


    typedef void (*OnStatsUpdateCallback)(IPcapDevice::PcapStats& stats, void* userCookie);

    // for internal use only
    typedef void* (*ThreadStart)(void*);

    struct PcapThread;

    class PcapLiveDevice : public IPcapDevice
    {
        friend class PcapLiveDeviceList;
    protected:
        // This is a second descriptor for the same device. It is needed because of a bug
        // that occurs in libpcap on Linux (on Windows using WinPcap/Npcap it works well):
        // It's impossible to capture packets sent by the same descriptor
        pcap_t* m_PcapSendDescriptor;
        std::string m_Name;
        std::string m_Description;
        bool m_IsLoopback;
        uint32_t m_DeviceMtu;
        std::vector<pcap_addr_t> m_Addresses;
        MacAddress m_MacAddress;
        IPv4Address m_DefaultGateway;
        PcapThread* m_CaptureThread;
        bool m_CaptureThreadStarted;
        PcapThread* m_StatsThread;
        bool m_StatsThreadStarted;
        bool m_StopThread;
        OnPacketArrivesCallback m_cbOnPacketArrives;
        void* m_cbOnPacketArrivesUserCookie;
        OnStatsUpdateCallback m_cbOnStatsUpdate;
        void* m_cbOnStatsUpdateUserCookie;
        OnPacketArrivesStopBlocking m_cbOnPacketArrivesBlockingMode;
        void* m_cbOnPacketArrivesBlockingModeUserCookie;
        int m_IntervalToUpdateStats;
        RawPacketVector* m_CapturedPackets;
        bool m_CaptureCallbackMode;
        LinkLayerType m_LinkType;

        // c'tor is not public, there should be only one for every interface (created by PcapLiveDeviceList)
        PcapLiveDevice(pcap_if_t* pInterface, bool calculateMTU, bool calculateMacAddress, bool calculateDefaultGateway);
        // copy c'tor is not public
        PcapLiveDevice( const PcapLiveDevice& other );
        PcapLiveDevice& operator=(const PcapLiveDevice& other);

        void setDeviceMtu();
        void setDeviceMacAddress();
        void setDefaultGateway();
        static void* captureThreadMain(void* ptr);
        static void* statsThreadMain(void* ptr);
        static void onPacketArrives(uint8_t* user, const struct pcap_pkthdr* pkthdr, const uint8_t* packet);
        static void onPacketArrivesNoCallback(uint8_t* user, const struct pcap_pkthdr* pkthdr, const uint8_t* packet);
        static void onPacketArrivesBlockingMode(uint8_t* user, const struct pcap_pkthdr* pkthdr, const uint8_t* packet);
        std::string printThreadId(PcapThread* id);
        virtual ThreadStart getCaptureThreadStart();
    public:

        enum LiveDeviceType
        {
            LibPcapDevice,
            WinPcapDevice,
            RemoteDevice
        };


        enum DeviceMode
        {
            Normal = 0,
            Promiscuous = 1
        };


        enum PcapDirection
        {
            PCPP_INOUT = 0,
            PCPP_IN,
            PCPP_OUT
        };


        struct DeviceConfiguration
        {
            DeviceMode mode;

            int packetBufferTimeoutMs;

            int packetBufferSize;

            PcapDirection direction;

            int snapshotLength;

            DeviceConfiguration(DeviceMode mode = Promiscuous, int packetBufferTimeoutMs = 0, int packetBufferSize = 0,
                                PcapDirection direction = PCPP_INOUT, int snapshotLength = 0)
            {
                this->mode = mode;
                this->packetBufferTimeoutMs = packetBufferTimeoutMs;
                this->packetBufferSize = packetBufferSize;
                this->direction = direction;
                this->snapshotLength = snapshotLength;
            }
        };


        virtual ~PcapLiveDevice();

        virtual LiveDeviceType getDeviceType() const { return LibPcapDevice; }

        std::string getName() const { return m_Name; }

        std::string getDesc() const { return m_Description; }

        bool getLoopback() const { return m_IsLoopback; }

        virtual uint32_t getMtu() const { return m_DeviceMtu; }

        virtual LinkLayerType getLinkType() const { return m_LinkType; }

        const std::vector<pcap_addr_t>& getAddresses() const { return m_Addresses; }

        virtual MacAddress getMacAddress() const { return m_MacAddress; }

        IPv4Address getIPv4Address() const;

        IPv4Address getDefaultGateway() const;

        const std::vector<IPv4Address>& getDnsServers() const;

        virtual bool startCapture(OnPacketArrivesCallback onPacketArrives, void* onPacketArrivesUserCookie);

        virtual bool startCapture(OnPacketArrivesCallback onPacketArrives, void* onPacketArrivesUserCookie, int intervalInSecondsToUpdateStats, OnStatsUpdateCallback onStatsUpdate, void* onStatsUpdateUserCookie);

        virtual bool startCapture(int intervalInSecondsToUpdateStats, OnStatsUpdateCallback onStatsUpdate, void* onStatsUpdateUserCookie);

        virtual bool startCapture(RawPacketVector& capturedPacketsVector);

        virtual int startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacketArrives, void* userCookie, int timeout);

        void stopCapture();

        bool captureActive();

        bool doMtuCheck(int packetPayloadLength);

        bool sendPacket(RawPacket const& rawPacket, bool checkMtu = false);

        bool sendPacket(const uint8_t* packetData, int packetDataLength, int packetPayloadLength);

        bool sendPacket(const uint8_t* packetData, int packetDataLength, bool checkMtu = false, pcpp::LinkLayerType linkType = pcpp::LINKTYPE_ETHERNET);

        bool sendPacket(Packet* packet, bool checkMtu = true);

        virtual int sendPackets(RawPacket* rawPacketsArr, int arrLength, bool checkMtu = false);

        virtual int sendPackets(Packet** packetsArr, int arrLength, bool checkMtu = true);

        virtual int sendPackets(const RawPacketVector& rawPackets, bool checkMtu = false);


        // implement abstract methods

        bool open();

        bool open(const DeviceConfiguration& config);

        void close();

        PcapLiveDevice* clone();

        virtual void getStatistics(IPcapDevice::PcapStats& stats) const;

    protected:
        pcap_t* doOpen(const DeviceConfiguration& config);
    };

} // namespace pcpp

#endif