Add serialization for: EthDot3, VLAN, VXLAN, LLC, SLL, SLL2, MPLS, Null/loopback, TPKT, WOL

Packet++/header/EthDot3Layer.h

@@ -118,6 +118,30 @@ namespace pcpp
 		/// @param[in] dataLen The length of the byte stream
 		/// @return True if the data is valid and can represent an IEEE 802.3 Eth packet
 		static bool isDataValid(const uint8_t* data, size_t dataLen);
+
+		/// @struct SerializedFields
+		/// Fields written by EthDot3Layer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for EthDot3Layer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ SrcMacAddress, DstMacAddress };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief Source MAC address, as a string
+			static const FieldDescriptor SrcMacAddress;
+
+			/// @brief Destination MAC address, as a string
+			static const FieldDescriptor DstMacAddress;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 
 }  // namespace pcpp

Packet++/header/LLCLayer.h

@@ -79,6 +79,33 @@ namespace pcpp
 		/// @param[in] dataLen The length of the byte stream
 		/// @return True if the data is valid and can represent an LLC packet
 		static bool isDataValid(const uint8_t* data, size_t dataLen);
+
+		/// @struct SerializedFields
+		/// Fields written by LLCLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for LLCLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ DSAP, SSAP, Control };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief Destination Service Access Point
+			static const FieldDescriptor DSAP;
+
+			/// @brief Source Service Access Point
+			static const FieldDescriptor SSAP;
+
+			/// @brief First byte of the LLC control field
+			static const FieldDescriptor Control;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 
 }  // namespace pcpp

Packet++/header/MplsLayer.h

@@ -115,6 +115,36 @@ namespace pcpp
 		{
 			return canReinterpretAs<mpls_header>(data, dataLen);
 		}
+
+		/// @struct SerializedFields
+		/// Fields written by MplsLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for MplsLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ Label, TTL, IsBottomOfStack, ExperimentalUseValue };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief MPLS label
+			static const FieldDescriptor Label;
+
+			/// @brief Time to live
+			static const FieldDescriptor TTL;
+
+			/// @brief True if this is the last label in the stack (S bit)
+			static const FieldDescriptor IsBottomOfStack;
+
+			/// @brief Experimental use / traffic class bits
+			static const FieldDescriptor ExperimentalUseValue;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 
 }  // namespace pcpp

Packet++/header/NullLoopbackLayer.h

@@ -87,5 +87,26 @@ namespace pcpp
 		{
 			return data != nullptr && dataLen >= sizeof(uint32_t);
 		}
+
+		/// @struct SerializedFields
+		/// Fields written by NullLoopbackLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for NullLoopbackLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ Family };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief Protocol family (AF_* value) of the payload
+			static const FieldDescriptor Family;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 }  // namespace pcpp

Packet++/header/Sll2Layer.h

@@ -147,6 +147,39 @@ namespace pcpp
 		{
 			return OsiModelDataLinkLayer;
 		}
-	};
 
+		/// @struct SerializedFields
+		/// Fields written by Sll2Layer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for Sll2Layer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ ProtocolType, InterfaceIndex, ArpHeaderType, PacketType,
+					                                          LinkLayerAddress };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief EtherType of the encapsulated protocol, in host byte order
+			static const FieldDescriptor ProtocolType;
+
+			/// @brief Index of the capture interface
+			static const FieldDescriptor InterfaceIndex;
+
+			/// @brief ARPHRD_* link-layer address type (e.g. 1 for Ethernet)
+			static const FieldDescriptor ArpHeaderType;
+
+			/// @brief Packet type
+			static const FieldDescriptor PacketType;
+
+			/// @brief Link-layer address of the sender
+			static const FieldDescriptor LinkLayerAddress;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
+	};
 }  // namespace pcpp

Packet++/header/SllLayer.h

@@ -88,6 +88,37 @@ namespace pcpp
 		{
 			return OsiModelDataLinkLayer;
 		}
+
+		/// @struct SerializedFields
+		/// Fields written by SllLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for SllLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ PacketType, ArpHeaderType, ProtocolType,
+					                                          LinkLayerAddress };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief Packet type
+			static const FieldDescriptor PacketType;
+
+			/// @brief ARPHRD_* link-layer address type (e.g. 1 for Ethernet)
+			static const FieldDescriptor ArpHeaderType;
+
+			/// @brief EtherType of the encapsulated protocol, in host byte order
+			static const FieldDescriptor ProtocolType;
+
+			/// @brief Link-layer address of the sender
+			static const FieldDescriptor LinkLayerAddress;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 
 }  // namespace pcpp

Packet++/header/TpktLayer.h

@@ -100,6 +100,27 @@ namespace pcpp
 			return OsiModelTransportLayer;
 		}
 
+		/// @struct SerializedFields
+		/// Fields written by TpktLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for TpktLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ Version };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief TPKT version
+			static const FieldDescriptor Version;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
+
 	private:
 		/// Get a pointer to the TPKT header. Data can be retrieved through the
 		/// other methods of this layer. Notice the return value points directly to the data, so every change will

Packet++/header/VlanLayer.h

@@ -120,5 +120,35 @@ namespace pcpp
 		{
 			return canReinterpretAs<vlan_header>(data, dataLen);
 		}
+
+		/// @struct SerializedFields
+		/// Fields written by VlanLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for VlanLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ VlanID, CFI, Priority, EtherType };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief VLAN identifier (12 bits)
+			static const FieldDescriptor VlanID;
+
+			/// @brief Canonical Format Indicator / Drop Eligible Indicator bit
+			static const FieldDescriptor CFI;
+
+			/// @brief Priority Code Point
+			static const FieldDescriptor Priority;
+
+			/// @brief EtherType, in host byte order (e.g. 2048 for IPv4)
+			static const FieldDescriptor EtherType;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 }  // namespace pcpp

Packet++/header/VxlanLayer.h

@@ -142,5 +142,32 @@ namespace pcpp
 		{
 			return OsiModelDataLinkLayer;
 		}
+
+		/// @struct SerializedFields
+		/// Fields written by VxlanLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for VxlanLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ ValidVNI, GroupPolicyID, VNI };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief True if the "valid VNI" flag (I bit) is set
+			static const FieldDescriptor ValidVNI;
+
+			/// @brief Group Policy ID (VXLAN-GBP extension)
+			static const FieldDescriptor GroupPolicyID;
+
+			/// @brief VXLAN Network Identifier (24 bits)
+			static const FieldDescriptor VNI;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 }  // namespace pcpp

Packet++/header/WakeOnLanLayer.h

@@ -137,5 +137,29 @@ namespace pcpp
 
 		/// @return Returns the protocol info as readable string
 		std::string toString() const override;
+
+		/// @struct SerializedFields
+		/// Fields written by WakeOnLanLayer's serializeLayer(), in addition to
+		/// Layer::SerializedFields.
+		struct SerializedFields : Layer::SerializedFields
+		{
+			/// @return All field descriptors for WakeOnLanLayer
+			static std::vector<FieldDescriptor> all()
+			{
+				auto result = Layer::SerializedFields::all();
+				std::initializer_list<FieldDescriptor> extra{ TargetAddress, Password };
+				std::copy(extra.begin(), extra.end(), std::back_inserter(result));
+				return result;
+			}
+
+			/// @brief Target MAC address that the magic packet wakes, as a string
+			static const FieldDescriptor TargetAddress;
+
+			/// @brief Optional SecureOn password, if present
+			static const FieldDescriptor Password;
+		};
+
+	protected:
+		void serializeLayer(ObjectScope& serializer) const override;
 	};
 }  // namespace pcpp

Packet++/src/EthDot3Layer.cpp

@@ -52,4 +52,15 @@ namespace pcpp
 			return false;
 		}
 	}
+
+	const FieldDescriptor EthDot3Layer::SerializedFields::SrcMacAddress{ Layer::SerializedFields::MaxID + 1,
+		                                                                 "srcMacAddress" };
+	const FieldDescriptor EthDot3Layer::SerializedFields::DstMacAddress{ Layer::SerializedFields::MaxID + 2,
+		                                                                 "dstMacAddress" };
+
+	void EthDot3Layer::serializeLayer(ObjectScope& serializer) const
+	{
+		serializer.writeField(SerializedFields::SrcMacAddress, getSourceMac().toString());
+		serializer.writeField(SerializedFields::DstMacAddress, getDestMac().toString());
+	}
 }  // namespace pcpp

Packet++/src/LLCLayer.cpp

@@ -51,4 +51,15 @@ namespace pcpp
 		return dataLen >= sizeof(llc_header) && !(data[0] == 0xFF && data[1] == 0xFF);
 	}
 
+	const FieldDescriptor LLCLayer::SerializedFields::DSAP{ Layer::SerializedFields::MaxID + 1, "dsap" };
+	const FieldDescriptor LLCLayer::SerializedFields::SSAP{ Layer::SerializedFields::MaxID + 2, "ssap" };
+	const FieldDescriptor LLCLayer::SerializedFields::Control{ Layer::SerializedFields::MaxID + 3, "control" };
+
+	void LLCLayer::serializeLayer(ObjectScope& serializer) const
+	{
+		auto* header = getLlcHeader();
+		serializer.writeField(SerializedFields::DSAP, header->dsap);
+		serializer.writeField(SerializedFields::SSAP, header->ssap);
+		serializer.writeField(SerializedFields::Control, header->control);
+	}
 }  // namespace pcpp

Packet++/src/MplsLayer.cpp

@@ -150,4 +150,19 @@ namespace pcpp
 		       ", Bottom of stack: " + bottomOfStack;
 	}
 
+	const FieldDescriptor MplsLayer::SerializedFields::Label{ Layer::SerializedFields::MaxID + 1, "label" };
+	const FieldDescriptor MplsLayer::SerializedFields::TTL{ Layer::SerializedFields::MaxID + 2, "ttl" };
+	const FieldDescriptor MplsLayer::SerializedFields::IsBottomOfStack{ Layer::SerializedFields::MaxID + 3,
+		                                                                "isBottomOfStack" };
+
+	const FieldDescriptor MplsLayer::SerializedFields::ExperimentalUseValue{ Layer::SerializedFields::MaxID + 4,
+		                                                                     "experimentalUseValue" };
+
+	void MplsLayer::serializeLayer(ObjectScope& serializer) const
+	{
+		serializer.writeField(SerializedFields::Label, getMplsLabel());
+		serializer.writeField(SerializedFields::TTL, getTTL());
+		serializer.writeField(SerializedFields::IsBottomOfStack, isBottomOfStack());
+		serializer.writeField(SerializedFields::ExperimentalUseValue, getExperimentalUseValue());
+	}
 }  // namespace pcpp

Packet++/src/NullLoopbackLayer.cpp

@@ -103,4 +103,11 @@ namespace pcpp
 		return "Null/Loopback";
 	}
 
+	const FieldDescriptor NullLoopbackLayer::SerializedFields::Family{ Layer::SerializedFields::MaxID + 1, "family" };
+
+	void NullLoopbackLayer::serializeLayer(ObjectScope& serializer) const
+	{
+		serializer.writeField(SerializedFields::Family, getFamily());
+	}
+
 }  // namespace pcpp