Started implementing serialization logic

Author: cernec1999

config/client-example.toml

@@ -11,14 +11,10 @@ nick = "[CHANGEME]"
 # The version used in the login packet
 version = "GSERV025"
 
-# The platform for the joining client
-platform = "win"
-
-# Three identifiers, which are used to identify the user's client, for security
-# purposes. The RC client actually uses three such identifiers, and I believe the
-# format is usually 3 16-byte values formatted as ASCII hex. The format is basically
-# the same as MD5 hashes.
-system_ids = ["[CHANGEME]", "[CHANGEME]", "[CHANGEME]"]
+# These are IDs used to identify the user's client, for security purposes. The RC client
+# actually uses three such identifiers, and I believe the format is usually 3 16-byte
+# values formatted as ASCII hex. The format is basically the same as MD5 hashes.
+identification = ["win", "[CHANGEME]", "[CHANGEME]", "[CHANGEME]"]
 
 # The account username (e.g. Graal123456)
 auth.account_name = "[CHANGEME]"

logging_config.yaml

@@ -3,7 +3,13 @@ appenders:
     kind: console
     encoder:
       pattern: "{h({d(%Y-%m-%d %H:%M:%S)(utc)} - {l}: {m}{n})}"
+loggers:
+  preagonal_client_rs:
+    level: info
+    appenders:
+      - console
+    additive: false
 root:
-  level: debug
+  level: warn
   appenders:
     - console

src/config.rs

@@ -22,11 +22,9 @@ pub struct LoginConfig {
     pub nick: Option<String>,
     /// The version to use
     pub version: String,
-    /// The account name to use
-    pub platform: String,
     #[serde(default)]
     /// The system ids to use
-    pub system_ids: Vec<String>,
+    pub identification: Vec<String>,
     /// The auth to use
     pub auth: LoginAuth,
 }

src/main.rs

@@ -186,12 +186,11 @@ async fn main() {
             let protocol = GProtocolV5::new(reader, writer);
             let encryption_key: u8 = rand::random::<u8>() & 0x7f;
             let login_packet = RcLogin::new(
-                encryption_key as u32,
+                encryption_key,
                 login.version,
                 login.auth.account_name,
                 login.auth.password,
-                login.platform,
-                login.system_ids,
+                login.identification,
             );
 
             // Wrap the protocol in an Arc<Mutex<_>> so it can be shared safely.

src/net/mod.rs

@@ -5,3 +5,6 @@ pub mod packet;
 
 /// This module contains the protocol definitions and implementations.
 pub mod protocol;
+
+/// This module contains the serialization / deserialization logic
+pub mod serialization;

src/net/packet/from_client/rc_chat.rs

@@ -1,25 +1,30 @@
 #![deny(missing_docs)]
 
-use crate::net::packet::{GPacket, PacketId};
+use serde::Serialize;
+
+use crate::net::{
+    packet::{GPacket, PacketId},
+    serialization::serialize::serialize_to_vector,
+};
 
 use super::FromClientPacketId;
 
 /// RcChat packet.
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct RcChat {
     /// Message
     pub message: String,
 }
 
 impl RcChat {
     /// Create a new RcChat packet.
-    pub fn new(message: String) -> Self {
-        Self { message }
-    }
-
-    fn serialize(&self) -> Vec<u8> {
-        // Simply turn the message into a byte vector.
-        self.message.as_bytes().to_vec()
+    pub fn new<S>(message: S) -> Self
+    where
+        S: Into<String>,
+    {
+        Self {
+            message: message.into(),
+        }
     }
 }
 
@@ -29,6 +34,6 @@ impl GPacket for RcChat {
     }
 
     fn data(&self) -> Vec<u8> {
-        self.serialize()
+        serialize_to_vector(self).expect("Failed to serialize RcChat packet")
     }
 }

src/net/packet/from_client/rc_login.rs

@@ -1,71 +1,48 @@
 #![deny(missing_docs)]
 
-use crate::{
-    io::{GraalIoError, io_vec::IntoSyncGraalWriterRef},
-    net::packet::{GPacket, PacketId},
+use serde::Serialize;
+
+use crate::net::{
+    packet::{GPacket, PacketId},
+    serialization::{GString, serialize::serialize_to_vector},
 };
 
 use super::FromClientPacketId;
 
 /// RcLogin packet.
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct RcLogin {
     /// Encryption key.
-    pub encryption_key: u32,
+    pub encryption_key: u8,
     /// Version.
     pub version: String,
     /// Account.
-    pub account: String,
+    pub account: GString,
     /// Password.
-    pub password: String,
-    /// Platform.
-    pub platform: String,
+    pub password: GString,
     /// PC IDs
-    pub pc_ids: Vec<String>,
+    pub identification: Vec<String>,
 }
 
 impl RcLogin {
     /// Create a new RcLogin packet.
-    pub fn new(
-        encryption_key: u32,
-        version: String,
-        account: String,
-        password: String,
-        platform: String,
-        pc_ids: Vec<String>,
-    ) -> Self {
+    pub fn new<S>(
+        encryption_key: u8,
+        version: S,
+        account: S,
+        password: S,
+        identification: Vec<String>,
+    ) -> Self
+    where
+        S: Into<String>,
+    {
         Self {
             encryption_key,
-            version,
-            account,
-            password,
-            platform,
-            pc_ids,
-        }
-    }
-
-    fn serialize(&self) -> Result<Vec<u8>, GraalIoError> {
-        let mut vec = Vec::new();
-        {
-            let mut writer = vec.into_sync_graal_writer();
-
-            writer.write_gu8(self.encryption_key.into())?;
-            writer.write_bytes(self.version.as_bytes())?;
-            writer.write_gstring(&self.account)?;
-            writer.write_gstring(&self.password)?;
-            writer.write_bytes(self.platform.as_bytes())?;
-            writer.write_bytes(b",\"")?;
-            for (i, pc_id) in self.pc_ids.iter().enumerate() {
-                if i > 0 {
-                    writer.write_bytes(b"\",\"")?;
-                }
-                writer.write_bytes(pc_id.as_bytes())?;
-            }
-            writer.write_bytes(b"\"")?;
-            writer.flush()?;
+            version: version.into(),
+            account: GString(account.into()),
+            password: GString(password.into()),
+            identification,
         }
-
-        Ok(vec)
     }
 }
 
@@ -75,7 +52,6 @@ impl GPacket for RcLogin {
     }
 
     fn data(&self) -> Vec<u8> {
-        self.serialize()
-            .expect("Failed to serialize RcLogin packet")
+        serialize_to_vector(&self).expect("Failed to serialize RcLogin packet")
     }
 }

src/net/serialization/error.rs

@@ -0,0 +1,30 @@
+use std::fmt::Display;
+
+use serde::de;
+use thiserror::Error;
+
+use crate::io::GraalIoError;
+
+/// An error type for Graal IO operations.
+#[derive(Debug, Error)]
+pub enum GraalSerializationError {
+    /// An IO error occurred.
+    #[error("IO error: {0}")]
+    Io(#[from] GraalIoError),
+
+    /// An error occurred while encoding or decoding a Graal value.
+    #[error("Other: {0}")]
+    Other(String),
+}
+
+impl serde::ser::Error for GraalSerializationError {
+    fn custom<T: Display>(msg: T) -> Self {
+        GraalSerializationError::Other(msg.to_string())
+    }
+}
+
+impl de::Error for GraalSerializationError {
+    fn custom<T: Display>(msg: T) -> Self {
+        GraalSerializationError::Other(msg.to_string())
+    }
+}

src/net/serialization/mod.rs

@@ -0,0 +1,33 @@
+#![deny(missing_docs)]
+
+use serde::{Deserialize, Serialize};
+
+/// This module defines the error types for serialization.
+pub mod error;
+/// This module handles the serialization of packets.
+pub mod serialize;
+
+/// A GString is a string that is serialized as a length-preceded string.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GString(pub String);
+
+/// Allow conversion from GString to String.
+impl From<GString> for String {
+    fn from(g: GString) -> Self {
+        g.0
+    }
+}
+
+/// Allow conversion from String to GString.
+impl From<String> for GString {
+    fn from(s: String) -> Self {
+        GString(s)
+    }
+}
+
+/// Allow conversion from &str to GString.
+impl From<&str> for GString {
+    fn from(s: &str) -> Self {
+        GString(s.to_string())
+    }
+}