public
/
libraries
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
libraries/pcappp/include/pcapplusplus/PcapLiveDevice.h

557 lines
30 KiB
C++
Raw Blame History

//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;
/// @file
/**
* \namespace pcpp
* \brief The main namespace for the PcapPlusPlus lib
*/
namespace pcpp
{
class PcapLiveDevice;
/**
* @typedef OnPacketArrivesCallback
* A callback that is called when a packet is captured by PcapLiveDevice
* @param[in] pPacket A pointer to the raw packet
* @param[in] pDevice A pointer to the PcapLiveDevice instance
* @param[in] userCookie A pointer to the object put by the user when packet capturing stared
*/
typedef void (*OnPacketArrivesCallback)(RawPacket* pPacket, PcapLiveDevice* pDevice, void* userCookie);
/**
* @typedef OnPacketArrivesStopBlocking
* A callback that is called when a packet is captured by PcapLiveDevice
* @param[in] pPacket A pointer to the raw packet
* @param[in] pDevice A pointer to the PcapLiveDevice instance
* @param[in] userCookie A pointer to the object put by the user when packet capturing stared
* @return True when main thread should stop blocking or false otherwise
*/
typedef bool (*OnPacketArrivesStopBlocking)(RawPacket* pPacket, PcapLiveDevice* pDevice, void* userData);
/**
* @typedef OnStatsUpdateCallback
* A callback that is called periodically for stats collection if user asked to start packet capturing with periodic stats collection
* @param[in] stats A reference to the most updated stats
* @param[in] userCookie A pointer to the object put by the user when packet capturing stared
*/
typedef void (*OnStatsUpdateCallback)(IPcapDevice::PcapStats& stats, void* userCookie);
// for internal use only
typedef void* (*ThreadStart)(void*);
struct PcapThread;
/**
* @class PcapLiveDevice
* A class that wraps a network interface (each of the interfaces listed in ifconfig/ipconfig).
* This class wraps the libpcap capabilities of capturing packets from the network, filtering packets and sending packets back to the network.
* This class is relevant for Linux applications only. On Windows the WinPcapLiveDevice (which inherits this class) is used. Both classes are
* almost similar in capabilities, the main difference between them is adapting some capabilities to the specific OS.
* This class cannot be instantiated by the user (it has a private constructor), as network interfaces aren't dynamic. Instances of
* this class (one instance per network interface) are created by PcapLiveDeviceList singleton on application startup and the user can get
* access to them by using PcapLiveDeviceList public methods such as PcapLiveDeviceList#getPcapLiveDeviceByIp()<BR>
* Main capabilities of this class:
* - Get all available information for this network interfaces such as name, IP addresses, MAC address, MTU, etc. This information is taken
* from both libpcap and the OS
* - Capture packets from the network. Capturing is always conducted on a different thread. PcapPlusPlus creates this
* thread when capturing starts and kills it when capturing ends. This prevents the application from being stuck while waiting for packets or
* processing them. Currently only one capturing thread is allowed, so when the interface is in capture mode, no further capturing is allowed.
* In addition to capturing the user can get stats on packets that were received by the application, dropped by the NIC (due to full
* NIC buffers), etc. Stats collection can be initiated by the user by calling getStatistics() or be pushed to the user periodically by
* supplying a callback and a timeout to startCapture()
* - Send packets back to the network. Sending the packets is done on the caller thread. No additional threads are created for this task
*/
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:
/**
* The type of the live device
*/
enum LiveDeviceType
{
/** libPcap live device */
LibPcapDevice,
/** WinPcap/Npcap live device */
WinPcapDevice,
/** WinPcap/Npcap Remote Capture device */
RemoteDevice
};
/**
* Device capturing mode
*/
enum DeviceMode
{
/** Only packets that their destination is this NIC are captured */
Normal = 0,
/** All packets that arrive to the NIC are captured, even packets that their destination isn't this NIC */
Promiscuous = 1
};
/**
* Set direction for capturing packets (you can read more here: <https://www.tcpdump.org/manpages/pcap.3pcap.html#lbAI>)
*/
enum PcapDirection
{
/** Capture traffics both incoming and outgoing */
PCPP_INOUT = 0,
/** Only capture incoming traffics */
PCPP_IN,
/** Only capture outgoing traffics */
PCPP_OUT
};
/**
* @struct DeviceConfiguration
* A struct that contains user configurable parameters for opening a device. All parameters have default values so
* the user isn't expected to set all parameters or understand exactly how they work
*/
struct DeviceConfiguration
{
/** Indicates whether to open the device in promiscuous or normal mode */
DeviceMode mode;
/** Set the packet buffer timeout in milliseconds. You can read more here:
* https://www.tcpdump.org/manpages/pcap.3pcap.html .
* Any value above 0 is considered legal, otherwise a value of 1 or -1 is used (depends on the platform)
*/
int packetBufferTimeoutMs;
/**
* Set the packet buffer size. You can read more about the packet buffer here:
* https://www.tcpdump.org/manpages/pcap.3pcap.html .
* Any value of 100 or above is considered valid, otherwise the default value is used (which varies between different OS's).
* However, please notice that setting values which are too low or two high may result in failure to open the device.
* These too low or too high thresholds may vary between OS's, as an example please refer to this thread:
* https://stackoverflow.com/questions/11397367/issue-in-pcap-set-buffer-size
*/
int packetBufferSize;
/**
* Set the direction for capturing packets. You can read more here:
* <https://www.tcpdump.org/manpages/pcap.3pcap.html#lbAI>.
*/
PcapDirection direction;
/**
* Set the snapshot length. Snapshot length is the amount of data for each frame that is actually captured. Note that taking
* larger snapshots both increases the amount of time it takes to process packets and, effectively, decreases the amount of
* packet buffering. This may cause packets to be lost. Note also that taking smaller snapshots will discard data from protocols
* above the transport layer, which loses information that may be important.
* You can read more here:
* https://wiki.wireshark.org/SnapLen
*/
int snapshotLength;
/**
* A c'tor for this struct
* @param[in] mode The mode to open the device: promiscuous or non-promiscuous. Default value is promiscuous
* @param[in] packetBufferTimeoutMs Buffer timeout in millisecond. Default value is 0 which means set timeout of
* 1 or -1 (depends on the platform)
* @param[in] packetBufferSize The packet buffer size. Default value is 0 which means use the default value
* (varies between different OS's)
* @param[in] direction Direction for capturing packets. Default value is INOUT which means capture both incoming
* and outgoing packets (not all platforms support this)
* @param[in] snapshotLength Snapshot length for capturing packets. Default value is 0 which means use the default value.
* A snapshot length of 262144 should be big enough for maximum-size Linux loopback packets (65549) and some USB packets
* captured with USBPcap (> 131072, < 262144). A snapshot length of 65535 should be sufficient, on most if not all networks,
* to capture all the data available from the packet.
*/
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;
}
};
/**
* A destructor for this class
*/
virtual ~PcapLiveDevice();
/**
* @return The type of the device (libPcap, WinPcap/Npcap or a remote device)
*/
virtual LiveDeviceType getDeviceType() const { return LibPcapDevice; }
/**
* @return The name of the device (e.g eth0), taken from pcap_if_t->name
*/
std::string getName() const { return m_Name; }
/**
* @return A human-readable description of the device, taken from pcap_if_t->description. May be NULL in some interfaces
*/
std::string getDesc() const { return m_Description; }
/**
* @return True if this interface is a loopback interface, false otherwise
*/
bool getLoopback() const { return m_IsLoopback; }
/**
* @return The device's maximum transmission unit (MTU) in bytes
*/
virtual uint32_t getMtu() const { return m_DeviceMtu; }
/**
* @return The device's link layer type
*/
virtual LinkLayerType getLinkType() const { return m_LinkType; }
/**
* @return A vector containing all addresses defined for this interface, each in pcap_addr_t struct
*/
const std::vector<pcap_addr_t>& getAddresses() const { return m_Addresses; }
/**
* @return The MAC address for this interface
*/
virtual MacAddress getMacAddress() const { return m_MacAddress; }
/**
* @return The IPv4 address for this interface. If multiple IPv4 addresses are defined for this interface, the first will be picked.
* If no IPv4 addresses are defined, a zeroed IPv4 address (IPv4Address#Zero) will be returned
*/
IPv4Address getIPv4Address() const;
/**
* @return The default gateway defined for this interface. If no default gateway is defined, if it's not IPv4 or if couldn't extract
* default gateway IPv4Address#Zero will be returned. If multiple gateways were defined the first one will be returned
*/
IPv4Address getDefaultGateway() const;
/**
* @return A list of all DNS servers defined for this machine. If this list is empty it means no DNS servers were defined or they
* couldn't be extracted from some reason. This list is created in PcapLiveDeviceList class and can be also retrieved from there.
* This method exists for convenience - so it'll be possible to get this list from PcapLiveDevice as well
*/
const std::vector<IPv4Address>& getDnsServers() const;
/**
* Start capturing packets on this network interface (device). Each time a packet is captured the onPacketArrives callback is called.
* The capture is done on a new thread created by this method, meaning all callback calls are done in a thread other than the
* caller thread. Capture process will stop and this capture thread will be terminated when calling stopCapture(). This method must be
* called after the device is opened (i.e the open() method was called), otherwise an error will be returned.
* @param[in] onPacketArrives A callback that is called each time a packet is captured
* @param[in] onPacketArrivesUserCookie A pointer to a user provided object. This object will be transferred to the onPacketArrives callback
* each time it is called. This cookie is very useful for transferring objects that give context to the capture callback, for example:
* objects that counts packets, manages flow state or manages the application state according to the packet that was captured
* @return True if capture started successfully, false if (relevant log error is printed in any case):
* - Capture is already running
* - Device is not opened
* - Capture thread could not be created
*/
virtual bool startCapture(OnPacketArrivesCallback onPacketArrives, void* onPacketArrivesUserCookie);
/**
* Start capturing packets on this network interface (device) with periodic stats collection. Each time a packet is captured the onPacketArrives
* callback is called. In addition, each intervalInSecondsToUpdateStats seconds stats are collected from the device and the onStatsUpdate
* callback is called. Both the capture and periodic stats collection are done on new threads created by this method, each on a different thread,
* meaning all callback calls are done in threads other than the caller thread. Capture process and stats collection will stop and threads will be
* terminated when calling stopCapture(). This method must be called after the device is opened (i.e the open() method was called), otherwise an
* error will be returned.
* @param[in] onPacketArrives A callback that is called each time a packet is captured
* @param[in] onPacketArrivesUserCookie A pointer to a user provided object. This object will be transferred to the onPacketArrives callback
* each time it is called. This cookie is very useful for transferring objects that give context to the capture callback, for example:
* objects that counts packets, manages flow state or manages the application state according to the packet that was captured
* @param[in] intervalInSecondsToUpdateStats The interval in seconds to activate periodic stats collection
* @param[in] onStatsUpdate A callback that will be called each time intervalInSecondsToUpdateStats expires and stats are collected. This
* callback will contain the collected stats
* @param[in] onStatsUpdateUserCookie A pointer to a user provided object. This object will be transferred to the onStatsUpdate callback
* each time it is called
* @return True if capture started successfully, false if (relevant log error is printed in any case):
* - Capture is already running
* - Device is not opened
* - Capture thread could not be created
* - Stats collection thread could not be created
*/
virtual bool startCapture(OnPacketArrivesCallback onPacketArrives, void* onPacketArrivesUserCookie, int intervalInSecondsToUpdateStats, OnStatsUpdateCallback onStatsUpdate, void* onStatsUpdateUserCookie);
/**
* Start capturing packets on this network interface (device) with periodic stats collection only. This means that packets arriving to the
* network interface aren't delivered to the user but only counted. Each intervalInSecondsToUpdateStats seconds stats are collected from the
* device and the onStatsUpdate callback is called with the updated counters. The periodic stats collection is done on a new thread created
* by this method, meaning all callback calls are done in threads other than the caller thread. Stats collection will stop and threads will
* be terminated when calling stopCapture(). This method must be called after the device is opened (i.e the open() method was called),
* otherwise an error will be returned.
* @param[in] intervalInSecondsToUpdateStats The interval in seconds to activate periodic stats collection
* @param[in] onStatsUpdate A callback that will be called each time intervalInSecondsToUpdateStats expires and stats are collected. This
* callback will contain the collected stats
* @param[in] onStatsUpdateUserCookie A pointer to a user provided object. This object will be transferred to the onStatsUpdate callback
* each time it is called
* @return True if capture started successfully, false if (relevant log error is printed in any case):
* - Capture is already running
* - Device is not opened
* - Stats collection thread could not be created
*/
virtual bool startCapture(int intervalInSecondsToUpdateStats, OnStatsUpdateCallback onStatsUpdate, void* onStatsUpdateUserCookie);
/**
* Start capturing packets on this network interface (device). All captured packets are added to capturedPacketsVector, so at the end of
* the capture (when calling stopCapture()) this vector contains pointers to all captured packets in the form of RawPacket. The capture
* is done on a new thread created by this method, meaning capturedPacketsVector is updated from another thread other than the caller
* thread (so user should avoid changing or iterating this vector while capture is on). Capture process will stop and this capture thread
* will be terminated when calling stopCapture(). This method must be called after the device is opened (i.e the open() method was called),
* otherwise an error will be returned.
* @param[in] capturedPacketsVector A reference to a RawPacketVector, meaning a vector of pointer to RawPacket objects
* @return True if capture started successfully, false if (relevant log error is printed in any case):
* - Capture is already running
* - Device is not opened
* - Capture thread could not be created
*/
virtual bool startCapture(RawPacketVector& capturedPacketsVector);
/**
* Start capturing packets on this network interface (device) in blocking mode, meaning this method blocks and won't return until
* the user frees the blocking (via onPacketArrives callback) or until a user defined timeout expires.
* Whenever a packets is captured the onPacketArrives callback is called and lets the user handle the packet. In each callback call
* the user should return true if he wants to release the block or false if it wants it to keep blocking. Regardless of this callback
* a timeout is defined when start capturing. When this timeout expires the method will return.<BR>
* Please notice that stopCapture() isn't needed here because when the method returns (after timeout or per user decision) capturing
* on the device is stopped
* @param[in] onPacketArrives A callback given by the user for handling incoming packets. After handling each packet the user needs to
* return a boolean value. True value indicates stop capturing and stop blocking and false value indicates continue capturing and blocking
* @param[in] userCookie A pointer to a user provided object. This object will be transferred to the onPacketArrives callback
* each time it is called. This cookie is very useful for transferring objects that give context to the capture callback, for example:
* objects that counts packets, manages flow state or manages the application state according to the packet that was captured
* @param[in] timeout A timeout in seconds for the blocking to stop even if the user didn't return "true" in the onPacketArrives callback
* If this timeout is set to 0 or less the timeout will be ignored, meaning the method will keep blocking until the user frees it via
* the onPacketArrives callback
* @return -1 if timeout expired, 1 if blocking was stopped via onPacketArrives callback or 0 if an error occurred (such as device
* not open etc.). When returning 0 an appropriate error message is printed to log
*/
virtual int startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacketArrives, void* userCookie, int timeout);
/**
* Stop a currently running packet capture. This method terminates gracefully both packet capture thread and periodic stats collection
* thread (both if exist)
*/
void stopCapture();
/**
* Check if a capture thread is running
* @return True if a capture thread is currently running
*/
bool captureActive();
/**
* Checks whether the packetPayloadLength is larger than the device MTU. Logs an error if check fails
* @param[in] packetPayloadLength The length of the IP layer of the packet
* @return True if the packetPayloadLength is less than or equal to the device MTU
*/
bool doMtuCheck(int packetPayloadLength);
/**
* Send a RawPacket to the network
* @param[in] rawPacket A reference to the raw packet to send. This method treats the raw packet as read-only, it doesn't change anything
* in it
* @param[in] checkMtu Whether the length of the packet's payload should be checked against the MTU. If enabled this comes with a small performance penalty.
* Default value is false to avoid performance overhead. Set to true if you don't know whether packets fit the live device's MTU and you can afford the overhead.
* @return True if packet was sent successfully. False will be returned in the following cases (relevant log error is printed in any case):
* - Device is not opened
* - Packet length is 0
* - Packet length is larger than device MTU
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
bool sendPacket(RawPacket const& rawPacket, bool checkMtu = false);
/**
* Send a buffer containing packet raw data (including all layers) to the network.
* This particular version of the sendPacket method should only be used if you already have access to the size of the network layer of the packet,
* since it allows you to check the payload size (see packetPayloadLength parameter) MTU of the live device without incurring a parsing overhead.
* If the packetPayloadLength is unknown, please use a different implementation of the sendPacket method.
* @param[in] packetData The buffer containing the packet raw data
* @param[in] packetDataLength The length of the buffer (this is the entire packet, including link layer)
* @param[in] packetPayloadLength The length of the payload for the data link layer. This includes all data apart from the header for the
* data link layer.
* @return True if the packet was sent successfully. False will be returned in the following cases (relevant log error is printed in any case):
* - Device is not opened
* - Packet data length is 0
* - Packet payload length is larger than device MTU
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
bool sendPacket(const uint8_t* packetData, int packetDataLength, int packetPayloadLength);
/**
* Send a buffer containing packet raw data (including all layers) to the network
* @param[in] packetData The buffer containing the packet raw data
* @param[in] packetDataLength The length of the buffer
* @param[in] checkMtu Whether the length of the packet's payload should be checked against the MTU. If enabled this comes with a small performance penalty.
* Default value is false to avoid performance overhead. Set to true if you don't know whether packets fit the live device's MTU and you can afford the overhead.
* @param[in] linkType Only used if checkMtu is true. Defines the layer type for parsing the first layer of the packet. Used for parsing the packet to
* perform the MTU check. Default value is pcpp::LINKTYPE_ETHERNET. Ensure this parameter matches the linktype of the packet if checkMtu is true.
* @return True if packet was sent successfully. False will be returned in the following cases (relevant log error is printed in any case):
* - Device is not opened
* - Packet length is 0
* - Packet length is larger than device MTU and checkMtu is true
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
bool sendPacket(const uint8_t* packetData, int packetDataLength, bool checkMtu = false, pcpp::LinkLayerType linkType = pcpp::LINKTYPE_ETHERNET);
/**
* Send a parsed Packet to the network
* @param[in] packet A pointer to the packet to send. This method treats the packet as read-only, it doesn't change anything in it
* @param[in] checkMtu Whether the length of the packet's payload should be checked against the MTU. Default value is true, since the packet
* being passed in has already been parsed, so checking the MTU does not incur significant processing overhead.
* @return True if packet was sent successfully. False will be returned in the following cases (relevant log error is printed in any case):
* - Device is not opened
* - Packet length is 0
* - Packet length is larger than device MTU and checkMtu is true
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
bool sendPacket(Packet* packet, bool checkMtu = true);
/**
* Send an array of RawPacket objects to the network
* @param[in] rawPacketsArr The array of RawPacket objects to send. This method treats all packets as read-only, it doesn't change anything
* in them
* @param[in] arrLength The length of the array
* @param[in] checkMtu Whether to check the size of the packet payload against MTU size. Incurs a parsing overhead.
* Default value is false to avoid performance overhead. Set to true if you don't know whether packets fit the live device's MTU and you can afford the overhead.
* @return The number of packets sent successfully. Sending a packet can fail if:
* - Device is not opened. In this case no packets will be sent, return value will be 0
* - Packet length is 0
* - Packet length is larger than device MTU and checkMtu is true
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
virtual int sendPackets(RawPacket* rawPacketsArr, int arrLength, bool checkMtu = false);
/**
* Send an array of pointers to Packet objects to the network
* @param[in] packetsArr The array of pointers to Packet objects to send. This method treats all packets as read-only, it doesn't change
* anything in them
* @param[in] arrLength The length of the array
* @param[in] checkMtu Whether to check the size of the packet payload against MTU size. Default value is true, since the packets
* being passed in has already been parsed, so checking the MTU does not incur significant processing overhead.
* @return The number of packets sent successfully. Sending a packet can fail if:
* - Device is not opened. In this case no packets will be sent, return value will be 0
* - Packet length is 0
* - Packet length is larger than device MTU and checkMtu is true
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
virtual int sendPackets(Packet** packetsArr, int arrLength, bool checkMtu = true);
/**
* Send a vector of pointers to RawPacket objects to the network
* @param[in] rawPackets The array of pointers to RawPacket objects to send. This method treats all packets as read-only, it doesn't change
* anything in them
* @param[in] checkMtu Whether to check the size of the packet payload against MTU size. Incurs a parsing overhead.
* Default value is false to avoid performance overhead. Set to true if you don't know whether packets fit the live device's MTU and you can afford the overhead.
* @return The number of packets sent successfully. Sending a packet can fail if:
* - Device is not opened. In this case no packets will be sent, return value will be 0
* - Packet length is 0
* - Packet length is larger than device MTU and checkMtu is true
* - Packet could not be sent due to some error in libpcap/WinPcap/Npcap
*/
virtual int sendPackets(const RawPacketVector& rawPackets, bool checkMtu = false);
// implement abstract methods
/**
* Open the device using libpcap pcap_open_live. Opening the device only makes the device ready for use, it doesn't start packet capturing.
* For packet capturing the user should call startCapture(). This implies that calling this method is a must before calling startCapture()
* (otherwise startCapture() will fail with a "device not open" error). The device is opened in promiscuous mode
* @return True if the device was opened successfully, false otherwise. When opening the device fails an error will be printed to log
* as well
*/
bool open();
/**
* Enables to open a device in a non-default configuration. Configuration has parameters like packet buffer timeout & size, open in
* promiscuous/non-promiscuous mode, etc. Please check DeviceConfiguration for more details
* @param[in] config The requested configuration
* @return Same as open()
*/
bool open(const DeviceConfiguration& config);
void close();
/**
* Clones the current device class
* @return Pointer to the copied class
*/
PcapLiveDevice* clone();
virtual void getStatistics(IPcapDevice::PcapStats& stats) const;
protected:
pcap_t* doOpen(const DeviceConfiguration& config);
};
} // namespace pcpp
#endif
Reference in New Issue View Git Blame Copy Permalink