💥 Hide raw payloads behind the feature flag, and improve the performance

Cargo.toml

@@ -12,7 +12,8 @@ categories = ["parsing"]
 
 [features]
 default = []
-meta = ["dep:serde_json"]
+meta = ["dep:serde_json"] # `meta.json` parsing
+raw-payload = [] # save raw packet payloads, enabling increases memory usage and decreases performance
 
 [dependencies]
 bytes = "1.4.0"

src/models/data/entity_method.rs

@@ -15,48 +15,37 @@ pub mod update_arena;
 #[serde_as]
 #[derive(Debug, Serialize)]
 pub enum EntityMethod {
-    /// Subtype `0x2F`.
+    /// Subtype 47.
     UpdateArena {
         field_number: u64,
         arguments: UpdateArena,
-
-        /// Original payload for investigation.
-        #[serde_as(as = "serde_with::hex::Hex")]
-        payload: Vec<u8>,
     },
 
     /// Default variant when subtype is not known by the parser.
-    Unknown {
-        sub_type: u32,
-
-        /// Whole packet payload (including the sub-type).
-        #[serde_as(as = "serde_with::hex::Hex")]
-        payload: Vec<u8>,
-    },
+    Unknown { sub_type: u32 },
 }
 
 impl EntityMethod {
     /// Parse the entity method payload.
-    pub fn new(payload: Vec<u8>) -> Result<Self> {
-        let mut reader = payload.as_slice();
+    pub fn new(payload: &[u8]) -> Result<Self> {
+        let mut payload = payload;
 
-        reader.read_u32::<LittleEndian>()?;
-        let sub_type = reader.read_u32::<LittleEndian>()?;
+        payload.read_u32::<LittleEndian>()?;
+        let sub_type = payload.read_u32::<LittleEndian>()?;
 
         let this = match sub_type {
-            0x2F => {
-                let _inner_length = reader.read_u32::<LittleEndian>()?;
+            47 => {
+                let _inner_length = payload.read_u32::<LittleEndian>()?;
 
-                let field_number = decode_varint(&mut reader)?;
-                let message_length = read_quirky_length(&mut reader)?;
+                let field_number = decode_varint(&mut payload)?;
+                let message_length = read_quirky_length(&mut payload)?;
                 Self::UpdateArena {
                     field_number,
-                    arguments: UpdateArena::decode(&reader[..message_length])?,
-                    payload,
+                    arguments: UpdateArena::decode(&payload[..message_length])?,
                 }
             }
 
-            _ => Self::Unknown { sub_type, payload },
+            _ => Self::Unknown { sub_type },
         };
         Ok(this)
     }

src/models/data/packet.rs

@@ -2,14 +2,20 @@ use std::io::Read;
 
 use byteorder::{LittleEndian, ReadBytesExt};
 use serde::Serialize;
+use serde_with::serde_as;
 
 use crate::models::data::payload::Payload;
 use crate::result::Result;
 
+#[serde_as]
 #[derive(Debug, Serialize)]
 pub struct Packet {
     pub clock: f32,
     pub payload: Payload,
+
+    #[cfg(feature = "raw-payload")]
+    #[serde_as(as = "serde_with::hex::Hex")]
+    pub raw_payload: Vec<u8>,
 }
 
 impl Packet {
@@ -18,8 +24,13 @@ impl Packet {
         let type_ = reader.read_u32::<LittleEndian>()?;
         let clock = reader.read_f32::<LittleEndian>()?;
         let payload = Self::read_payload(reader, length as usize)?;
-        let payload = Payload::new(type_, payload)?;
-        let this = Self { clock, payload };
+        let this = Self {
+            clock,
+            payload: Payload::new(type_, &payload)?,
+
+            #[cfg(feature = "raw-payload")]
+            raw_payload: payload,
+        };
         Ok(Some(this))
     }
 

src/models/data/payload.rs

@@ -25,32 +25,27 @@ pub enum Payload {
     EntityMethod(EntityMethod),
 
     /// Default payload when type is not known by the parser.
-    Unknown {
-        packet_type: u32,
-
-        /// Whole packet payload.
-        #[serde_as(as = "serde_with::hex::Hex")]
-        raw: Vec<u8>,
-    },
+    Unknown { packet_type: u32 },
 }
 
 impl Payload {
     /// Parse the packet payload.
-    pub fn new(packet_type: u32, payload: Vec<u8>) -> Result<Self> {
+    pub fn new(packet_type: u32, payload: &[u8]) -> Result<Self> {
+        let mut payload = payload;
+
         let this = match packet_type {
             0 => {
-                let mut reader = payload.as_slice();
-                reader.read_exact(&mut [0; 10])?;
+                payload.read_exact(&mut [0; 10])?;
 
-                let author_nickname = read_string(&mut reader)?;
-                let arena_unique_id = reader.read_u64::<LittleEndian>()?;
-                let arena_type_id = reader.read_u32::<LittleEndian>()?;
-                let type_0 = {
-                    let pickled_length = read_quirky_length(&mut reader)?;
-                    read_pickled(&mut reader, pickled_length)?
+                let author_nickname = read_string(&mut payload)?;
+                let arena_unique_id = payload.read_u64::<LittleEndian>()?;
+                let arena_type_id = payload.read_u32::<LittleEndian>()?;
+                let arguments = {
+                    let pickled_length = read_quirky_length(&mut payload)?;
+                    read_pickled(&mut payload, pickled_length)?
                 };
                 Self::BasePlayerCreate {
-                    arguments: type_0,
+                    arguments,
                     author_nickname,
                     arena_unique_id,
                     arena_type_id,
@@ -59,7 +54,7 @@ impl Payload {
 
             8 => Self::EntityMethod(EntityMethod::new(payload)?),
 
-            _ => Self::Unknown { raw: payload, packet_type },
+            _ => Self::Unknown { packet_type },
         };
         Ok(this)
     }