some C++14 migration (#1953)

tigercosmos · web-flow · commit 1eff7bb01092 · 2025-09-11T15:24:39.000+08:00
* some C++14 migration

* format

* more fix

* more

* code review

* test
diff --git a/Packet++/header/IPReassembly.h b/Packet++/header/IPReassembly.h
@@ -284,7 +284,7 @@ namespace pcpp
 		/// @param[in] key A pointer to the identifier of the packet that is being dropped
 		/// @param[in] userCookie A pointer to the cookie provided by the user in IPReassemby c'tor (or nullptr if no
 		/// cookie provided)
-		typedef void (*OnFragmentsClean)(const PacketKey* key, void* userCookie);
+		using OnFragmentsClean = void (*)(const PacketKey* key, void* userCookie);
 
 		/// An enum representing the status returned from processing a fragment
 		enum ReassemblyStatus
diff --git a/Packet++/header/ProtocolType.h b/Packet++/header/ProtocolType.h
@@ -32,11 +32,11 @@ namespace pcpp
 
 	/// @typedef ProtocolType
 	/// Representing all protocols supported by PcapPlusPlus
-	typedef uint8_t ProtocolType;
+	using ProtocolType = uint8_t;
 
 	/// @typedef ProtocolTypeFamily
 	/// Representing a family of protocols
-	typedef uint32_t ProtocolTypeFamily;
+	using ProtocolTypeFamily = uint32_t;
 
 	/// Unknown protocol (or unsupported by PcapPlusPlus)
 	const ProtocolType UnknownProtocol = 0;
diff --git a/Packet++/header/SomeIpSdLayer.h b/Packet++/header/SomeIpSdLayer.h
@@ -508,10 +508,10 @@ namespace pcpp
 	public:
 		friend class SomeIpSdEntry;
 
-		typedef SomeIpSdEntry* EntryPtr;
-		typedef std::vector<EntryPtr> EntriesVec;
-		typedef SomeIpSdOption* OptionPtr;
-		typedef std::vector<OptionPtr> OptionsVec;
+		using EntryPtr = SomeIpSdEntry*;
+		using EntriesVec = std::vector<EntryPtr>;
+		using OptionPtr = SomeIpSdOption*;
+		using OptionsVec = std::vector<OptionPtr>;
 
 		/// A constructor that creates the layer from an existing packet raw data
 		/// @param[in] data A pointer to the raw data
diff --git a/Packet++/header/TcpReassembly.h b/Packet++/header/TcpReassembly.h
@@ -308,7 +308,7 @@ namespace pcpp
 		};
 
 		/// The type for storing the connection information
-		typedef std::unordered_map<uint32_t, ConnectionData> ConnectionInfoList;
+		using ConnectionInfoList = std::unordered_map<uint32_t, ConnectionData>;
 
 		/// @typedef OnTcpMessageReady
 		/// A callback invoked when new data arrives on a connection
@@ -459,8 +459,8 @@ namespace pcpp
 			OutOfOrderProcessingGuard& operator=(const OutOfOrderProcessingGuard&) = delete;
 		};
 
-		typedef std::unordered_map<uint32_t, TcpReassemblyData> ConnectionList;
-		typedef std::map<time_t, std::list<uint32_t>> CleanupList;
+		using ConnectionList = std::unordered_map<uint32_t, TcpReassemblyData>;
+		using CleanupList = std::map<time_t, std::list<uint32_t>>;
 
 		OnTcpMessageReady m_OnMessageReadyCallback;
 		OnTcpConnectionStart m_OnConnStart;
diff --git a/Packet++/src/DnsResource.cpp b/Packet++/src/DnsResource.cpp
@@ -196,8 +196,8 @@ namespace pcpp
 
 	DnsType IDnsResource::getDnsType() const
 	{
-		uint16_t dnsType = *(uint16_t*)(getRawData() + m_NameLength);
-		return (DnsType)be16toh(dnsType);
+		uint16_t dnsType = *reinterpret_cast<uint16_t*>(getRawData() + m_NameLength);
+		return static_cast<DnsType>(be16toh(dnsType));
 	}
 
 	void IDnsResource::setDnsType(DnsType newType)
@@ -208,8 +208,8 @@ namespace pcpp
 
 	DnsClass IDnsResource::getDnsClass() const
 	{
-		uint16_t dnsClass = *(uint16_t*)(getRawData() + m_NameLength + sizeof(uint16_t));
-		return (DnsClass)be16toh(dnsClass);
+		uint16_t dnsClass = *reinterpret_cast<uint16_t*>(getRawData() + m_NameLength + sizeof(uint16_t));
+		return static_cast<DnsClass>(be16toh(dnsClass));
 	}
 
 	void IDnsResource::setDnsClass(DnsClass newClass)
@@ -268,7 +268,7 @@ namespace pcpp
 
 	uint32_t DnsResource::getTTL() const
 	{
-		uint32_t ttl = *(uint32_t*)(getRawData() + m_NameLength + 2 * sizeof(uint16_t));
+		uint32_t ttl = *reinterpret_cast<uint32_t*>(getRawData() + m_NameLength + 2 * sizeof(uint16_t));
 		return be32toh(ttl);
 	}
 
@@ -290,7 +290,7 @@ namespace pcpp
 			return 0;
 		}
 
-		uint16_t dataLength = *(uint16_t*)(getRawData() + sizeToRead);
+		uint16_t dataLength = *reinterpret_cast<uint16_t*>(getRawData() + sizeToRead);
 		return be16toh(dataLength);
 	}
 
@@ -444,7 +444,7 @@ namespace pcpp
 
 	uint16_t DnsResource::getCustomDnsClass() const
 	{
-		uint16_t value = *(uint16_t*)(getRawData() + m_NameLength + sizeof(uint16_t));
+		uint16_t value = *reinterpret_cast<uint16_t*>(getRawData() + m_NameLength + sizeof(uint16_t));
 		return be16toh(value);
 	}
 
diff --git a/Packet++/src/IgmpLayer.cpp b/Packet++/src/IgmpLayer.cpp
@@ -88,7 +88,7 @@ namespace pcpp
 	uint16_t IgmpLayer::calculateChecksum()
 	{
 		ScalarBuffer<uint16_t> buffer;
-		buffer.buffer = (uint16_t*)getIgmpHeader();
+		buffer.buffer = reinterpret_cast<uint16_t*>(getIgmpHeader());
 		buffer.len = getHeaderLen();
 		return computeChecksum(&buffer, 1);
 	}
@@ -224,7 +224,7 @@ namespace pcpp
 			return IPv4Address();
 
 		uint8_t* ptr = m_Data + ptrOffset;
-		return IPv4Address(*(uint32_t*)ptr);
+		return IPv4Address(*reinterpret_cast<uint32_t*>(ptr));
 	}
 
 	size_t IgmpV3QueryLayer::getHeaderLen() const
@@ -256,7 +256,7 @@ namespace pcpp
 	{
 		uint16_t sourceAddrCount = getSourceAddressCount();
 
-		if (index < 0 || index > (int)sourceAddrCount)
+		if (index < 0 || index > static_cast<int>(sourceAddrCount))
 		{
 			PCPP_LOG_ERROR("Cannot add source address at index " << index << ", index is out of bounds");
 			return false;
@@ -286,7 +286,7 @@ namespace pcpp
 	{
 		uint16_t sourceAddrCount = getSourceAddressCount();
 
-		if (index < 0 || index > (int)sourceAddrCount - 1)
+		if (index < 0 || index > static_cast<int>(sourceAddrCount) - 1)
 		{
 			PCPP_LOG_ERROR("Cannot remove source address at index " << index << ", index is out of bounds");
 			return false;
@@ -348,11 +348,13 @@ namespace pcpp
 		if (groupRecord == nullptr)
 			return nullptr;
 
-		// prev group was the last group
-		if ((uint8_t*)groupRecord + groupRecord->getRecordLen() - m_Data >= (int)getHeaderLen())
+		uint8_t* nextGroupRecordBegin = reinterpret_cast<uint8_t*>(groupRecord) + groupRecord->getRecordLen();
+		if (std::distance(m_Data, nextGroupRecordBegin) >= static_cast<std::ptrdiff_t>(getHeaderLen()))
+		{
 			return nullptr;
+		}
 
-		igmpv3_group_record* nextGroup = (igmpv3_group_record*)((uint8_t*)groupRecord + groupRecord->getRecordLen());
+		igmpv3_group_record* nextGroup = reinterpret_cast<igmpv3_group_record*>(nextGroupRecordBegin);
 
 		return nextGroup;
 	}
@@ -368,7 +370,7 @@ namespace pcpp
 	                                                         const std::vector<IPv4Address>& sourceAddresses,
 	                                                         int offset)
 	{
-		if (offset > (int)getHeaderLen())
+		if (offset > static_cast<int>(getHeaderLen()))
 		{
 			PCPP_LOG_ERROR("Cannot add group record, offset is out of layer bounds");
 			return nullptr;
@@ -403,13 +405,13 @@ namespace pcpp
 
 		getReportHeader()->numOfGroupRecords = htobe16(getGroupRecordCount() + 1);
 
-		return (igmpv3_group_record*)(m_Data + offset);
+		return reinterpret_cast<igmpv3_group_record*>(m_Data + offset);
 	}
 
 	igmpv3_group_record* IgmpV3ReportLayer::addGroupRecord(uint8_t recordType, const IPv4Address& multicastAddress,
 	                                                       const std::vector<IPv4Address>& sourceAddresses)
 	{
-		return addGroupRecordAt(recordType, multicastAddress, sourceAddresses, (int)getHeaderLen());
+		return addGroupRecordAt(recordType, multicastAddress, sourceAddresses, static_cast<int>(getHeaderLen()));
 	}
 
 	igmpv3_group_record* IgmpV3ReportLayer::addGroupRecordAtIndex(uint8_t recordType,
@@ -509,7 +511,7 @@ namespace pcpp
 
 		int offset = index * sizeof(uint32_t);
 		const uint8_t* ptr = sourceAddresses + offset;
-		return IPv4Address(*(uint32_t*)ptr);
+		return IPv4Address(*reinterpret_cast<const uint32_t*>(ptr));
 	}
 
 	size_t igmpv3_group_record::getRecordLen() const
diff --git a/Packet++/src/PPPoELayer.cpp b/Packet++/src/PPPoELayer.cpp
@@ -256,7 +256,7 @@ namespace pcpp
 		if (m_Data == nullptr)
 			return PPPoEDiscoveryLayer::PPPoETagTypes::PPPOE_TAG_EOL;
 
-		return (PPPoEDiscoveryLayer::PPPoETagTypes)be16toh(m_Data->recordType);
+		return static_cast<PPPoEDiscoveryLayer::PPPoETagTypes>(be16toh(m_Data->recordType));
 	}
 
 	size_t PPPoEDiscoveryLayer::PPPoETag::getTotalSize() const
diff --git a/Packet++/src/PacketUtils.cpp b/Packet++/src/PacketUtils.cpp
@@ -28,7 +28,7 @@ namespace pcpp
 			if (vec[i].len % 2)
 			{
 				// access to the last byte using an uint8_t pointer
-				uint8_t* vecBytes = (uint8_t*)vec[i].buffer;
+				uint8_t* vecBytes = reinterpret_cast<uint8_t*>(vec[i].buffer);
 				uint8_t lastByte = vecBytes[vec[i].len - 1];
 				PCPP_LOG_DEBUG("1 byte left, adding value: 0x" << std::uppercase << std::hex << lastByte);
 				// We have read the latest byte manually but this byte should be properly interpreted
@@ -72,7 +72,7 @@ namespace pcpp
 
 		uint16_t checksumRes = 0;
 		ScalarBuffer<uint16_t> vec[2];
-		vec[0].buffer = (uint16_t*)dataPtr;
+		vec[0].buffer = reinterpret_cast<uint16_t*>(dataPtr);
 		vec[0].len = dataLen;
 
 		if (ipAddrType == IPAddress::IPv4AddressType)
@@ -93,8 +93,8 @@ namespace pcpp
 		else if (ipAddrType == IPAddress::IPv6AddressType)
 		{
 			uint16_t pseudoHeader[18];
-			srcIPAddress.getIPv6().copyTo((uint8_t*)pseudoHeader);
-			dstIPAddress.getIPv6().copyTo((uint8_t*)(pseudoHeader + 8));
+			srcIPAddress.getIPv6().copyTo(reinterpret_cast<uint8_t*>(pseudoHeader));
+			dstIPAddress.getIPv6().copyTo(reinterpret_cast<uint8_t*>(pseudoHeader + 8));
 			pseudoHeader[16] = 0xffff & htobe16(dataLen);
 			pseudoHeader[17] = htobe16(0x00ff & protocolType);
 			vec[1].buffer = pseudoHeader;
diff --git a/Packet++/src/SSHLayer.cpp b/Packet++/src/SSHLayer.cpp
@@ -191,7 +191,7 @@ namespace pcpp
 			if (offset + sizeof(uint32_t) >= m_DataLen)
 				return;
 
-			size_t fieldLength = static_cast<size_t>(be32toh(*(uint32_t*)(m_Data + offset)));
+			size_t fieldLength = static_cast<size_t>(be32toh(*reinterpret_cast<uint32_t*>(m_Data + offset)));
 			if (offset + sizeof(uint32_t) + fieldLength > m_DataLen)
 				return;
 
@@ -215,7 +215,7 @@ namespace pcpp
 			return "";
 
 		size_t fieldOffset = m_FieldOffsets[fieldOffsetIndex];
-		uint32_t fieldLength = be32toh(*(uint32_t*)(m_Data + fieldOffset));
+		uint32_t fieldLength = be32toh(*reinterpret_cast<uint32_t*>(m_Data + fieldOffset));
 		return std::string(reinterpret_cast<const char*>(m_Data + fieldOffset + sizeof(uint32_t)), (size_t)fieldLength);
 	}
 
diff --git a/Packet++/src/SSLHandshake.cpp b/Packet++/src/SSLHandshake.cpp
@@ -693,7 +693,7 @@ namespace pcpp
 	static uint32_t hashString(std::string str)
 	{
 		unsigned h = FIRST_HASH;
-		for (std::string::size_type i = 0; i < str.size(); ++i)
+		for (auto i = 0u; i < str.size(); ++i)
 		{
 			h = (h * A) ^ (str[i] * B);
 		}
@@ -1127,7 +1127,7 @@ namespace pcpp
 		}
 
 		uint8_t* hostNameLengthPos = extensionDataPtr + sizeof(uint16_t) + sizeof(uint8_t);
-		uint16_t hostNameLength = be16toh(*(uint16_t*)hostNameLengthPos);
+		uint16_t hostNameLength = be16toh(*reinterpret_cast<uint16_t*>(hostNameLengthPos));
 
 		char* hostNameAsCharArr = new char[hostNameLength + 1];
 		memset(hostNameAsCharArr, 0, hostNameLength + 1);
@@ -1148,7 +1148,7 @@ namespace pcpp
 		uint16_t extensionLength = getLength();
 		if (extensionLength == 2)  // server hello message
 		{
-			result.push_back(SSLVersion(be16toh(*(uint16_t*)getData())));
+			result.push_back(SSLVersion(be16toh(*reinterpret_cast<uint16_t*>(getData()))));
 		}
 		else  // client-hello message
 		{
@@ -1159,7 +1159,7 @@ namespace pcpp
 			uint8_t* dataPtr = getData() + sizeof(uint8_t);
 			for (int i = 0; i < listLength / 2; i++)
 			{
-				result.push_back(SSLVersion(be16toh(*(uint16_t*)dataPtr)));
+				result.push_back(SSLVersion(be16toh(*reinterpret_cast<uint16_t*>(dataPtr))));
 				dataPtr += sizeof(uint16_t);
 			}
 		}
diff --git a/Packet++/src/StpLayer.cpp b/Packet++/src/StpLayer.cpp
@@ -35,7 +35,7 @@ namespace pcpp
 	{
 		if (dataLen >= sizeof(stp_tcn_bpdu))
 		{
-			stp_tcn_bpdu* ptr = (stp_tcn_bpdu*)data;
+			stp_tcn_bpdu* ptr = reinterpret_cast<stp_tcn_bpdu*>(data);
 			switch (ptr->type)
 			{
 			case 0x00:
@@ -311,7 +311,7 @@ namespace pcpp
 
 	std::string MultipleStpLayer::getMstConfigurationName() const
 	{
-		std::string str = std::string((char*)(getMstpHeader()->mstConfigName), 32);
+		std::string str = std::string(reinterpret_cast<char*>(getMstpHeader()->mstConfigName), 32);
 		str.erase(std::find(str.begin(), str.end(), '\0'), str.end());
 		return str;
 	}
@@ -341,7 +341,7 @@ namespace pcpp
 	msti_conf_msg* MultipleStpLayer::getMstiConfMessages() const
 	{
 		if (getNumberOfMSTIConfMessages())
-			return (msti_conf_msg*)(m_Data + sizeof(mstp_conf_bpdu));
+			return reinterpret_cast<msti_conf_msg*>(m_Data + sizeof(mstp_conf_bpdu));
 		return nullptr;
 	}
 
diff --git a/Pcap++/header/Device.h b/Pcap++/header/Device.h
@@ -11,7 +11,7 @@
 namespace pcpp
 {
 	/// A vector of pointers to RawPacket
-	typedef PointerVector<RawPacket> RawPacketVector;
+	using RawPacketVector = PointerVector<RawPacket>;
 
 	/// @class IDevice
 	/// An abstract interface representing all packet processing devices. It stands as the root class for all devices.
diff --git a/Pcap++/header/DpdkDevice.h b/Pcap++/header/DpdkDevice.h
@@ -125,8 +125,8 @@ namespace pcpp
 	/// @param[in] device A pointer to the DpdkDevice who captured the packets
 	/// @param[in] userCookie The user cookie assigned by the user in DpdkDevice#startCaptureSingleThread() or
 	/// DpdkDevice#startCaptureMultiThreads
-	typedef void (*OnDpdkPacketsArriveCallback)(MBufRawPacket* packets, uint32_t numOfPackets, uint8_t threadId,
-	                                            DpdkDevice* device, void* userCookie);
+	using OnDpdkPacketsArriveCallback = void (*)(MBufRawPacket* packets, uint32_t numOfPackets, uint8_t threadId,
+	                                             DpdkDevice* device, void* userCookie);
 
 	/// @class DpdkDevice
 	/// Encapsulates a DPDK port and enables receiving and sending packets using DPDK as well as getting interface info
diff --git a/Pcap++/header/KniDevice.h b/Pcap++/header/KniDevice.h
@@ -86,8 +86,8 @@ namespace pcpp
 	class KniDeviceList;
 
 	/// Defines the signature callback used by capturing API on KNI device
-	typedef bool (*OnKniPacketArriveCallback)(MBufRawPacket* packets, uint32_t numOfPackets, KniDevice* device,
-	                                          void* userCookie);
+	using OnKniPacketArriveCallback = bool (*)(MBufRawPacket* packets, uint32_t numOfPackets, KniDevice* device,
+	                                           void* userCookie);
 
 	/// @class KniDevice
 	/// This class represents special kind of DPDK devices called KNI - Kernel Network Interface
diff --git a/Pcap++/header/MBufRawPacket.h b/Pcap++/header/MBufRawPacket.h
@@ -211,7 +211,7 @@ namespace pcpp
 
 	/// @typedef MBufRawPacketVector
 	/// A vector of pointers to MBufRawPacket
-	typedef PointerVector<MBufRawPacket> MBufRawPacketVector;
+	using MBufRawPacketVector = PointerVector<MBufRawPacket>;
 
 }  // namespace pcpp
 
diff --git a/Tests/Fuzzers/DumpToFile.h b/Tests/Fuzzers/DumpToFile.h
@@ -10,7 +10,7 @@ static int dumpDataToPcapFile(const uint8_t* data, size_t size, const char* path
 	int written = 0;
 
 	fd = fopen(path, "wb");
-	if (fd == NULL)
+	if (fd == nullptr)
 	{
 		std::cerr << "Error opening pcap file for writing\n";
 		return -1;
diff --git a/Tests/Packet++Test/Utils/TestUtils.cpp b/Tests/Packet++Test/Utils/TestUtils.cpp
@@ -128,7 +128,7 @@ namespace pcpp_tests
 		pcap_dumper_t* d;
 		/* open output file */
 		d = pcap_dump_open(pcap, fileName.c_str());
-		if (d == NULL)
+		if (d == nullptr)
 		{
 			pcap_perror(pcap, "pcap_dump_fopen");
 			return;
diff --git a/Tests/Pcap++Test/Common/TestUtils.h b/Tests/Pcap++Test/Common/TestUtils.h
@@ -20,7 +20,7 @@ class DeviceTeardown
 
 	~DeviceTeardown()
 	{
-		if (!m_CancelTeardown && m_Device != NULL && m_Device->isOpened())
+		if (!m_CancelTeardown && m_Device != nullptr && m_Device->isOpened())
 		{
 			m_Device->close();
 		}
diff --git a/Tests/Pcap++Test/Tests/DpdkTests.cpp b/Tests/Pcap++Test/Tests/DpdkTests.cpp
diff --git a/Tests/Pcap++Test/Tests/KniTests.cpp b/Tests/Pcap++Test/Tests/KniTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -196,8 +196,8 @@ namespace pcpp`
`196`	`196`
`197`	`197`	`DnsType IDnsResource::getDnsType() const`
`198`	`198`	`{`
`199`		`- uint16_t dnsType = (uint16_t)(getRawData() + m_NameLength);`
`200`		`- return (DnsType)be16toh(dnsType);`
	`199`	`+ uint16_t dnsType = reinterpret_cast<uint16_t>(getRawData() + m_NameLength);`
	`200`	`+ return static_cast<DnsType>(be16toh(dnsType));`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`void IDnsResource::setDnsType(DnsType newType)`
`@@ -208,8 +208,8 @@ namespace pcpp`
`208`	`208`
`209`	`209`	`DnsClass IDnsResource::getDnsClass() const`
`210`	`210`	`{`
`211`		`- uint16_t dnsClass = (uint16_t)(getRawData() + m_NameLength + sizeof(uint16_t));`
`212`		`- return (DnsClass)be16toh(dnsClass);`
	`211`	`+ uint16_t dnsClass = reinterpret_cast<uint16_t>(getRawData() + m_NameLength + sizeof(uint16_t));`
	`212`	`+ return static_cast<DnsClass>(be16toh(dnsClass));`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`void IDnsResource::setDnsClass(DnsClass newClass)`
`@@ -268,7 +268,7 @@ namespace pcpp`
`268`	`268`
`269`	`269`	`uint32_t DnsResource::getTTL() const`
`270`	`270`	`{`
`271`		`- uint32_t ttl = (uint32_t)(getRawData() + m_NameLength + 2 * sizeof(uint16_t));`
	`271`	`+ uint32_t ttl = reinterpret_cast<uint32_t>(getRawData() + m_NameLength + 2 * sizeof(uint16_t));`
`272`	`272`	`return be32toh(ttl);`
`273`	`273`	`}`
`274`	`274`
`@@ -290,7 +290,7 @@ namespace pcpp`
`290`	`290`	`return 0;`
`291`	`291`	`}`
`292`	`292`
`293`		`- uint16_t dataLength = (uint16_t)(getRawData() + sizeToRead);`
	`293`	`+ uint16_t dataLength = reinterpret_cast<uint16_t>(getRawData() + sizeToRead);`
`294`	`294`	`return be16toh(dataLength);`
`295`	`295`	`}`
`296`	`296`
`@@ -444,7 +444,7 @@ namespace pcpp`
`444`	`444`
`445`	`445`	`uint16_t DnsResource::getCustomDnsClass() const`
`446`	`446`	`{`
`447`		`- uint16_t value = (uint16_t)(getRawData() + m_NameLength + sizeof(uint16_t));`
	`447`	`+ uint16_t value = reinterpret_cast<uint16_t>(getRawData() + m_NameLength + sizeof(uint16_t));`
`448`	`448`	`return be16toh(value);`
`449`	`449`	`}`
`450`	`450`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ namespace pcpp`
`88`	`88`	`uint16_t IgmpLayer::calculateChecksum()`
`89`	`89`	`{`
`90`	`90`	`ScalarBuffer<uint16_t> buffer;`
`91`		`- buffer.buffer = (uint16_t*)getIgmpHeader();`
	`91`	`+ buffer.buffer = reinterpret_cast<uint16_t*>(getIgmpHeader());`
`92`	`92`	`buffer.len = getHeaderLen();`
`93`	`93`	`return computeChecksum(&buffer, 1);`
`94`	`94`	`}`
`@@ -224,7 +224,7 @@ namespace pcpp`
`224`	`224`	`return IPv4Address();`
`225`	`225`
`226`	`226`	`uint8_t* ptr = m_Data + ptrOffset;`
`227`		`- return IPv4Address((uint32_t)ptr);`
	`227`	`+ return IPv4Address(reinterpret_cast<uint32_t>(ptr));`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`size_t IgmpV3QueryLayer::getHeaderLen() const`
`@@ -256,7 +256,7 @@ namespace pcpp`
`256`	`256`	`{`
`257`	`257`	`uint16_t sourceAddrCount = getSourceAddressCount();`
`258`	`258`
`259`		`- if (index < 0 \|\| index > (int)sourceAddrCount)`
	`259`	`+ if (index < 0 \|\| index > static_cast<int>(sourceAddrCount))`
`260`	`260`	`{`
`261`	`261`	`PCPP_LOG_ERROR("Cannot add source address at index " << index << ", index is out of bounds");`
`262`	`262`	`return false;`
`@@ -286,7 +286,7 @@ namespace pcpp`
`286`	`286`	`{`
`287`	`287`	`uint16_t sourceAddrCount = getSourceAddressCount();`
`288`	`288`
`289`		`- if (index < 0 \|\| index > (int)sourceAddrCount - 1)`
	`289`	`+ if (index < 0 \|\| index > static_cast<int>(sourceAddrCount) - 1)`
`290`	`290`	`{`
`291`	`291`	`PCPP_LOG_ERROR("Cannot remove source address at index " << index << ", index is out of bounds");`
`292`	`292`	`return false;`
`@@ -348,11 +348,13 @@ namespace pcpp`
`348`	`348`	`if (groupRecord == nullptr)`
`349`	`349`	`return nullptr;`
`350`	`350`
`351`		`- // prev group was the last group`
`352`		`- if ((uint8_t*)groupRecord + groupRecord->getRecordLen() - m_Data >= (int)getHeaderLen())`
	`351`	`+ uint8_t* nextGroupRecordBegin = reinterpret_cast<uint8_t*>(groupRecord) + groupRecord->getRecordLen();`
	`352`	`+ if (std::distance(m_Data, nextGroupRecordBegin) >= static_cast<std::ptrdiff_t>(getHeaderLen()))`
	`353`	`+ {`
`353`	`354`	`return nullptr;`
	`355`	`+ }`
`354`	`356`
`355`		`- igmpv3_group_record* nextGroup = (igmpv3_group_record)((uint8_t)groupRecord + groupRecord->getRecordLen());`
	`357`	`+ igmpv3_group_record* nextGroup = reinterpret_cast<igmpv3_group_record*>(nextGroupRecordBegin);`
`356`	`358`
`357`	`359`	`return nextGroup;`
`358`	`360`	`}`
`@@ -368,7 +370,7 @@ namespace pcpp`
`368`	`370`	`const std::vector<IPv4Address>& sourceAddresses,`
`369`	`371`	`int offset)`
`370`	`372`	`{`
`371`		`- if (offset > (int)getHeaderLen())`
	`373`	`+ if (offset > static_cast<int>(getHeaderLen()))`
`372`	`374`	`{`
`373`	`375`	`PCPP_LOG_ERROR("Cannot add group record, offset is out of layer bounds");`
`374`	`376`	`return nullptr;`
`@@ -403,13 +405,13 @@ namespace pcpp`
`403`	`405`
`404`	`406`	`getReportHeader()->numOfGroupRecords = htobe16(getGroupRecordCount() + 1);`
`405`	`407`
`406`		`- return (igmpv3_group_record*)(m_Data + offset);`
	`408`	`+ return reinterpret_cast<igmpv3_group_record*>(m_Data + offset);`
`407`	`409`	`}`
`408`	`410`
`409`	`411`	`igmpv3_group_record* IgmpV3ReportLayer::addGroupRecord(uint8_t recordType, const IPv4Address& multicastAddress,`
`410`	`412`	`const std::vector<IPv4Address>& sourceAddresses)`
`411`	`413`	`{`
`412`		`- return addGroupRecordAt(recordType, multicastAddress, sourceAddresses, (int)getHeaderLen());`
	`414`	`+ return addGroupRecordAt(recordType, multicastAddress, sourceAddresses, static_cast<int>(getHeaderLen()));`
`413`	`415`	`}`
`414`	`416`
`415`	`417`	`igmpv3_group_record* IgmpV3ReportLayer::addGroupRecordAtIndex(uint8_t recordType,`
`@@ -509,7 +511,7 @@ namespace pcpp`
`509`	`511`
`510`	`512`	`int offset = index * sizeof(uint32_t);`
`511`	`513`	`const uint8_t* ptr = sourceAddresses + offset;`
`512`		`- return IPv4Address((uint32_t)ptr);`
	`514`	`+ return IPv4Address(reinterpret_cast<const uint32_t>(ptr));`
`513`	`515`	`}`
`514`	`516`
`515`	`517`	`size_t igmpv3_group_record::getRecordLen() const`
Original file line number	Diff line number	Diff line change
`@@ -693,7 +693,7 @@ namespace pcpp`
`693`	`693`	`static uint32_t hashString(std::string str)`
`694`	`694`	`{`
`695`	`695`	`unsigned h = FIRST_HASH;`
`696`		`- for (std::string::size_type i = 0; i < str.size(); ++i)`
	`696`	`+ for (auto i = 0u; i < str.size(); ++i)`
`697`	`697`	`{`
`698`	`698`	`h = (h * A) ^ (str[i] * B);`
`699`	`699`	`}`
`@@ -1127,7 +1127,7 @@ namespace pcpp`
`1127`	`1127`	`}`
`1128`	`1128`
`1129`	`1129`	`uint8_t* hostNameLengthPos = extensionDataPtr + sizeof(uint16_t) + sizeof(uint8_t);`
`1130`		`- uint16_t hostNameLength = be16toh((uint16_t)hostNameLengthPos);`
	`1130`	`+ uint16_t hostNameLength = be16toh(reinterpret_cast<uint16_t>(hostNameLengthPos));`
`1131`	`1131`
`1132`	`1132`	`char* hostNameAsCharArr = new char[hostNameLength + 1];`
`1133`	`1133`	`memset(hostNameAsCharArr, 0, hostNameLength + 1);`
`@@ -1148,7 +1148,7 @@ namespace pcpp`
`1148`	`1148`	`uint16_t extensionLength = getLength();`
`1149`	`1149`	`if (extensionLength == 2) // server hello message`
`1150`	`1150`	`{`
`1151`		`- result.push_back(SSLVersion(be16toh((uint16_t)getData())));`
	`1151`	`+ result.push_back(SSLVersion(be16toh(reinterpret_cast<uint16_t>(getData()))));`
`1152`	`1152`	`}`
`1153`	`1153`	`else // client-hello message`
`1154`	`1154`	`{`
`@@ -1159,7 +1159,7 @@ namespace pcpp`
`1159`	`1159`	`uint8_t* dataPtr = getData() + sizeof(uint8_t);`
`1160`	`1160`	`for (int i = 0; i < listLength / 2; i++)`
`1161`	`1161`	`{`
`1162`		`- result.push_back(SSLVersion(be16toh((uint16_t)dataPtr)));`
	`1162`	`+ result.push_back(SSLVersion(be16toh(reinterpret_cast<uint16_t>(dataPtr))));`
`1163`	`1163`	`dataPtr += sizeof(uint16_t);`
`1164`	`1164`	`}`
`1165`	`1165`	`}`