implement poll() for startCaptureBlockingMode

Pcap++/header/PcapLiveDevice.h

@@ -87,6 +87,7 @@ namespace pcpp
 		// 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;
+		int m_PcapSelectableFd;
 		std::string m_Name;
 		std::string m_Description;
 		bool m_IsLoopback;
@@ -109,6 +110,7 @@ namespace pcpp
 		RawPacketVector* m_CapturedPackets;
 		bool m_CaptureCallbackMode;
 		LinkLayerType m_LinkType;
+		bool m_UsePoll;
 
 		// 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);
@@ -217,6 +219,11 @@ namespace pcpp
 			*/
 			unsigned int nflogGroup;
 
+
+			/// In Unix-like system, use poll() for blocking mode.
+			bool usePoll;
+
+
 			/**
 			 * A c'tor for this struct
 			 * @param[in] mode The mode to open the device: promiscuous or non-promiscuous. Default value is promiscuous
@@ -231,16 +238,18 @@ namespace pcpp
 			 * 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.
 			 * @param[in] nflogGroup NFLOG group for NFLOG devices. Default value is 0.
+			 * @param[in] usePoll use `poll()` when capturing packets in blocking more (`startCaptureBlockingMode()`) on Unix-like system. Default value is false.
 			*/
 			explicit DeviceConfiguration(DeviceMode mode = Promiscuous, int packetBufferTimeoutMs = 0, int packetBufferSize = 0,
-				                PcapDirection direction = PCPP_INOUT, int snapshotLength = 0, unsigned int nflogGroup = 0)
+				                PcapDirection direction = PCPP_INOUT, int snapshotLength = 0, unsigned int nflogGroup = 0, bool usePoll = false)
 			{
 				this->mode = mode;
 				this->packetBufferTimeoutMs = packetBufferTimeoutMs;
 				this->packetBufferSize = packetBufferSize;
 				this->direction = direction;
 				this->snapshotLength = snapshotLength;
 				this->nflogGroup = nflogGroup;
+				this->usePoll = usePoll;
 			}
 		};
 
@@ -402,13 +411,14 @@ namespace pcpp
 		 * @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
+		 * @param[in] timeout A timeout in seconds for the blocking to stop even if the user didn't return "true" in the onPacketArrives callback.
+		 * The precision of `timeout` is millisecond, e.g. 2.345 seconds means 2345 milliseconds.
+		 * If this timeout is set to 0 or less the timeout will be ignored, meaning the method will keep handling packets until the `onPacketArrives`
+		 * callback returns `true`.
 		 * @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);
+		virtual int startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacketArrives, void* userCookie, const double timeout);
 
 		/**
 		 * Stop a currently running packet capture. This method terminates gracefully both packet capture thread and periodic stats collection

Pcap++/src/PcapLiveDevice.cpp

@@ -14,6 +14,7 @@
 #include <string.h>
 #include <iostream>
 #include <fstream>
+#include <chrono>
 #include <sstream>
 #if defined(_WIN32)
 // The definition of BPF_MAJOR_VERSION is required to support Npcap. In Npcap there are
@@ -30,6 +31,8 @@
 #include <arpa/inet.h>
 #include <sys/ioctl.h>
 #include <net/if.h>
+#include <poll.h>
+#include <pcap/pcap.h>
 #endif // if defined(_WIN32)
 #if defined(__APPLE__) || defined(__FreeBSD__)
 #include <net/if_dl.h>
@@ -64,8 +67,8 @@ static pcap_direction_t directionTypeMap(PcapLiveDevice::PcapDirection direction
 
 
 
-PcapLiveDevice::PcapLiveDevice(pcap_if_t* pInterface, bool calculateMTU, bool calculateMacAddress, bool calculateDefaultGateway) : IPcapDevice(),
-		m_MacAddress(""), m_DefaultGateway(IPv4Address::Zero)
+PcapLiveDevice::PcapLiveDevice(pcap_if_t* pInterface, bool calculateMTU, bool calculateMacAddress, bool calculateDefaultGateway) :
+	IPcapDevice(), m_PcapSelectableFd(-1), m_MacAddress(""), m_DefaultGateway(IPv4Address::Zero), m_UsePoll(false)
 {
 	m_DeviceMtu = 0;
 	m_LinkType = LINKTYPE_ETHERNET;
@@ -346,6 +349,21 @@ bool PcapLiveDevice::open(const DeviceConfiguration& config)
 
 	m_DeviceOpened = true;
 
+	if(!config.usePoll)
+	{
+		m_UsePoll = false;
+		m_PcapSelectableFd = -1;
+	}
+	else
+	{
+#if !defined(_WIN32)
+		m_UsePoll = true;
+		m_PcapSelectableFd = pcap_get_selectable_fd(m_PcapSendDescriptor);
+#else
+		PCPP_LOG_ERROR("Windows doesn't support poll(), ignoring the `usePoll` parameter");
+#endif
+	}
+
 	return true;
 }
 
@@ -478,7 +496,7 @@ bool PcapLiveDevice::startCapture(RawPacketVector& capturedPacketsVector)
 }
 
 
-int PcapLiveDevice::startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacketArrives, void* userCookie, int timeout)
+int PcapLiveDevice::startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacketArrives, void* userCookie, const double timeout)
 {
 	if (!m_DeviceOpened || m_PcapDescriptor == nullptr)
 	{
@@ -500,48 +518,84 @@ int PcapLiveDevice::startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacke
 	m_cbOnPacketArrivesBlockingMode = onPacketArrives;
 	m_cbOnPacketArrivesBlockingModeUserCookie = userCookie;
 
-	long startTimeSec = 0, startTimeNSec = 0;
-	clockGetTime(startTimeSec, startTimeNSec);
-
-	long curTimeSec = 0;
-
 	m_CaptureThreadStarted = true;
 	m_StopThread = false;
 
+	const int64_t timeoutMs = timeout * 1000; // timeout unit is seconds, let's change it to milliseconds
+	auto startTime = std::chrono::steady_clock::now();
+	auto currentTime = startTime;
+
+#if !defined(_WIN32)
+	struct pollfd pcapPollFd;
+	memset(&pcapPollFd, 0, sizeof(pcapPollFd));
+	pcapPollFd.fd = m_PcapSelectableFd;
+	pcapPollFd.events = POLLIN;
+#endif
+
 	bool pcapDispatchError = false;
 
-	if (timeout <= 0)
+	if(timeoutMs <= 0)
 	{
 		while (!m_StopThread)
 		{
-			if (pcap_dispatch(m_PcapDescriptor, -1, onPacketArrivesBlockingMode, reinterpret_cast<uint8_t*>(this)) == -1)
+			if(pcap_dispatch(m_PcapDescriptor, -1, onPacketArrivesBlockingMode, (uint8_t*)this) < 0)
 			{
 				PCPP_LOG_ERROR("pcap_dispatch returned an error: " << pcap_geterr(m_PcapDescriptor));
 				pcapDispatchError = true;
 				m_StopThread = true;
 			}
 		}
-		curTimeSec = startTimeSec + timeout;
 	}
 	else
 	{
-		while (!m_StopThread && curTimeSec <= (startTimeSec + timeout))
+		while (!m_StopThread && std::chrono::duration_cast<std::chrono::milliseconds>(currentTime  - startTime).count() < timeoutMs )
 		{
-			long curTimeNSec = 0;
-			if (pcap_dispatch(m_PcapDescriptor, -1, onPacketArrivesBlockingMode, reinterpret_cast<uint8_t*>(this)) == -1)
+			if(m_UsePoll)
 			{
-				PCPP_LOG_ERROR("pcap_dispatch returned an error: " << pcap_geterr(m_PcapDescriptor));
-				pcapDispatchError = true;
-				m_StopThread = true;
+#if !defined(_WIN32)
+				// Be careful when you modify the code related to `poll` in this block
+				// Some tests are not supported to run on CIs: `TestPcapLiveDeviceBlockingModePollTimeout`, `TestPcapLiveDeviceBlockingModeNotTimeoutWithoutPoll`
+				// Please turn on `MANUAL_TEST` flag and at least ensure that it works on your machine
+
+				int64_t pollTimeoutMs = timeoutMs - std::chrono::duration_cast<std::chrono::milliseconds>(currentTime  - startTime).count();
+				pollTimeoutMs = std::max(pollTimeoutMs, (int64_t)0); // poll will be in blocking mode if negative value
+
+				int ready = poll(&pcapPollFd, 1, pollTimeoutMs); // wait the packets until timeout
+
+				if(ready > 0)
+				{
+					if(pcap_dispatch(m_PcapDescriptor, -1, onPacketArrivesBlockingMode, (uint8_t*)this) < 0)
+					{
+						PCPP_LOG_ERROR("pcap_dispatch returned an error: " << pcap_geterr(m_PcapDescriptor));
+						pcapDispatchError = true;
+						m_StopThread = true;
+					}
+				}
+				else if(ready < 0)
+				{
+					PCPP_LOG_ERROR("poll() got error '" <<  strerror(errno) << "'");
+					return -1;
+				}
+#else
+				PCPP_LOG_ERROR("Windows doesn't support poll()");
+				return 0;
+#endif
 			}
-			clockGetTime(curTimeSec, curTimeNSec);
+			else
+			{
+				if(pcap_dispatch(m_PcapDescriptor, -1, onPacketArrivesBlockingMode, (uint8_t*)this) < 0)
+				{
+					PCPP_LOG_ERROR("pcap_dispatch returned an error: " << pcap_geterr(m_PcapDescriptor));
+					pcapDispatchError = true;
+					m_StopThread = true;
+				}
+			}
+			currentTime = std::chrono::steady_clock::now();
 		}
 	}
 
 	m_CaptureThreadStarted = false;
-
 	m_StopThread = false;
-
 	m_cbOnPacketArrivesBlockingMode = nullptr;
 	m_cbOnPacketArrivesBlockingModeUserCookie = nullptr;
 
@@ -550,8 +604,10 @@ int PcapLiveDevice::startCaptureBlockingMode(OnPacketArrivesStopBlocking onPacke
 		return 0;
 	}
 
-	if (curTimeSec > (startTimeSec + timeout))
+	if (std::chrono::duration_cast<std::chrono::milliseconds>(currentTime  - startTime).count() >= timeoutMs )
+	{
 		return -1;
+	}
 	return 1;
 }
 

Tests/Pcap++Test/Common/TestUtils.h

@@ -36,6 +36,34 @@ class DeviceTeardown
 	}
 };
 
+class SystemCommandTeardown
+{
+private:
+	std::string m_command;
+	bool m_CancelTeardown;
+
+public:
+
+	explicit SystemCommandTeardown(const std::string& command) : m_command(command) , m_CancelTeardown(false) {}
+
+	~SystemCommandTeardown() noexcept(false)
+	{
+		if (!m_CancelTeardown)
+		{
+			if(std::system(m_command.c_str()) < 0)
+			{
+				// cppcheck-suppress exceptThrowInDestructor
+				throw std::runtime_error("failed to run: " + m_command);
+			}
+		}
+	}
+
+	void cancelTeardown()
+	{
+		m_CancelTeardown = true;
+	}
+};
+
 bool sendURLRequest(const std::string &url);
 
 bool readPcapIntoPacketVec(const std::string& pcapFileName, std::vector<pcpp::RawPacket>& packetStream, std::string& errMsg);

Tests/Pcap++Test/TestDefinition.h

@@ -36,6 +36,8 @@ PTF_TEST_CASE(TestPcapLiveDeviceClone);
 PTF_TEST_CASE(TestPcapLiveDeviceNoNetworking);
 PTF_TEST_CASE(TestPcapLiveDeviceStatsMode);
 PTF_TEST_CASE(TestPcapLiveDeviceBlockingMode);
+PTF_TEST_CASE(TestPcapLiveDeviceBlockingModePollTimeout);
+PTF_TEST_CASE(TestPcapLiveDeviceBlockingModeNotTimeoutWithoutPoll);
 PTF_TEST_CASE(TestPcapLiveDeviceSpecialCfg);
 PTF_TEST_CASE(TestWinPcapLiveDevice);
 PTF_TEST_CASE(TestSendPacket);