完善服务端功能

2025-01-19 22:24:46 +08:00
parent 72f332db47
commit 6888bd7b92
7 changed files with 290 additions and 73 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,9 +4,8 @@ version = "0.1.0"
 edition = "2021"

 [lib]
-name = "LingTransmit"
-crate-type = ["staticlib"]
-
+crate-type = ["rlib", "staticlib"]
+path = "src/lib.rs"

 [dependencies]
 openssl = "0.10.68"
@@ -14,3 +13,6 @@ tokio = { version = "1.43.0", features = ["full"] }
 async-trait = "0.1.85"
 tokio-macros = "2.5.0"
 log = "0.4.25"
+fern = "0.7.1"
+colored = "3.0.0"
+chrono = "0.4.39"
--- a/src/bin/main.rs
+++ b/src/bin/main.rs
@@ -4,4 +4,195 @@
 // 由 ling 创建于 2025/1/18.
 #![allow(non_snake_case)]

-fn main() {}
+use async_trait::async_trait;
+use chrono::Local;
+use colored::{Color, Colorize};
+use fern::Dispatch;
+use log::{Level, LevelFilter};
+use std::sync::Arc;
+use LingTransmit::server::event::ServerEvent;
+use LingTransmit::server::Client::Client;
+use LingTransmit::server::Server;
+use LingTransmit::ssl::ServerCert;
+
+#[tokio::main]
+async fn main() {
+    let cert = "-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+";
+    let pri = "-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: AES-256-CBC,AA416D12CD67CA769B2FA6F136B12B6E
+
+q3STJspEstTuvO70OlpVQJ0LyKnMp3zA79rbvxT7KeB/yzaB8ZuZJTpriK2Gm/ol
+mDqIj4pynBjRAYcJIpJDbdSE6u/5YJoXP+CuLDjGhVDJHR8uAAxFMTk0NjStw7xX
+YFNjaEMWliHCXQy5cYXYA48wceYT12Ff7pOWv/vFeQyuUWuAd90yE4FI4rch4Ik0
+b7mO7/Y2U1mxiFZVRPmteidfHBRZRCEuT7hgpC8KZ0xBqDQlKNYHvfAGEK8XYzKh
+UdK8vn76HLhlHTfpjB502PibYNGWqX6TbhVH/3dmnqJ5A6IKjVmi+YgBvPCBu6bm
+mQtcBLzBp3CBV4e6qKnWKhZS7kOAm29+LcEfFvMGQEZ3A7Crt7fu0IuAxch5qCxQ
+pBAT5SBprhO64fo2L/5WGa5DeGgt+1njXGTKlKDGxx15IKxvN+hhpefOytuukKsU
+shhXYOOnJ3fTbJas9bpsbeuFTEGf1lU2lxrrmvHLxm/qxhikkiZmuK9h0F0sd9VA
+MEZvcK/633ZMPxsbFJlakzSXEEtaaaSM4Pl8aRF7s0Px6L1r3d6eNL7Q/FQi+8N1
+QXL4iQeQTT3BHFUdToMCUei+PrBFBeK7JtL72AT5DUw3pwopBh85E+QrlAx3rKla
+kos5pXGhjEcWPdq8OotUjQ5IquQaGYP/rLzI/Iu33EX11saFaMR9CP0xdgVHREHk
+KTOlWPtreKDnOD2JWZ4/o2+pabV8MZ/CESpyBOSIzsQTl0CA3KRS/3TPZfmTkMfF
+qAWVSS4kcS6ZYAhG+euktj6+SUuSNWKmNy67qqjM1P3yUr1UKSeznyE4LulOxCxP
+V/1j4vkzmXYpWOkMSYWYaX5lJ5YChdp+sD4jQ/cBhAX7MpixcBORMeWIMta+qFY8
+um6LY6boYeaxvvvsVcE3TteDdfHy8MZgpY3HZuNWYdDH3R1HorsMVXwMG/L2TaLn
+4aAu0BxEORWxZWtqTFIVSDhvBwSVgWmHG825tovPtvv9ItzIcN5LnE8McoERt6jd
+vXKw5IozP6hSOEIazP8bCRN0LcodbhLO2HdijNvswqJrsvtI447Kw5nLcST+GZ7K
+G7KhRWyZTEliPljBov6dnDBF0qWPBKbzIACaCV9UpBKjRQd6ChOzUzBTA4OcyY9Q
+ZQjWxRNUbnS9OUOb6ihZb0PtfWf63hykFrCT4Kf0nNG8VrPbrpZIagbW5wdxzFUP
+Wh8t+axBvMqSb4KbaJasKK8K9MgA0nmJKcP7U9TKoucfqnFf0DIbAgTh3S+/918f
+2G968l3pTv3Rxd4HOhl+8ErXAy8L1YYemd6BJuG4TsR7ZoBRxBoy45oCr6TKXkZN
+0M4wellUAG3a5pDko/2JhExmCCn/orElUZ7oDFsj/HqLNW9JTQLnuUmHVk6HrmJM
+PKypVUMXav7xxncdUOUzAeoH85dkLxtCmDw4LbAvOqDpm1Gf5KFm53pKC75HN8+w
+pTp2x8EN76DljLxewNode8qHsAXG+VueTisMQMbLjnIYGPLFWHp8f74vZ/z/YEbb
+awkIjtd8QTxWs/WEYRcLy5CYyHRMLPxALziG9TE4jri0373GeMnlgOu7t36YotSl
+-----END RSA PRIVATE KEY-----
+";
+    init_log();
+    let server_cert = ServerCert::init_buffer_password(
+        &cert.as_bytes().to_vec(),
+        &pri.as_bytes().to_vec(),
+        "intmainvoid",
+    )
+    .expect("解析证书失败");
+    let server = Server::new_tcp("0.0.0.0:11451", server_cert, Arc::new(Event {}))
+        .await
+        .expect("启动服务端失败");
+    server.start_accept().await;
+}
+fn get_time() -> String {
+    let now = Local::now();
+    now.format("%Y-%m-%d %H:%M:%S").to_string()
+}
+fn init_log() {
+    let console_dispatch = Dispatch::new()
+        .format(|out, message, record| {
+            let (title, color) = match record.level() {
+                Level::Error => ("Error", Color::Red),
+                Level::Warn => ("Warning", Color::Yellow),
+                Level::Info => ("Info", Color::Green),
+                Level::Debug => ("Debug", Color::BrightWhite),
+                Level::Trace => ("Trace", Color::White),
+            };
+
+            out.finish(format_args!(
+                "{}",
+                format!("[{} {}]\t{}", get_time(), title, message).color(color)
+            ))
+        })
+        .chain(std::io::stdout())
+        .level(LevelFilter::Trace)
+        .apply();
+}
+
+struct Event {}
+
+#[async_trait]
+impl ServerEvent for Event {
+    async fn client_linker_listener(&self, client: Arc<Client>) {
+        println!("客户端连入，ID：{}", client.id);
+    }
+
+    async fn client_close_listener(&self, client: Arc<Client>) {
+        println!("客户端挂断，ID：{}", client.id)
+    }
+
+    async fn client_user_data(&self, client: Arc<Client>, packet: Vec<u8>) -> std::io::Result<()> {
+        println!(
+            "客户端发送数据，ID：{}，数据长度：{}",
+            client.id,
+            packet.len()
+        );
+        Ok(())
+    }
+}
--- a/src/packet/mod.rs
+++ b/src/packet/mod.rs
@@ -11,6 +11,7 @@ use crate::server::accept::OwnedReadHalfAbstraction;
 use crate::server::Client::Client;
 use std::fmt::format;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use std::{error, io};
 use tokio::io::AsyncReadExt;

@@ -27,7 +28,7 @@ pub enum NetworkPackets {
 /// 从字节流中读取一个数据包
 pub async fn read_packet(
    read: &mut Box<dyn OwnedReadHalfAbstraction>,
-    client: &Client,
+    client: Arc<Client>,
 ) -> io::Result<NetworkPackets> {
    //根据协议，通信伊始收到 SYN V1 信息，则使用V1协议加密通信
    //在此实现中，彻底摈弃了未加密的不安全数据。
@@ -35,7 +36,7 @@ pub async fn read_packet(
    if client.syn_version.load(Ordering::Acquire) == 0
        && !client.is_key_negotiation.load(Ordering::Acquire)
    {
-        let syn = read.read_i32().await?;
+        let syn = read.read_i32_le().await?;
        if syn != LING_SYN_V1 {
            return Err(make_error("客户端尝试使用未加密连接交换数据"));
        }
@@ -44,7 +45,7 @@ pub async fn read_packet(
        return Ok(NetworkPackets::SynV1);
    }
    //读取数据包长度
-    let mut size = read.read_i32().await?;
+    let mut size = read.read_i32_le().await?;
    // 在旧版本的协议中，没有魔数标记数据包开始，数据包通过 int32_t 类型的size作为开始。
    // 如果传输过程中出错，导致读取位置发生些许偏差，则size不准，可能错误分配堆内存，带来安全隐患。
    // 自 Ling V1.1开始，数据包头部必须使用 LING_START 开始
@@ -56,7 +57,7 @@ pub async fn read_packet(
            ));
        }
        //由于size实际上读取的是 LING_START 魔数，所以要重新读取四个字节作为数据包实际大小
-        size = read.read_i32().await?;
+        size = read.read_i32_le().await?;
        //附带魔数后，将数据包长度限制提高到 512kb
        if size > MAX_SIZE_V1_1 {
            return Err(make_error(
@@ -73,7 +74,7 @@ pub async fn read_packet(
    }

    // 数据包类型
-    let data_type = match read.read_i32().await? {
+    let data_type = match read.read_i32_le().await? {
        API_TYPE_ASK => API_TYPE_ASK,
        API_TYPE_PUSH_AES_KEY => API_TYPE_PUSH_AES_KEY,
        num => {
@@ -91,6 +92,15 @@ pub async fn read_packet(
        )));
    }

+    // 根据协议，每一个数据包都必须以 LING_STOP 作为结束
+    let stop = read.read_i32_le().await?;
+    if stop != LING_STOP {
+        return Err(make_error(format!(
+            "数据包结束标记错误，需要 {:X}，但发现 {:X}",
+            LING_STOP, stop
+        )));
+    }
+
    match data_type {
        API_TYPE_ASK => Ok(NetworkPackets::UserAsk(buffer)),
        API_TYPE_PUSH_AES_KEY => Ok(NetworkPackets::PushAesKey(buffer)),
--- a/src/server/Client.rs
+++ b/src/server/Client.rs
@@ -8,6 +8,7 @@ use crate::close_sender::CloseSender;
 use crate::packet::code::{SERVER_ACK, SERVER_ERROR};
 use crate::packet::{read_packet, NetworkPackets};
 use crate::server::accept::{OwnedReadHalfAbstraction, OwnedWriteHalfAbstraction, SocketAddr};
+use crate::server::event::ServerEvent;
 use crate::server::ClientID;
 use crate::ssl::ServerCert;
 use log::{error, info};
@@ -41,6 +42,7 @@ pub struct Client {
    pub key: OnceLock<String>,
    /// 服务器证书
    cert: Arc<ServerCert>,
+    pub(super) event: Arc<dyn ServerEvent>,
 }

 impl Client {
@@ -52,6 +54,7 @@ impl Client {
        id: ClientID,
        addr: SocketAddr,
        cert: Arc<ServerCert>,
+        event: Arc<dyn ServerEvent>,
    ) -> Self {
        Client {
            server_close,
@@ -64,6 +67,7 @@ impl Client {
            is_key_negotiation: AtomicBool::new(false),
            key: OnceLock::new(),
            cert,
+            event,
        }
    }

@@ -79,7 +83,7 @@ impl Client {
    }

    /// 开始处理该客户端的请求
-    pub async fn start(&self) {
+    pub async fn start(self: Arc<Client>) {
        loop {
            //从字节流中读取一个数据包
            let packet = tokio::select! {
@@ -90,14 +94,17 @@ impl Client {
                            Err(io::Error::new(io::ErrorKind::NotFound,"读取端已经被挂断"))
                        }
                        Some(ref mut val) => {
-                            read_packet(val,self).await
+                            read_packet(val,self.clone()).await
                        }
                    }
                } => {
                    match packet {
                        Ok(val) => {val}
                        Err(err) => {
-                            info!("{} 号连接读取数据包出错：{}",self.id,err.to_string());
+                            //  如果仅仅是读取到文件尾，说明客户端只是挂断了，不是什么大问题
+                            if err.kind() != io::ErrorKind::UnexpectedEof {
+                                error!("{} 号连接读取数据包出错：{}",self.id,err.to_string());
+                            }
                            return;
                        }
                    }
@@ -130,10 +137,10 @@ impl Client {
    }

    /// 处理客户端请求
-    async fn process_packet(&self, packet: NetworkPackets) -> io::Result<()> {
+    async fn process_packet(self: &Arc<Client>, packet: NetworkPackets) -> io::Result<()> {
        match packet {
            NetworkPackets::SynV1 => self.syn_v1().await,
-            NetworkPackets::UserAsk(_) => Ok(()),
+            NetworkPackets::UserAsk(data) => self.event.client_user_data(self.clone(), data).await,
            NetworkPackets::PushAesKey(data) => self.client_push_key(&data).await,
        }
    }
@@ -157,10 +164,10 @@ impl Client {
        let mut send = self.write_soc.lock().await;
        if let Err(_) = self.key.set(key.clone()) {
            //重复推送，拒绝密钥
-            send.write_i32(SERVER_ERROR).await?;
+            send.write_i32_le(SERVER_ERROR).await?;
            return Ok(());
        }
-        send.write_i32(SERVER_ACK).await?;
+        send.write_i32_le(SERVER_ACK).await?;
        Ok(())
    }

@@ -168,7 +175,7 @@ impl Client {
    async fn syn_v1(&self) -> io::Result<()> {
        let certificate = self.cert.certificate.to_pem()?;
        let mut send = self.write_soc.lock().await;
-        send.write_i64(certificate.len() as i64).await?;
+        send.write_i64_le(certificate.len() as i64).await?;
        send.write(&certificate).await?;
        Ok(())
    }
--- a/src/server/accept.rs
+++ b/src/server/accept.rs
@@ -9,53 +9,13 @@ use tokio::io;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tokio::net::{tcp, unix, TcpListener, UnixListener};

-/// 读取抽象，使用小端序
+/// 读取抽象
 #[async_trait]
-pub trait OwnedReadHalfAbstraction: AsyncRead + Unpin + Send + Sync {
-    async fn read_i32(&mut self) -> io::Result<i32> {
-        let mut buffer = [0u8; 4];
-        self.read_exact(&mut buffer).await?;
-        Ok(i32::from_le_bytes(buffer))
-    }
+pub trait OwnedReadHalfAbstraction: AsyncRead + Unpin + Send + Sync {}

-    async fn read_i64(&mut self) -> io::Result<i64> {
-        let mut buffer = [0u8; 8];
-        self.read_exact(&mut buffer).await?;
-        Ok(i64::from_le_bytes(buffer))
-    }
-
-    async fn read_u32(&mut self) -> io::Result<u32> {
-        let mut buffer = [0u8; 4];
-        self.read_exact(&mut buffer).await?;
-        Ok(u32::from_le_bytes(buffer))
-    }
-
-    async fn read_u64(&mut self) -> io::Result<u64> {
-        let mut buffer = [0u8; 8];
-        self.read_exact(&mut buffer).await?;
-        Ok(u64::from_le_bytes(buffer))
-    }
-}
-
-/// 写入抽象，使用小端序
+/// 写入抽象
 #[async_trait]
-pub trait OwnedWriteHalfAbstraction: AsyncWrite + Unpin + Send + Sync {
-    async fn write_i32(&mut self, value: i32) -> io::Result<usize> {
-        self.write(&value.to_le_bytes()).await
-    }
-
-    async fn write_i64(&mut self, value: i64) -> io::Result<usize> {
-        self.write(&value.to_le_bytes()).await
-    }
-
-    async fn write_u32(&mut self, value: u32) -> io::Result<usize> {
-        self.write(&value.to_le_bytes()).await
-    }
-
-    async fn write_u64(&mut self, value: u64) -> io::Result<usize> {
-        self.write(&value.to_le_bytes()).await
-    }
-}
+pub trait OwnedWriteHalfAbstraction: AsyncWrite + Unpin + Send + Sync {}

 #[async_trait]
 impl OwnedReadHalfAbstraction for tcp::OwnedReadHalf {}
--- a/src/server/event.rs
+++ b/src/server/event.rs
@@ -0,0 +1,28 @@
+// 版权所有 (c) ling 保留所有权利。
+// 除非另行说明，否则仅允许在LingTransmit中使用此文件中的代码。
+//
+// 由 ling 创建于 2025/1/19.
+#![allow(non_snake_case)]
+
+use crate::server::Client;
+use async_trait::async_trait;
+use std::io;
+use std::sync::Arc;
+use tokio::sync::broadcast;
+use tokio::sync::broadcast::error::{RecvError, SendError};
+
+#[async_trait]
+pub trait ServerEvent: Send + Sync {
+    /// 客户端连入事件
+    async fn client_linker_listener(&self, client: Arc<Client::Client>);
+
+    /// 客户端挂断事件
+    async fn client_close_listener(&self, client: Arc<Client::Client>);
+
+    /// 客户端请求
+    async fn client_user_data(
+        &self,
+        client: Arc<Client::Client>,
+        packet: Vec<u8>,
+    ) -> io::Result<()>;
+}
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -6,9 +6,11 @@

 pub mod Client;
 pub mod accept;
+pub mod event;

 use crate::close_sender::CloseSender;
 use crate::server::accept::AcceptSocket;
+use crate::server::event::ServerEvent;
 use crate::ssl::ServerCert;
 use async_trait::async_trait;
 use log::{debug, error};
@@ -32,30 +34,40 @@ pub struct Server {
    client_list: ClientList,
    next_id: AtomicU64,
    cert: Arc<ServerCert>,
+    event: Arc<dyn ServerEvent>,
 }

 impl Server {
-    fn new(listener: Box<dyn AcceptSocket>, cert: ServerCert) -> Self {
+    fn new(listener: Box<dyn AcceptSocket>, cert: ServerCert, event: Arc<dyn ServerEvent>) -> Self {
        Server {
            listener,
            close_sender: CloseSender::new(),
            client_list: Arc::new(Mutex::new(HashMap::new())),
            next_id: AtomicU64::new(0),
            cert: Arc::new(cert),
+            event,
        }
    }

-    pub async fn new_tcp<A: ToSocketAddrs>(addr: A, cert: ServerCert) -> io::Result<Self> {
+    pub async fn new_tcp<A: ToSocketAddrs>(
+        addr: A,
+        cert: ServerCert,
+        event: Arc<dyn ServerEvent>,
+    ) -> io::Result<Self> {
        let listener = TcpListener::bind(addr).await?;
-        Ok(Server::new(Box::new(listener), cert))
+        Ok(Server::new(Box::new(listener), cert, event))
    }

-    pub async fn new_unix<P>(path: P, cert: ServerCert) -> io::Result<Self>
+    pub async fn new_unix<P>(
+        path: P,
+        cert: ServerCert,
+        event: Arc<dyn ServerEvent>,
+    ) -> io::Result<Self>
    where
        P: AsRef<Path>,
    {
        let unix = UnixListener::bind(path)?;
-        Ok(Server::new(Box::new(unix), cert))
+        Ok(Server::new(Box::new(unix), cert, event))
    }

    /// 广播关闭消息
@@ -69,15 +81,18 @@ impl Server {
    }

    /// 挂断一个客户端
-    pub async fn close_client(&self, id: ClientID) {
-        Self::close_client_form_arc(&self.client_list, id).await;
+    pub async fn close_client(&self, client: &Arc<Client::Client>) {
+        Self::close_client_form_arc(&self.client_list, client).await;
    }

-    pub async fn close_client_form_arc(list: &ClientList, id: ClientID) {
+    pub async fn close_client_form_arc(list: &ClientList, client: &Arc<Client::Client>) {
+        let client_id = client.id;
        let mut lock = list.lock().await;
-        if let Some(client) = lock.get(&id) {
+        if let Some(client) = lock.get(&client_id) {
+            //向使用者报告客户端关闭
+            client.event.client_close_listener(client.clone()).await;
            client.close().await;
-            lock.remove(&id);
+            lock.remove(&client_id);
        }
    }

@@ -109,17 +124,21 @@ impl Server {
            id,
            addr,
            self.cert.clone(),
+            self.event.clone(),
        ));

        let mut lock = self.client_list.lock().await;
        lock.insert(id, client.clone());
        drop(lock);

+        //向使用者报告新的客户端连入
+        self.event.client_linker_listener(client.clone()).await;
+
        let list = self.get_client_list();
        tokio::spawn(async move {
-            client.start().await;
+            client.clone().start().await;
            //当连接的事件轮退出，则自动挂断
-            Self::close_client_form_arc(&list, id).await;
+            Self::close_client_form_arc(&list, &client).await;
        });
        Ok(())
    }