Refactor wine client

rich-status/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "rich_status"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+wine_client = { path = "../wine-client" }
+log = "0.4.28"
+simple_logger = "5.0.0"
+binary-util = "0.3.4"
+serde_json = "1.0.143"
+serde = { version = "1.0.219", features = ["derive"] }

src/handler.rs → rich-status/src/handler.rs

@@ -1,7 +1,5 @@
 use crate::protocols::packet::ProtocolPacket;
 
-pub mod emulator;
-
 pub trait MessageHandler {
     fn handle_packet(&mut self, data: ProtocolPacket) -> Option<ProtocolPacket>;
 }

rich-status/src/main.rs

@@ -0,0 +1,71 @@
+use log::{LevelFilter, error, info};
+use simple_logger::SimpleLogger;
+
+use crate::{
+    handler::MessageHandler,
+    protocols::{discord, packet::ProtocolPacket},
+};
+
+mod handler;
+mod protocols;
+
+#[tokio::main]
+async fn main() {
+    SimpleLogger::new()
+        .with_level(LevelFilter::Off)
+        .with_module_level("rich_status", LevelFilter::Info)
+        .with_module_level("wine_client", LevelFilter::Trace)
+        .init()
+        .unwrap();
+
+    info!("Connecting to wineserver");
+
+    let mut api = wine_client::api::wine_api::connect(
+        "/tmp/.wine-1000/server-fc01-d29a92/socket".to_string(),
+    )
+    .unwrap();
+
+    info!("Connected!");
+
+    info!("Creating pipe");
+    let pipe = api
+        .create_named_pipe("\\??\\pipe\\discord-ipc-0".to_string())
+        .unwrap();
+
+    info!("Created pipe, waiting for connection");
+    api.accept_connection(&pipe);
+    info!("Received connection, reading data");
+
+    let mut handler: Box<dyn MessageHandler> = Box::new(discord::handler::emulator::Emulator {});
+
+    let mut buffer = Vec::<u8>::new();
+    loop {
+        let mut result = api.read(&pipe, 80);
+
+        info!("Read data: {:?}", result);
+
+        buffer.append(&mut result);
+
+        let packet = protocols::discord::utils::try_read_packet(&mut buffer);
+        match packet {
+            Ok((packet, remaining_data)) => {
+                buffer = remaining_data;
+
+                let response = handler.handle_packet(ProtocolPacket::Discord(packet));
+
+                match response {
+                    Some(response) => match response {
+                        ProtocolPacket::Discord(ipc_packet) => {
+                            let data = discord::utils::write_packet(ipc_packet).unwrap();
+                            api.write(&pipe, data);
+                        }
+                    },
+                    None => {}
+                }
+            }
+            Err(_) => {
+                error!("Failed to parse packet!");
+            }
+        }
+    }
+}

src/protocols/discord.rs → rich-status/src/protocols/discord.rs

@@ -1,3 +1,4 @@
 pub mod enums;
+pub mod handler;
 pub mod structs;
 pub mod utils;

rich-status/src/protocols/discord/handler.rs

@@ -0,0 +1 @@
+pub mod emulator;

src/protocols/discord/utils.rs → rich-status/src/protocols/discord/utils.rs

@@ -1,14 +1,13 @@
 use std::io::{self, Error};
 
-use crate::{
-    protocols::discord::{enums::Opcode, structs::IpcPacket},
-    utils::{binary_reader::BinaryReader, binary_writer::BinaryWriter},
-};
+use binary_util::{ByteReader, ByteWriter};
+
+use crate::protocols::discord::{enums::Opcode, structs::IpcPacket};
 
 pub fn try_read_packet(buffer: &[u8]) -> Result<(IpcPacket, Vec<u8>), io::Error> {
-    let mut reader = BinaryReader::from(buffer);
+    let mut reader = ByteReader::from(buffer);
 
-    let opcode = reader.u32()?;
+    let opcode = reader.read_u32_le()?;
     let opcode = match Opcode::try_from(opcode) {
         Ok(opcode) => opcode,
         Err(_) => {
@@ -19,7 +18,7 @@ pub fn try_read_packet(buffer: &[u8]) -> Result<(IpcPacket, Vec<u8>), io::Error>
         }
     };
 
-    let length: usize = reader.u32()?.try_into().unwrap();
+    let length: usize = reader.read_u32_le()?.try_into().unwrap();
 
     let mut buffer: Vec<u8> = vec![0; length];
     reader.read(&mut buffer)?;
@@ -42,10 +41,10 @@ pub fn try_read_packet(buffer: &[u8]) -> Result<(IpcPacket, Vec<u8>), io::Error>
 }
 
 pub fn write_packet(packet: IpcPacket) -> Result<Vec<u8>, io::Error> {
-    let mut writer = BinaryWriter::new();
-    writer.u32(packet.opcode as u32)?;
-    writer.u32(packet.data.len().try_into().unwrap())?;
+    let mut writer = ByteWriter::new();
+    writer.write_u32_le(packet.opcode as u32)?;
+    writer.write_u32_le(packet.data.len().try_into().unwrap())?;
     writer.write(&packet.data)?;
 
-    return Ok(writer.as_vec());
+    return Ok(writer.as_slice().to_vec());
 }