[WIP] General refactor of RawPacket to remove ambiguity in API and streamline logic.

Common++/header/Logger.h

@@ -27,8 +27,9 @@
 // Allows for conditional removal of unwanted log calls at compile time.
 #define PCPP_LOG_LEVEL_OFF 0
 #define PCPP_LOG_LEVEL_ERROR 1
-#define PCPP_LOG_LEVEL_INFO 2
-#define PCPP_LOG_LEVEL_DEBUG 3
+#define PCPP_LOG_LEVEL_WARN 2
+#define PCPP_LOG_LEVEL_INFO 3
+#define PCPP_LOG_LEVEL_DEBUG 4
 
 // All log messages built via a PCPP_LOG_* macro below the PCPP_ACTIVE_LOG_LEVEL will be removed at compile time.
 // Uses the PCPP_ACTIVE_LOG_LEVEL if it is defined, otherwise defaults to PCAP_LOG_LEVEL_DEBUG
@@ -146,6 +147,7 @@ namespace pcpp
 	{
 		Off = PCPP_LOG_LEVEL_OFF,      ///< No log messages are emitted.
 		Error = PCPP_LOG_LEVEL_ERROR,  ///< Error level logs are emitted.
+		Warn = PCPP_LOG_LEVEL_WARN,    ///< Warning level logs and above are emitted.
 		Info = PCPP_LOG_LEVEL_INFO,    ///< Info level logs and above are emitted.
 		Debug = PCPP_LOG_LEVEL_DEBUG   ///< Debug level logs and above are emitted.
 	};
@@ -436,6 +438,12 @@ namespace pcpp
 #	define PCPP_LOG_INFO(message) (void)0
 #endif
 
+#if PCPP_ACTIVE_LOG_LEVEL >= PCPP_LOG_LEVEL_WARN
+#	define PCPP_LOG_WARN(message) PCPP_LOG(pcpp::LogLevel::Warn, message)
+#else
+#	define PCPP_LOG_WARN(message) (void)0
+#endif
+
 #if PCPP_ACTIVE_LOG_LEVEL >= PCPP_LOG_LEVEL_ERROR
 #	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
 #else

Packet++/header/IPReassembly.h

@@ -399,7 +399,7 @@ namespace pcpp
 		/// - If the input fragment is the last one and the reassembled packet is ready - a pointer to the reassembled
 		///   packet is returned. Notice it's the user's responsibility to free this pointer when done using it
 		/// - If the reassembled packet isn't ready then nullptr is returned
-		Packet* processPacket(RawPacket* fragment, ReassemblyStatus& status, ProtocolType parseUntil = UnknownProtocol,
+		Packet* processPacket(IRawPacket* fragment, ReassemblyStatus& status, ProtocolType parseUntil = UnknownProtocol,
 		                      OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
 		/// Get a partially reassembled packet. This method returns all the reassembled data that was gathered so far

Packet++/header/Packet.h

@@ -23,7 +23,7 @@ namespace pcpp
 		friend class Layer;
 
 	private:
-		RawPacket* m_RawPacket;
+		IRawPacket* m_RawPacket;
 		Layer* m_FirstLayer;
 		Layer* m_LastLayer;
 		size_t m_MaxPacketLen;
@@ -65,7 +65,7 @@ namespace pcpp
 		/// model (inclusive). Can be useful for cases when you need to parse only up to a certain OSI layer (for
 		/// example transport layer) and want to avoid the performance impact and memory consumption of parsing the
 		/// whole packet. Default value is ::OsiModelLayerUnknown which means don't take this parameter into account
-		explicit Packet(RawPacket* rawPacket, bool freeRawPacket = false, ProtocolType parseUntil = UnknownProtocol,
+		explicit Packet(IRawPacket* rawPacket, bool freeRawPacket = false, ProtocolType parseUntil = UnknownProtocol,
 		                OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
 		/// A constructor for creating a packet out of already allocated RawPacket. Very useful when parsing packets
@@ -77,7 +77,7 @@ namespace pcpp
 		/// @param[in] parseUntil Parse the packet until you reach a certain protocol (inclusive). Can be useful for
 		/// cases when you need to parse only up to a certain layer and want to avoid the performance impact and memory
 		/// consumption of parsing the whole packet
-		explicit Packet(RawPacket* rawPacket, ProtocolType parseUntil);
+		explicit Packet(IRawPacket* rawPacket, ProtocolType parseUntil);
 
 		/// A constructor for creating a packet out of already allocated RawPacket. Very useful when parsing packets
 		/// that came from the network. When using this constructor a pointer to the RawPacket is saved (data isn't
@@ -88,7 +88,7 @@ namespace pcpp
 		/// @param[in] parseUntilFamily Parse the packet until you reach a certain protocol family (inclusive). Can be
 		/// useful for cases when you need to parse only up to a certain layer and want to avoid the performance impact
 		/// and memory consumption of parsing the whole packet
-		explicit Packet(RawPacket* rawPacket, ProtocolTypeFamily parseUntilFamily);
+		explicit Packet(IRawPacket* rawPacket, ProtocolTypeFamily parseUntilFamily);
 
 		/// A constructor for creating a packet out of already allocated RawPacket. Very useful when parsing packets
 		/// that came from the network. When using this constructor a pointer to the RawPacket is saved (data isn't
@@ -101,7 +101,7 @@ namespace pcpp
 		/// model (inclusive). Can be useful for cases when you need to parse only up to a certain OSI layer (for
 		/// example transport layer) and want to avoid the performance impact and memory consumption of parsing the
 		/// whole packet
-		explicit Packet(RawPacket* rawPacket, OsiModelLayer parseUntilLayer);
+		explicit Packet(IRawPacket* rawPacket, OsiModelLayer parseUntilLayer);
 
 		/// A destructor for this class. Frees all layers allocated by this instance (Notice: it doesn't free layers
 		/// that weren't allocated by this class, for example layers that were added by addLayer() or insertLayer() ).
@@ -130,7 +130,7 @@ namespace pcpp
 
 		/// Get a pointer to the Packet's RawPacket
 		/// @return A pointer to the Packet's RawPacket
-		RawPacket* getRawPacket() const
+		IRawPacket* getRawPacket() const
 		{
 			return m_RawPacket;
 		}
@@ -147,12 +147,12 @@ namespace pcpp
 		/// you need to parse only up to a certain layer and want to avoid the performance impact and memory consumption
 		/// of parsing the whole packet. Default value is ::OsiModelLayerUnknown which means don't take this parameter
 		/// into account
-		void setRawPacket(RawPacket* rawPacket, bool freeRawPacket, ProtocolTypeFamily parseUntil = UnknownProtocol,
+		void setRawPacket(IRawPacket* rawPacket, bool freeRawPacket, ProtocolTypeFamily parseUntil = UnknownProtocol,
 		                  OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
 		/// Get a pointer to the Packet's RawPacket in a read-only manner
 		/// @return A pointer to the Packet's RawPacket
-		const RawPacket* getRawPacketReadOnly() const
+		const IRawPacket* getRawPacketReadOnly() const
 		{
 			return m_RawPacket;
 		}