Cleanup and new packet system impl

Author: jacobtread

Cargo.lock

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-blaze-pk = { path = "../BlazePK" }
+blaze-pk = "0.2.3"
 blaze-schannel = "0.1.0"
 egui = "0.19.0"
 eframe = "0.19.0"

Cargo.toml

@@ -1,4 +1,4 @@
-use std::sync::{Arc, RwLock, TryLockResult};
+use std::sync::{Arc, RwLock};
 use std::thread;
 use egui::{Align, Button, Color32, Layout, Vec2};
 use egui_extras::RetainedImage;
@@ -34,8 +34,7 @@ impl App {
 
         thread::spawn(move || {
             let shared_state = shared_state.clone();
-            run_server(shared_state.clone())
-                .expect("Failed to start server");
+            run_server(shared_state.clone());
         });
 
         app
@@ -54,7 +53,7 @@ impl App {
             .map_err(|_| AppError::InvalidPort)?;
 
         let mut state = self.state.write()
-            .map_err(|err| AppError::FailedServerStart)?;
+            .map_err(|_| AppError::FailedServerStart)?;
         state.host = host.clone();
         state.port = port.clone();
         state.status = AppStatus::Redirecting { host, port };
@@ -65,7 +64,7 @@ impl App {
 }
 
 impl eframe::App for App {
-    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| {
             let styles = ui.style_mut();
             styles.visuals.widgets.noninteractive.bg_fill = Color32::from_rgb(0, 0, 0);

src/app.rs

@@ -11,6 +11,6 @@ fn main() {
     native_options.resizable = false;
     native_options.initial_window_size = Some(Vec2::new(300f32, 250f32));
     eframe::run_native("Pocket Relay Client", native_options,
-                       Box::new(|cc| Box::new(App::new())));
+                       Box::new(|_| Box::new(App::new())));
 
 }

src/main.rs

@@ -1,21 +1,12 @@
 use std::{io, thread};
-use std::io::{Cursor, Write};
 use std::net::{TcpListener, TcpStream};
 use std::sync::{Arc, PoisonError, RwLock};
-use blaze_pk::error::TdfError;
-use blaze_pk::io::Writable;
-use blaze_pk::packet::{DecodedPacket, Packet};
-use blaze_pk::tdf::Tdf;
+use blaze_pk::{group, OpaquePacket, packet, PacketError, Packets, TdfOptional};
 use blaze_schannel::{CertStore, SchannelCred, TlsStream};
 use crate::shared::SharedState;
 
-#[derive(Debug)]
-pub enum ServerError {
-    IO(io::Error),
-}
-
 /// Starts the server
-pub fn run_server(state: Arc<RwLock<SharedState>>) -> Result<(), ServerError> {
+pub fn run_server(state: Arc<RwLock<SharedState>>) {
     // Import redirector store
     let cert_store = {
         let store_bytes = include_bytes!("redirector.pfx");
@@ -48,14 +39,13 @@ pub fn run_server(state: Arc<RwLock<SharedState>>) -> Result<(), ServerError> {
             let _ = handle_client(stream, state);
         });
     }
-    Ok(())
 }
 
 #[derive(Debug)]
 pub enum ClientError {
     LockPoison,
     IOError(io::Error),
-    PacketError
+    PacketError(PacketError)
 }
 
 impl<Guard> From<PoisonError<Guard>> for ClientError {
@@ -70,37 +60,44 @@ impl From<io::Error> for ClientError {
     }
 }
 
-impl From<TdfError> for ClientError {
-    fn from(_: TdfError) -> Self {
-        ClientError::PacketError
+impl From<PacketError> for ClientError {
+    fn from(err: PacketError) -> Self {
+        ClientError::PacketError(err)
+    }
+}
+
+packet! {
+    struct RedirectPacket {
+        ADDR: TdfOptional<AddressGroup>,
+        SECU: bool,
+        XDNS: bool,
+    }
+}
+
+group! {
+    struct AddressGroup {
+        HOST: String,
+        PORT: u16
     }
 }
 
 pub fn handle_client(
     stream: &mut TlsStream<TcpStream>,
     state: Arc<RwLock<SharedState>>,
 ) -> Result<(), ClientError> {
-    let packet = DecodedPacket::read(stream)?;
-    let content = {
-        let state = state.read()?;
-        let content = vec![
-            Tdf::optional("ADDR", 0, Some(
-                Tdf::group("VALUE", vec![
-                    Tdf::str("HOST", &state.host),
-                    Tdf::num("PORT", (*&state.port) as u64),
-                ])
-            )),
-            Tdf::bool("SECU", false),
-            Tdf::bool("XDNS", false),
-        ];
-        content
+    let packet = OpaquePacket::read(stream)?;
+    let state = state.read()?;
+    let content = RedirectPacket {
+        ADDR: TdfOptional::default_some("VALUE", AddressGroup {
+            HOST: state.host.clone(),
+            PORT: state.port,
+        }),
+        SECU: false,
+        XDNS: false
     };
-    let response = Packet::response(&packet, content);
-    let out_cursor = &mut Cursor::new(Vec::new());
-    response.write(out_cursor)?;
-    let stream = stream;
-    let bytes = out_cursor.get_mut();
-    stream.write_all(bytes)?;
+
+    let response = Packets::response(&packet, content);
+    response.write(stream)?;
     stream.shutdown()?;
     Ok(())
 }

src/server.rs

@@ -1,5 +1,4 @@
 use std::fmt;
-use std::fmt::{Display, Write};
 
 /// The default host to redirect to
 pub const DEFAULT_HOST: &str = "127.0.0.1";
@@ -32,7 +31,7 @@ pub enum AppStatus {
 }
 
 
-impl Display for AppStatus {
+impl fmt::Display for AppStatus {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Redirecting { host, port } => f.write_str(&format!("Redirecting ({}:{})", host, port)),
@@ -50,7 +49,7 @@ pub enum AppError {
     FailedServerStart,
 }
 
-impl Display for AppError {
+impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             AppError::InvalidPort => f.write_str("Invalid port"),