1.support specifying TOML format configuration file using the -f parameter

Author: ys928

Cargo.lock

@@ -28,6 +28,7 @@ anstyle = "1.0.6"
 sha2 = "0.10.8"
 axum = "0.7.5"
 chrono = "0.4.37"
+toml = "0.8.12"
 
 [profile.release]
 strip = true      # Automatically strip symbols from the binary.

Cargo.toml

@@ -2,52 +2,83 @@
 
 use std::io::{Error, ErrorKind};
 
-use log::{info, trace, warn};
+use log::{error, info, trace, warn};
 use tokio::{net::TcpStream, time::timeout};
 use uuid::Uuid;
 
 use crate::{
-    config::G_CFG,
+    config::{Link, G_CFG},
     share::{proxy, FrameStream, Message, NETWORK_TIMEOUT},
 };
 
 /// run a client
-pub async fn run() -> Result<(), Error> {
-    let stream = connect_with_timeout(
-        &G_CFG.get().unwrap().link.remote_host,
-        G_CFG.get().unwrap().contrl_port,
-    )
-    .await?;
-    let mut frame_stream = FrameStream::new(stream);
+pub async fn run() {
+    let links = &G_CFG.get().unwrap().links;
+    let port = G_CFG.get().unwrap().port;
+    let mut joins = Vec::new();
+    for link in links.iter() {
+        let join = tokio::spawn(async move {
+            let stream = connect_with_timeout(&link.remote_host, port).await;
+            if stream.is_err() {
+                error!("Failed to connect to remote host:{}", stream.unwrap_err());
+                return;
+            }
+            let stream = stream.unwrap();
+            let mut frame_stream = FrameStream::new(stream);
 
-    auth(&mut frame_stream).await?;
+            let ret = auth(&mut frame_stream).await;
 
-    init_port(&mut frame_stream).await?;
+            if let Err(e) = ret {
+                error!("auth failed:{e}");
+                return;
+            }
 
-    loop {
-        // sure connection is established
-        frame_stream.send(&Message::Heartbeat).await?;
+            let ret = init_port(&mut frame_stream, link).await;
 
-        let msg = frame_stream.recv_timeout().await;
-        if msg.is_err() {
-            continue;
-        }
+            if let Err(e) = ret {
+                error!("init port failed:{e}");
+                return;
+            }
 
-        match msg.unwrap() {
-            Message::InitPort(_) => info!("unexpected init"),
-            Message::Auth(_) => warn!("unexpected auth"),
-            Message::Heartbeat => trace!("server check heartbeat"),
-            Message::Error(e) => return Err(Error::new(ErrorKind::Other, e)),
-            Message::Connect(id) => {
-                tokio::spawn(async move {
-                    info!("new connection");
-                    match handle_proxy_connection(id).await {
-                        Ok(_) => info!("connection exited"),
-                        Err(err) => warn!("connection exited with error {}", err),
+            loop {
+                // sure connection is established
+                let ret = frame_stream.send(&Message::Heartbeat).await;
+
+                if let Err(e) = ret {
+                    error!("heartbeat failed:{e}");
+                    return;
+                }
+
+                let msg = frame_stream.recv_timeout().await;
+                if msg.is_err() {
+                    continue;
+                }
+
+                match msg.unwrap() {
+                    Message::InitPort(_) => info!("unexpected init"),
+                    Message::Auth(_) => warn!("unexpected auth"),
+                    Message::Heartbeat => trace!("server check heartbeat"),
+                    Message::Error(e) => {
+                        error!("{}", e);
+                        return;
                     }
-                });
+                    Message::Connect(id) => {
+                        tokio::spawn(async move {
+                            info!("new connection");
+                            match handle_proxy_connection(id, link).await {
+                                Ok(_) => info!("connection exited"),
+                                Err(err) => warn!("connection exited with error {}", err),
+                            }
+                        });
+                    }
+                }
             }
-        }
+        });
+
+        joins.push(join);
+    }
+    for join in joins {
+        let _ = join.await;
     }
 }
 
@@ -70,9 +101,7 @@ async fn auth(frame_stream: &mut FrameStream) -> Result<(), Error> {
 }
 
 /// send and recv InitPort message with server
-async fn init_port(frame_stream: &mut FrameStream) -> Result<(), Error> {
-    let link = &G_CFG.get().unwrap().link;
-
+async fn init_port(frame_stream: &mut FrameStream, link: &Link) -> Result<(), Error> {
     frame_stream
         .send(&Message::InitPort(link.remote_port))
         .await?;
@@ -100,10 +129,8 @@ async fn connect_with_timeout(addr: &str, port: u16) -> Result<TcpStream, Error>
 }
 
 /// deal connection from server proxy port
-async fn handle_proxy_connection(id: Uuid) -> Result<(), Error> {
-    let link = &G_CFG.get().unwrap().link;
-
-    let stream = connect_with_timeout(&link.remote_host, G_CFG.get().unwrap().contrl_port).await?;
+async fn handle_proxy_connection(id: Uuid, link: &Link) -> Result<(), Error> {
+    let stream = connect_with_timeout(&link.remote_host, G_CFG.get().unwrap().port).await?;
     let mut frame_stream = FrameStream::new(stream);
 
     auth(&mut frame_stream).await?;