tcp

src/main.rs

 mod router;
 
-use crate::router::{Meta, Router, META_SIZE, SECRET_LENGTH};
 use crate::Schema::{TCP, UDP};
+use crate::router::{META_SIZE, Meta, Router, SECRET_LENGTH};
 use anyhow::{Context, Result};
-use crossbeam::epoch::{pin, Owned};
+use crossbeam::epoch::{Owned, pin};
 use crossbeam_utils::thread;
 use itertools::Itertools;
 use serde::{Deserialize, Deserializer};
 use socket2::Domain;
 use std::net::Shutdown;
+use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use std::time::Duration;
-use std::{collections::HashMap, env, mem::MaybeUninit, sync::Arc};
+use std::{collections::HashMap, env, mem::MaybeUninit};
 
 #[derive(Deserialize)]
 pub struct Config {
@@ -63,18 +64,16 @@ fn main() -> Result<()> {
     let config = serde_json::from_str::<Config>(env::args().nth(1).context("need param")?.as_str())?;
     let local_secret: [u8; SECRET_LENGTH] = Router::create_secret(config.local_secret.as_str())?;
 
-    let routers = Arc::new(
-        config
-            .routers
-            .iter()
-            .cloned()
-            .sorted_by_key(|r| r.remote_id)
-            .map(|c| {
-                let remote_id = c.remote_id;
-                Router::new(c, config.local_id).map(|r| (remote_id, r))
-            })
-            .collect::<Result<HashMap<u8, Router>, _>>()?,
-    );
+    let routers = config
+        .routers
+        .iter()
+        .cloned()
+        .sorted_by_key(|r| r.remote_id)
+        .map(|c| {
+            let remote_id = c.remote_id;
+            Router::new(c, config.local_id).map(|r| (remote_id, r))
+        })
+        .collect::<Result<HashMap<u8, Router>, _>>()?;
 
     for (_, group) in &routers
         .values()
@@ -89,7 +88,7 @@ fn main() -> Result<()> {
 
     thread::scope(|s| {
         // IP, UDP
-        for router in routers.values().filter(|&r| !(r.config.schema != TCP)) {
+        for router in routers.values().filter(|&r| r.config.schema != TCP) {
             s.spawn(|_| {
                 router.handle_outbound_ip_udp(config.local_id);
             });

src/router.rs

 use crate::{ConfigRouter, Schema};
-use anyhow::{bail, ensure, Error, Result};
-use base64::prelude::BASE64_STANDARD;
+use anyhow::{Error, Result, bail, ensure};
 use base64::Engine;
+use base64::prelude::BASE64_STANDARD;
 use socket2::{Domain, Protocol, SockAddr, SockFilter, Socket, Type};
 use std::net::Shutdown;
+use std::sync::Arc;
 use std::{
     ffi::c_void,
     mem::MaybeUninit,
@@ -12,15 +13,13 @@ use std::{
     os::fd::{AsRawFd, FromRawFd},
     process::{Command, ExitStatus},
     sync::atomic::Ordering,
-    sync::Arc,
 };
 use tun::Device;
 
-use crate::Schema::IP;
-use crossbeam::epoch::{pin, Atomic};
+use crossbeam::epoch::{Atomic, pin};
 use libc::{
-    setsockopt, sock_filter, sock_fprog, socklen_t, BPF_ABS, BPF_B, BPF_IND, BPF_JEQ, BPF_JMP, BPF_K, BPF_LD, BPF_LDX, BPF_MSH, BPF_RET, BPF_W,
-    MSG_FASTOPEN, SOL_SOCKET, SO_ATTACH_REUSEPORT_CBPF,
+    BPF_ABS, BPF_B, BPF_IND, BPF_JEQ, BPF_JMP, BPF_K, BPF_LD, BPF_LDX, BPF_MSH, BPF_RET, BPF_W, MSG_FASTOPEN, SO_ATTACH_REUSEPORT_CBPF, SOL_SOCKET, setsockopt,
+    sock_filter, sock_fprog, socklen_t,
 };
 
 pub const SECRET_LENGTH: usize = 32;
@@ -46,10 +45,10 @@ pub struct Router {
     pub config: ConfigRouter,
     pub secret: [u8; SECRET_LENGTH],
     pub tun: Device,
-    pub socket: Arc<Socket>,
-    pub endpoint: Arc<Atomic<SockAddr>>,
+    pub socket: Socket,
+    pub endpoint: Atomic<SockAddr>,
 
-    pub tcp_listener_connection: Arc<Atomic<Arc<Socket>>>,
+    pub tcp_listener_connection: Atomic<Arc<Socket>>,
 }
 
 impl Router {
@@ -63,8 +62,8 @@ impl Router {
         }
     }
     pub(crate) fn decrypt2(&self, data: &mut [u8], secret: &[u8; SECRET_LENGTH], range: Range<usize>) {
-        for i in range {
-            data[i] ^= secret[i % SECRET_LENGTH];
+        for (i, b) in data[range.clone()].iter_mut().enumerate() {
+            *b ^= secret[(range.start + i) % SECRET_LENGTH];
         }
     }
 
@@ -253,7 +252,7 @@ impl Router {
             let packet = unsafe { std::slice::from_raw_parts_mut(recv_buf.as_mut_ptr().cast(), len) };
             // if addr.is_ipv6() { println!("{:X?}", packet) }
             // 只有 ipv4 raw 会给 IP报头
-            let offset = if self.config.family == Domain::IPV4 && self.config.schema == IP {
+            let offset = if self.config.family == Domain::IPV4 && self.config.schema == Schema::IP {
                 (packet[0] & 0x0f) as usize * 4
             } else {
                 0
@@ -337,8 +336,8 @@ impl Router {
         Ok(Command::new("sh").args(["-c", config.up.as_str()]).status()?)
     }
 
-    fn create_endpoint(config: &ConfigRouter) -> Arc<Atomic<SockAddr>> {
-        let addr = match (config.endpoint.clone(), config.dst_port)
+    fn create_endpoint(config: &ConfigRouter) -> Atomic<SockAddr> {
+        match (config.endpoint.clone(), config.dst_port)
             .to_socket_addrs()
             .unwrap_or_default()
             .filter(|a| match config.family {
@@ -350,9 +349,7 @@ impl Router {
         {
             None => Atomic::null(),
             Some(addr) => Atomic::new(addr.into()),
-        };
-
-        Arc::new(addr)
+        }
     }
 
     pub fn new(config: ConfigRouter, local_id: u8) -> Result<Router> {
@@ -360,8 +357,8 @@ impl Router {
             secret: Self::create_secret(config.remote_secret.as_str())?,
             tun: Self::create_tun_device(&config)?,
             endpoint: Self::create_endpoint(&config),
-            socket: Arc::new(Self::create_socket(&config, local_id)?),
-            tcp_listener_connection: Arc::new(Atomic::null()),
+            socket: Self::create_socket(&config, local_id)?,
+            tcp_listener_connection: Atomic::null(),
             config,
         };