Extracted MTU check code into its own helper functions. (#1834)

* Extracted MTU check code into its own helper functions.

* Fixed inverted if condition.

* Replaced call to sendPacket with sendPacketUnchecked.

* Apply suggestions from code review

Fixed comments

* Lint

* Renamed checkMtu functions to isPayloadWithinMtu.
- Moved checkMtu family of functions to public access.

* Deprecated doMtuCheck.

* Added guard against negative data length.

* Lint

* Added comments explaining why unknown length is allowed.

* Expanded documentation on the ckeck's return value if the length is unknown.

* Improved documentation for value of outPayloadLength on unknown length.

* Improved documentation.

* Lint

* Moved new functions to protected.

Author: Dimi1010

Pcap++/header/PcapLiveDevice.h

@@ -672,8 +672,65 @@ namespace pcpp
 
 		internal::PcapHandle doOpen(const DeviceConfiguration& config);
 
+		/// @brief Checks whether the packetPayloadLength is smaller or equal than the device MTU.
+		/// @param[in] payloadLength The length of the IP layer of the packet
+		/// @return True if the payloadLength is less than or equal to the device MTU
+		bool isPayloadWithinMtu(size_t payloadLength) const;
+
+		/// @brief Checks whether the packet's payload length is smaller or equal than the device MTU.
+		///
+		/// If the payload length cannot be determined, the function will return the value of allowUnknownLength.
+		/// In such cases, if outPayloadLength is not nullptr, it will be set to the maximum value of size_t (i.e.,
+		/// std::numeric_limits<size_t>::max()), indicating that the payload length could not be determined.
+		///
+		/// @param[in] packet The packet to check
+		/// @param[in] allowUnknownLength Controls whether packets with unknown payload length are allowed.
+		/// @param[out] outPayloadLength If not nullptr, the payload length of the packet will be written to this
+		/// pointer.
+		/// @return True if the packet's payload length is less than or equal to the device MTU.
+		/// If the packet's length cannot be determined, it will return true if allowUnknownLength is true.
+		bool isPayloadWithinMtu(Packet const& packet, bool allowUnknownLength = false,
+		                        size_t* outPayloadLength = nullptr) const;
+
+		/// @brief Checks whether the payload length of a RawPacket is smaller or equal than the device MTU.
+		///
+		/// If the payload length cannot be determined, the function will return the value of allowUnknownLength.
+		/// In such cases, if outPayloadLength is not nullptr, it will be set to the maximum value of size_t (i.e.,
+		/// std::numeric_limits<size_t>::max()), indicating that the payload length could not be determined.
+		///
+		/// @param[in] rawPacket The RawPacket to check.
+		/// @param[in] allowUnknownLength Controls whether packets with unknown payload length are allowed.
+		/// @param[out] outPayloadLength If not nullptr, the payload length of the packet will be written to this
+		/// pointer.
+		/// @return True if the packet's payload length is less than or equal to the device MTU.
+		/// If the packet's length cannot be determined, it will return true if allowUnknownLength is true.
+		bool isPayloadWithinMtu(RawPacket const& rawPacket, bool allowUnknownLength = false,
+		                        size_t* outPayloadLength = nullptr) const;
+
+		/// @brief Checks whether the payload length of a packet's raw data is smaller or equal than the device MTU.
+		///
+		/// If the payload length cannot be determined, the function will return the value of allowUnknownLength.
+		/// In such cases, if outPayloadLength is not nullptr, it will be set to the maximum value of size_t (i.e.,
+		/// std::numeric_limits<size_t>::max()), indicating that the payload length could not be determined.
+		///
+		/// @param[in] packetData A pointer to the raw data of the packet.
+		/// @param[in] packetLen The length of the raw data in bytes.
+		/// @param[in] linkType The link layer type of the packet. Default is pcpp::LINKTYPE_ETHERNET.
+		/// @param[in] allowUnknownLength Controls whether packets with unknown payload length are allowed.
+		/// @param[out] outPayloadLength If not nullptr, the payload length of the packet will be written to this
+		/// pointer.
+		/// @return True if the packet's payload length is less than or equal to the device MTU.
+		/// If the packet's length cannot be determined, it will return true if allowUnknownLength is true.
+		bool isPayloadWithinMtu(uint8_t const* packetData, size_t packetLen,
+		                        LinkLayerType linkType = pcpp::LINKTYPE_ETHERNET, bool allowUnknownLength = false,
+		                        size_t* outPayloadLength = nullptr) const;
+
 		// Sends a packet directly to the network.
-		bool sendPacketDirect(uint8_t const* packetData, int packetDataLength);
+		bool sendPacketUnchecked(uint8_t const* packetData, int packetDataLength);
+		bool sendPacketUnchecked(RawPacket const& rawPacket)
+		{
+			return sendPacketUnchecked(rawPacket.getRawData(), rawPacket.getRawDataLen());
+		}
 
 	private:
 		bool isNflogDevice() const;

Pcap++/src/PcapLiveDevice.cpp

@@ -916,7 +916,13 @@ namespace pcpp
 
 	bool PcapLiveDevice::doMtuCheck(int packetPayloadLength) const
 	{
-		if (packetPayloadLength > static_cast<int>(m_DeviceMtu))
+		if (packetPayloadLength < 0)
+		{
+			PCPP_LOG_ERROR("Payload length [" << packetPayloadLength << "] is negative");
+			return false;
+		}
+
+		if (!isPayloadWithinMtu(packetPayloadLength))
 		{
 			PCPP_LOG_ERROR("Payload length [" << packetPayloadLength << "] is larger than device MTU [" << m_DeviceMtu
 			                                  << "]");
@@ -925,64 +931,144 @@ namespace pcpp
 		return true;
 	}
 
-	bool PcapLiveDevice::sendPacket(Packet const& packet, bool checkMtu)
+	bool PcapLiveDevice::isPayloadWithinMtu(size_t packetPayloadLength) const
 	{
-		RawPacket const* rawPacket = packet.getRawPacketReadOnly();
-
-		if (!checkMtu)
-		{
-			return sendPacket(*rawPacket, false);
-		}
+		return packetPayloadLength <= static_cast<size_t>(m_DeviceMtu);
+	}
 
-		int packetPayloadLength = 0;
+	bool PcapLiveDevice::isPayloadWithinMtu(Packet const& packet, bool allowUnknownLength,
+	                                        size_t* outPayloadLength) const
+	{
+		size_t packetPayloadLength = 0;
 		switch (packet.getFirstLayer()->getOsiModelLayer())
 		{
-		case (pcpp::OsiModelDataLinkLayer):
-			packetPayloadLength = static_cast<int>(packet.getFirstLayer()->getLayerPayloadSize());
+		case pcpp::OsiModelDataLinkLayer:
+			packetPayloadLength = packet.getFirstLayer()->getLayerPayloadSize();
 			break;
-		case (pcpp::OsiModelNetworkLayer):
-			packetPayloadLength = static_cast<int>(packet.getFirstLayer()->getDataLen());
+		case pcpp::OsiModelNetworkLayer:
+			packetPayloadLength = packet.getFirstLayer()->getDataLen();
 			break;
 		default:
-			// if packet layer is not known, do not perform MTU check.
-			return sendPacket(*rawPacket, false);
+		{
+			// If the packet length is unknown, the MTU check is skipped.
+			// In such cases the output payload length is set to the maximum size and the return value is the
+			// allowUnknownLength value.
+			if (outPayloadLength != nullptr)
+			{
+				*outPayloadLength = (std::numeric_limits<size_t>::max)();
+			}
+			return allowUnknownLength;
+		}
+		}
+
+		if (outPayloadLength != nullptr)
+		{
+			*outPayloadLength = packetPayloadLength;
+		}
+		return isPayloadWithinMtu(packetPayloadLength);
+	}
+
+	bool PcapLiveDevice::isPayloadWithinMtu(RawPacket const& rawPacket, bool allowUnknownLength,
+	                                        size_t* outPayloadLength) const
+	{
+		// Const cast because Packet requires a non-const RawPacket pointer
+		// and we don't modify the RawPacket in this function.
+		return isPayloadWithinMtu(Packet(const_cast<RawPacket*>(&rawPacket), OsiModelDataLinkLayer), allowUnknownLength,
+		                          outPayloadLength);
+	}
+
+	bool PcapLiveDevice::isPayloadWithinMtu(uint8_t const* packetData, size_t packetLen, LinkLayerType linkType,
+	                                        bool allowUnknown, size_t* outPayloadLength) const
+	{
+		timeval time;
+		gettimeofday(&time, nullptr);
+		return isPayloadWithinMtu(RawPacket(packetData, packetLen, time, false, linkType), allowUnknown,
+		                          outPayloadLength);
+	}
+
+	bool PcapLiveDevice::sendPacket(Packet const& packet, bool checkMtu)
+	{
+		if (checkMtu)
+		{
+			size_t packetPayloadLength = 0;
+			// Unknown length is allowed due to legacy behavior of this function
+			if (!isPayloadWithinMtu(packet, true, &packetPayloadLength))
+			{
+				PCPP_LOG_ERROR("Packet payload length [" << packetPayloadLength << "] is larger than device MTU ["
+				                                         << m_DeviceMtu << "]");
+				return false;
+			}
 		}
-		return doMtuCheck(packetPayloadLength) && sendPacket(*rawPacket, false);
+
+		return sendPacketUnchecked(*packet.getRawPacketReadOnly());
 	}
 
 	bool PcapLiveDevice::sendPacket(RawPacket const& rawPacket, bool checkMtu)
 	{
-		if (!checkMtu)
+		if (checkMtu)
 		{
-			return sendPacketDirect(rawPacket.getRawData(), rawPacket.getRawDataLen());
+			size_t packetPayloadLength = 0;
+			// Unknown length is allowed due to legacy behavior of this function
+			if (!isPayloadWithinMtu(rawPacket, true, &packetPayloadLength))
+			{
+				PCPP_LOG_ERROR("Packet payload length [" << packetPayloadLength << "] is larger than device MTU ["
+				                                         << m_DeviceMtu << "]");
+				return false;
+			}
 		}
 
-		RawPacket* rPacket = const_cast<RawPacket*>(&rawPacket);
-		Packet parsedPacket = Packet(rPacket, OsiModelDataLinkLayer);
-		return sendPacket(parsedPacket, true);
+		return sendPacketUnchecked(rawPacket);
 	}
 
 	bool PcapLiveDevice::sendPacket(const uint8_t* packetData, int packetDataLength, int packetPayloadLength)
 	{
-		return doMtuCheck(packetPayloadLength) && sendPacketDirect(packetData, packetDataLength);
+		if (packetDataLength < 0)
+		{
+			PCPP_LOG_ERROR("Packet data length is negative: " << packetDataLength);
+			return false;
+		}
+
+		if (packetPayloadLength < 0)
+		{
+			PCPP_LOG_ERROR("Payload length is negative: " << packetPayloadLength);
+			return false;
+		}
+
+		if (!isPayloadWithinMtu(packetPayloadLength))
+		{
+			PCPP_LOG_ERROR("Packet payload length [" << packetPayloadLength << "] is larger than device MTU ["
+			                                         << m_DeviceMtu << "]");
+			return false;
+		}
+
+		return sendPacketUnchecked(packetData, packetDataLength);
 	}
 
 	bool PcapLiveDevice::sendPacket(const uint8_t* packetData, int packetDataLength, bool checkMtu,
 	                                pcpp::LinkLayerType linkType)
 	{
-		if (!checkMtu)
+		if (packetDataLength < 0)
+		{
+			PCPP_LOG_ERROR("Packet data length is negative: " << packetDataLength);
+			return false;
+		}
+
+		if (checkMtu)
 		{
-			return sendPacketDirect(packetData, packetDataLength);
+			size_t packetPayloadLength = 0;
+			// Unknown length is allowed due to legacy behavior of this function
+			if (!isPayloadWithinMtu(packetData, packetDataLength, linkType, true, &packetPayloadLength))
+			{
+				PCPP_LOG_ERROR("Packet payload length [" << packetPayloadLength << "] is larger than device MTU ["
+				                                         << m_DeviceMtu << "]");
+				return false;
+			}
 		}
 
-		timeval time;
-		gettimeofday(&time, nullptr);
-		pcpp::RawPacket rawPacket(packetData, packetDataLength, time, false, linkType);
-		Packet parsedPacket = Packet(&rawPacket, pcpp::OsiModelDataLinkLayer);
-		return sendPacket(parsedPacket, true);
+		return sendPacketUnchecked(packetData, packetDataLength);
 	}
 
-	bool PcapLiveDevice::sendPacketDirect(uint8_t const* packetData, int packetDataLength)
+	bool PcapLiveDevice::sendPacketUnchecked(uint8_t const* packetData, int packetDataLength)
 	{
 		if (!m_DeviceOpened)
 		{