Refactor: Use std::chrono for sleep and SystemUtils (#1858)

Author: adityaxa

Common++/src/SystemUtils.cpp

@@ -31,22 +31,18 @@
 #endif
 
 #ifdef _MSC_VER
+#	include <chrono>
 int gettimeofday(struct timeval* tp, struct timezone* tzp)
 {
-	// Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's
-	static const uint64_t EPOCH = ((uint64_t)116444736000000000ULL);
 
-	SYSTEMTIME system_time;
-	FILETIME file_time;
-	uint64_t time;
+	auto now = std::chrono::system_clock::now();
+	auto duration = now.time_since_epoch();
 
-	GetSystemTime(&system_time);
-	SystemTimeToFileTime(&system_time, &file_time);
-	time = ((uint64_t)file_time.dwLowDateTime);
-	time += ((uint64_t)file_time.dwHighDateTime) << 32;
+	auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+	auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration - seconds);
 
-	tp->tv_sec = (long)((time - EPOCH) / 10000000L);
-	tp->tv_usec = (long)(system_time.wMilliseconds * 1000);
+	tp->tv_sec = static_cast<long>(seconds.count());
+	tp->tv_usec = static_cast<long>(microseconds.count());
 	return 0;
 }
 #endif
@@ -211,63 +207,18 @@ namespace pcpp
 
 	int clockGetTime(long& sec, long& nsec)
 	{
-		sec = 0;
-		nsec = 0;
+		using namespace std::chrono;
 
-#if defined(_WIN32)
-
-#	define CLOCK_GETTIME_BILLION (1E9)
-
-		static BOOL clock_gettime_first_time = 1;
-		static LARGE_INTEGER clock_gettime_counts_per_sec;
-
-		LARGE_INTEGER count;
-
-		if (clock_gettime_first_time)
-		{
-			clock_gettime_first_time = 0;
-
-			if (0 == QueryPerformanceFrequency(&clock_gettime_counts_per_sec))
-			{
-				clock_gettime_counts_per_sec.QuadPart = 0;
-			}
-		}
-
-		if ((clock_gettime_counts_per_sec.QuadPart <= 0) || (0 == QueryPerformanceCounter(&count)))
-		{
-			return -1;
-		}
-
-		sec = count.QuadPart / clock_gettime_counts_per_sec.QuadPart;
-		nsec = ((count.QuadPart % clock_gettime_counts_per_sec.QuadPart) * CLOCK_GETTIME_BILLION) /
-		       clock_gettime_counts_per_sec.QuadPart;
+		auto now = system_clock::now();
+		auto duration = now.time_since_epoch();
 
-		return 0;
-
-#elif defined(__APPLE__)
+		auto secondsDuration = duration_cast<seconds>(duration);
+		auto nanosecondsDuration = duration_cast<nanoseconds>(duration - secondsDuration);
 
-		clock_serv_t cclock;
-		mach_timespec_t mts;
-		host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
-		clock_get_time(cclock, &mts);
-		mach_port_deallocate(mach_task_self(), cclock);
-		sec = mts.tv_sec;
-		nsec = mts.tv_nsec;
+		sec = static_cast<long>(secondsDuration.count());
+		nsec = static_cast<long>(nanosecondsDuration.count());
 
 		return 0;
-
-#else  // Linux
-
-		timespec tspec{};
-		const int res = clock_gettime(CLOCK_REALTIME, &tspec);
-		if (res == 0)
-		{
-			sec = tspec.tv_sec;
-			nsec = tspec.tv_nsec;
-		}
-		return res;
-
-#endif
 	}
 
 	time_t mkUtcTime(std::tm& tm)

Examples/IcmpFileTransfer/IcmpFileTransfer-pitcher.cpp

@@ -316,7 +316,7 @@ void receiveFile(pcpp::IPv4Address pitcherIP, pcpp::IPv4Address catcherIP, int p
 
 			// if rate limit was set by the user, sleep between sending packets
 			if (packetPerSec > 1)
-				usleep(sleepBetweenPackets);
+				std::this_thread::sleep_for(std::chrono::microseconds(sleepBetweenPackets));
 			else if (packetPerSec == 1)
 				std::this_thread::sleep_for(std::chrono::seconds(1));
 
@@ -334,7 +334,7 @@ void receiveFile(pcpp::IPv4Address pitcherIP, pcpp::IPv4Address catcherIP, int p
 			{
 				sendIcmpRequest(dev, pitcherMacAddr, catcherMacAddr, pitcherIP, catcherIP, icmpId, ICMP_FT_ABORT,
 				                nullptr, 0);
-				usleep(SLEEP_BETWEEN_ABORT_MESSAGES);
+				std::this_thread::sleep_for(std::chrono::microseconds(SLEEP_BETWEEN_ABORT_MESSAGES));
 			}
 
 			file.close();
@@ -502,7 +502,7 @@ void sendFile(const std::string& filePath, pcpp::IPv4Address pitcherIP, pcpp::IP
 
 			// use usleep or sleep (see comment a few lines below)
 			if (packetPerSec > 1)
-				usleep(sleepBetweenPackets);
+				std::this_thread::sleep_for(std::chrono::microseconds(sleepBetweenPackets));
 			else if (packetPerSec == 1)
 				std::this_thread::sleep_for(std::chrono::seconds(1));
 

Pcap++/src/DpdkDevice.cpp

@@ -20,6 +20,8 @@
 #include "rte_cycles.h"
 #include <string>
 #include <unistd.h>
+#include <chrono>
+#include <thread>
 
 #define MAX_BURST_SIZE 64
 
@@ -1115,7 +1117,7 @@ namespace pcpp
 					{
 						PCPP_LOG_DEBUG(
 						    "Since NIC couldn't send all packet in this iteration, waiting for 0.2 second for H/W descriptors to get free");
-						usleep(200000);
+						std::this_thread::sleep_for(std::chrono::microseconds(200000));
 						lastSleep = packetsSent;
 					}
 				}

Pcap++/src/KniDevice.cpp

@@ -7,7 +7,6 @@
 #include "SystemUtils.h"
 
 #include <unistd.h>
-#include <time.h>
 #include <thread>
 #include <sys/ioctl.h>
 #include <net/if.h>
@@ -410,7 +409,8 @@ namespace pcpp
 		struct rte_kni* kni_dev = device->m_Device;
 		for (;;)
 		{
-			nanosleep(&sleepTime, nullptr);
+			std::this_thread::sleep_for(std::chrono::seconds(sleepTime.tv_sec) +
+			                            std::chrono::nanoseconds(sleepTime.tv_nsec));
 			rte_kni_handle_request(kni_dev);
 			if (stopThread)
 			{

Pcap++/src/NetworkUtils.cpp

@@ -31,15 +31,15 @@ namespace pcpp
 		std::mutex& mutex;
 		std::condition_variable& cond;
 		IPv4Address ipAddr;
-		clock_t start;
+		std::chrono::steady_clock::time_point start;
 		MacAddress result;
 		double arpResponseTime;
 	};
 
 	static void arpPacketReceived(RawPacket* rawPacket, PcapLiveDevice*, void* userCookie)
 	{
 		// extract timestamp of packet
-		clock_t receiveTime = clock();
+		auto receiveTime = std::chrono::steady_clock::now();
 
 		// get the data from the main thread
 		ArpingReceivedData* data = (ArpingReceivedData*)userCookie;
@@ -66,8 +66,8 @@ namespace pcpp
 			return;
 
 		// measure response time
-		double diffticks = receiveTime - data->start;
-		double diffms = (diffticks * 1000) / CLOCKS_PER_SEC;
+		auto duration = receiveTime - data->start;
+		auto diffms = std::chrono::duration<double, std::milli>(duration).count();
 
 		data->arpResponseTime = diffms;
 		data->result = arpReplyLayer->getSenderMacAddress();
@@ -143,7 +143,7 @@ namespace pcpp
 		// this is the token that passes between the 2 threads. It contains pointers to the conditional mutex, the
 		// target IP for identifying the ARP response, the iteration index and a timestamp to calculate the response
 		// time
-		ArpingReceivedData data = { mutex, cond, ipAddr, clock(), MacAddress::Zero, 0 };
+		ArpingReceivedData data = { mutex, cond, ipAddr, std::chrono::steady_clock::now(), MacAddress::Zero, 0 };
 
 		struct timeval now;
 		gettimeofday(&now, nullptr);
@@ -186,7 +186,7 @@ namespace pcpp
 		std::condition_variable& cond;
 		std::string hostname;
 		uint16_t transactionID;
-		clock_t start;
+		std::chrono::steady_clock::time_point start;
 		IPv4Address result;
 		uint32_t ttl;
 		double dnsResponseTime;
@@ -195,7 +195,7 @@ namespace pcpp
 	static void dnsResponseReceived(RawPacket* rawPacket, PcapLiveDevice*, void* userCookie)
 	{
 		// extract timestamp of packet
-		clock_t receiveTime = clock();
+		auto receiveTime = std::chrono::steady_clock::now();
 
 		// get data from the main thread
 		DNSReceivedData* data = (DNSReceivedData*)userCookie;
@@ -268,8 +268,8 @@ namespace pcpp
 		// if we got here it means an IPv4 resolving was found
 
 		// measure response time
-		clock_t diffticks = receiveTime - data->start;
-		double diffms = (diffticks * 1000.0) / CLOCKS_PER_SEC;
+		auto duration = receiveTime - data->start;
+		auto diffms = std::chrono::duration<double, std::milli>(duration).count();
 
 		data->dnsResponseTime = diffms;
 		data->result = dnsAnswer->getData()->castAs<IPv4DnsResourceData>()->getIpAddress();
@@ -386,7 +386,9 @@ namespace pcpp
 		std::condition_variable cond;
 
 		// this is the token that passes between the 2 threads
-		DNSReceivedData data = { mutex, cond, hostname, transactionID, clock(), IPv4Address::Zero, 0, 0 };
+		DNSReceivedData data = {
+			mutex, cond, hostname, transactionID, std::chrono::steady_clock::now(), IPv4Address::Zero, 0, 0
+		};
 
 		struct timeval now;
 		gettimeofday(&now, nullptr);

Pcap++/src/PfRingDevice.cpp

@@ -831,7 +831,7 @@ namespace pcpp
 				    "Try #"
 				    << tries
 				    << ": Got ENOBUFS (write buffer full) error while sending packet. Sleeping 20 usec and trying again");
-				usleep(2000);
+				std::this_thread::sleep_for(std::chrono::microseconds(2000));
 			}
 			else
 				break;