重构 EasyTier 参数拼接逻辑 (#81)

* Refactor EasyTier argument building.

* Remote unused imports.

* Fix.

* Refactor PortForward configuration.

Author: burningtnt

src/controller/rooms/experimental/room.rs

@@ -3,6 +3,7 @@ use crate::controller::rooms::legacy;
 use crate::controller::states::{AppState, AppStateCapture};
 use crate::controller::{ExceptionType, Room, RoomKind, SCAFFOLDING_PORT};
 use crate::easytier;
+use crate::easytier::argument::{Argument, PortForward, Proto};
 use crate::mc::fakeserver::FakeServer;
 use crate::ports::PortRequest;
 use crate::scaffolding::client::ClientSession;
@@ -11,10 +12,12 @@ use crate::scaffolding::PacketResponse;
 use rand_chacha::ChaCha12Rng;
 use rand_core::{OsRng, RngCore, SeedableRng, TryRngCore};
 use serde_json::{json, Value};
+use std::borrow::Cow;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
 use std::str::FromStr;
 use std::time::{Duration, SystemTime};
 use std::{io, thread};
+use std::mem::{transmute, MaybeUninit};
 
 static CHARS: &[u8] = "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ".as_bytes();
 
@@ -137,13 +140,11 @@ pub fn start_host(room: Room, port: u16, player: Option<String>, capture: AppSta
     let scaffolding = *SCAFFOLDING_PORT;
 
     let mut args = compute_arguments(&room);
-    args.push("--hostname".to_string());
-    args.push(format!("scaffolding-mc-server-{}", scaffolding));
-    args.push("--ipv4".to_string());
-    args.push("10.144.144.1".to_string());
-    args.push(format!("--tcp-whitelist={}", scaffolding));
-    args.push(format!("--tcp-whitelist={}", port));
-    args.push(format!("--udp-whitelist={}", port));
+    args.push(Argument::HostName(Cow::Owned(format!("scaffolding-mc-server-{}", scaffolding))));
+    args.push(Argument::IPv4(Ipv4Addr::new(10, 144, 144, 1)));
+    args.push(Argument::TcpWhitelist(scaffolding));
+    args.push(Argument::TcpWhitelist(port));
+    args.push(Argument::UdpWhitelist(port));
 
     let easytier = easytier::FACTORY.create(args);
     let capture = {
@@ -213,9 +214,9 @@ pub fn start_host(room: Room, port: u16, player: Option<String>, capture: AppSta
 
 pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture) {
     let mut args = compute_arguments(&room);
-    args.push("-d".to_string());
-    args.push("--tcp-whitelist=0".to_string());
-    args.push("--udp-whitelist=0".to_string());
+    args.push(Argument::DHCP);
+    args.push(Argument::TcpWhitelist(0));
+    args.push(Argument::UdpWhitelist(0));
     let easytier = easytier::FACTORY.create(args);
     let capture = {
         let Some(state) = capture.try_capture() else {
@@ -250,10 +251,11 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
 
                     let local_port = PortRequest::Scaffolding.request();
 
-                    if !easytier.add_port_forward(&[(
-                        SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
-                        SocketAddrV4::new(ip, port).into(),
-                    )]) {
+                    if !easytier.add_port_forward(&[PortForward {
+                        local: SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
+                        remote: SocketAddrV4::new(ip, port).into(),
+                        proto: Proto::TCP
+                    }]) {
                         logging!("RoomExperiment", "Cannot create a port-forward {} -> {} for Scaffolding Connection.", local_port, port);
                         state.set(AppState::Exception { kind: ExceptionType::GuestEasytierCrash });
                         return;
@@ -346,17 +348,31 @@ pub fn start_guest(room: Room, player: Option<String>, capture: AppStateCapture)
         // If failed, use a dynamic free port instead.
         let local_port = PortRequest::request_specific(port).unwrap_or_else(|| PortRequest::Minecraft.request());
 
-        if !easytier.add_port_forward(&[(
-            SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
-            SocketAddrV4::new(host_ip, port).into()
-        ), (
-            SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, local_port, 0, 0).into(),
-            SocketAddrV4::new(host_ip, port).into()
-        )]) {
+        if !easytier.add_port_forward(&{
+            let locals = [
+                SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
+                SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, local_port, 0, 0).into(),
+            ];
+            let protos = [Proto::TCP, Proto::UDP];
+
+            // TODO: Compute SIZE automatically.
+            const SIZE: usize = 4;
+            assert_eq!(locals.len() * protos.len(), SIZE);
+            let mut forwards: [MaybeUninit<PortForward>; SIZE] = [const { MaybeUninit::uninit() }; _];
+            for (i, local) in locals.into_iter().enumerate() {
+                for (j, proto) in protos.iter().enumerate() {
+                    forwards[i * 2 + j].write(PortForward {
+                        remote: SocketAddrV4::new(host_ip, port).into(), local, proto: proto.clone()
+                    });
+                }
+            }
+            // SAFETY: These two types are of the same size and all elements have been properly initialized.
+            unsafe { transmute::<[MaybeUninit<PortForward>; SIZE], [PortForward; SIZE]>(forwards) }
+        }) {
             logging!("RoomExperiment", "Cannot create a port-forward {} -> {} for MC Connection.", local_port, port);
             state.set(AppState::Exception { kind: ExceptionType::GuestEasytierCrash });
             return;
-        }
+        } else {}
 
         local_port
     };
@@ -549,44 +565,40 @@ static FALLBACK_SERVERS: [&str; 2] = [
     "tcp://public2.easytier.cn:54321",
 ];
 
-fn compute_arguments(room: &Room) -> Vec<String> {
-    static DEFAULT_ARGUMENTS: [&str; 7] = [
-        "--no-tun",
-        "--compression=zstd",
-        "--multi-thread",
-        "--latency-first",
-        "--enable-kcp-proxy",
-        "-l",
-        "udp://0.0.0.0:0",
+fn compute_arguments(room: &Room) -> Vec<Argument> {
+    static DEFAULT_ARGUMENTS: [Argument; 6] = [
+        Argument::NoTun,
+        Argument::Compression(Cow::Borrowed("zstd")),
+        Argument::MultiThread,
+        Argument::LatencyFirst,
+        Argument::EnableKcpProxy,
+        Argument::Listener {
+            address: SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, 0).into(),
+            proto: Proto::UDP
+        },
     ];
 
-    let mut args: Vec<String> = Vec::with_capacity(32);
+    let mut args: Vec<Argument> = Vec::with_capacity(32);
     args.extend_from_slice(&[
-        "--network-name".to_string(),
-        room.network_name.clone(),
-        "--network-secret".to_string(),
-        room.network_secret.clone(),
+        Argument::NetworkName(Cow::Owned(room.network_name.clone())),
+        Argument::NetworkSecret(Cow::Owned(room.network_secret.clone())),
     ]);
 
     match fetch_public_nodes(room) {
         Ok(nodes) => {
             for replay in nodes {
-                args.push("-p".to_string());
-                args.push(replay);
+                args.push(Argument::PublicServer(Cow::Owned(replay)));
             }
         }
         Err(e) => {
             logging!("RoomExperiment", "Cannot fetch EasyTier public nodes: {:?}.", e);
             for replay in FALLBACK_SERVERS {
-                args.push("-p".to_string());
-                args.push(replay.to_string());
+                args.push(Argument::PublicServer(Cow::Borrowed(replay)));
             }
         }
     }
 
-    for arg in DEFAULT_ARGUMENTS {
-        args.push(arg.to_string());
-    }
+    args.extend_from_slice(&DEFAULT_ARGUMENTS);
     args
 }
 

src/controller/rooms/legacy.rs

@@ -1,12 +1,14 @@
 use crate::controller::states::{AppState, AppStateCapture};
 use crate::controller::{ExceptionType, Room, RoomKind};
 use crate::easytier;
+use crate::easytier::argument::{Argument, PortForward, Proto};
 use crate::mc::fakeserver::FakeServer;
 use crate::ports::PortRequest;
 use num_bigint::BigUint;
 use socket2::{Domain, SockAddr, Socket, Type};
+use std::borrow::Cow;
 use std::mem::MaybeUninit;
-use std::net::{Ipv4Addr, SocketAddrV4};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
 use std::thread;
 use std::time::{Duration, SystemTime};
 
@@ -167,51 +169,47 @@ pub fn start_guest(room: Room, capture: AppStateCapture) {
         "tcp://et.01130328.xyz:11010",
         "tcp://et.gbc.moe:11011",
     ];
-    static DEFAULT_ARGUMENTS: [&'static str; 5] = [
-        "--no-tun",
-        "--compression=zstd",
-        "--multi-thread",
-        "--latency-first",
-        "--enable-kcp-proxy",
+    static DEFAULT_ARGUMENTS: [Argument; 5] = [
+        Argument::NoTun,
+        Argument::Compression(Cow::Borrowed("zstd")),
+        Argument::MultiThread,
+        Argument::LatencyFirst,
+        Argument::EnableKcpProxy,
     ];
 
     let mut args = vec![
-        "--network-name".to_string(),
-        room.network_name.clone(),
-        "--network-secret".to_string(),
-        room.network_secret.clone(),
+        Argument::NetworkName(Cow::Owned(room.network_name.clone())),
+        Argument::NetworkSecret(Cow::Owned(room.network_secret.clone())),
     ];
 
     if matches!(room.kind, RoomKind::PCL2CE { .. }) {
-        args.push("-p".to_string());
-        args.push("tcp://43.139.42.188:11010".to_string())
+        args.push(Argument::PublicServer(Cow::Borrowed("tcp://43.139.42.188:11010")));
     }
 
     for replay in REPLAY_SERVERS.iter() {
-        args.push("-p".to_string());
-        args.push(replay.to_string());
-    }
-    for arg in DEFAULT_ARGUMENTS.iter() {
-        args.push(arg.to_string());
+        args.push(Argument::PublicServer(Cow::Borrowed(&replay)));
     }
+    args.extend_from_slice(&DEFAULT_ARGUMENTS);
 
     let local_port = PortRequest::Minecraft.request();
 
     let (host_ip, remote_port) = match room.kind {
-        RoomKind::TerracottaLegacy { mc_port, .. } => ("10.144.144.1", mc_port),
-        RoomKind::PCL2CE { mc_port, .. } => ("10.114.51.41", mc_port),
+        RoomKind::TerracottaLegacy { mc_port, .. } => (Ipv4Addr::new(10, 144, 144, 1), mc_port),
+        RoomKind::PCL2CE { mc_port, .. } => (Ipv4Addr::new(10, 144, 51, 41), mc_port),
         _ => panic!("Should NOT be here"),
     };
 
-    args.push("-d".to_string());
-    args.push(format!(
-        "--port-forward=tcp://[::0]:{}/{}:{}",
-        local_port, host_ip, remote_port
-    ));
-    args.push(format!(
-        "--port-forward=tcp://0.0.0.0:{}/{}:{}",
-        local_port, host_ip, remote_port
-    ));
+    args.push(Argument::DHCP);
+    args.push(Argument::PortForward(PortForward {
+        local: SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, local_port).into(),
+        remote: SocketAddrV4::new(host_ip, remote_port).into(),
+        proto: Proto::TCP,
+    }));
+    args.push(Argument::PortForward(PortForward {
+        local: SocketAddrV6::new(Ipv6Addr::UNSPECIFIED, local_port, 0, 0).into(),
+        remote: SocketAddrV4::new(host_ip, remote_port).into(),
+        proto: Proto::TCP,
+    }));
 
     let capture = {
         let easytier = easytier::FACTORY.create(args);

src/easytier/argument.rs

@@ -0,0 +1,48 @@
+use std::borrow::Cow;
+use std::net::{Ipv4Addr, SocketAddr};
+
+type CowString = Cow<'static, str>;
+
+#[derive(Clone)]
+pub struct PortForward {
+    pub(crate) local: SocketAddr,
+    pub(crate) remote: SocketAddr,
+    pub(crate) proto: Proto,
+}
+
+#[derive(Clone)]
+pub enum Proto {
+    TCP,
+    UDP,
+}
+
+impl Proto {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Proto::TCP => "tcp",
+            Proto::UDP => "udp"
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum Argument {
+    NoTun,
+    Compression(CowString),
+    MultiThread,
+    LatencyFirst,
+    EnableKcpProxy,
+    NetworkName(CowString),
+    NetworkSecret(CowString),
+    PublicServer(CowString),
+    Listener {
+        address: SocketAddr,
+        proto: Proto,
+    },
+    PortForward(PortForward),
+    DHCP,
+    HostName(CowString),
+    IPv4(Ipv4Addr),
+    TcpWhitelist(u16),
+    UdpWhitelist(u16),
+}