remote static

src/main.rs

@@ -38,17 +38,13 @@ pub struct Config {
 }
 use crossbeam_utils::thread;
 use grouping_by::GroupingBy;
-use lazy_static::lazy_static;
 use pnet::packet::ipv4::Ipv4Packet;
 use socket2::Socket;
 
-lazy_static! {
-    static ref config: Config = serde_json::from_str(env::args().nth(0).unwrap().as_str()).unwrap();
-    static ref local_secret: [u8; SECRET_LENGTH] =
-        Router::create_secret(config.local_secret.as_str()).unwrap();
-}
-
 fn main() -> Result<(), Box<dyn Error>> {
+    let config: Config = serde_json::from_str(env::args().nth(0).ok_or("need param")?.as_str())?;
+    let local_secret: [u8; SECRET_LENGTH] = Router::create_secret(config.local_secret.as_str())?;
+
     let mut sockets: HashMap<u16, Arc<Socket>> = HashMap::new();
     let routers: HashMap<u8, Router> = config
         .routers
@@ -124,7 +120,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                         if meta.dst_id == config.local_id && meta.reversed == 0 {
                             let router = router_writers.get_mut(&meta.src_id).ok_or("missing router")?;
                             *router.endpoint.write().unwrap() = Some(addr);
-                            router.decrypt(payload);
+                            router.decrypt(payload, &local_secret);
                             router.tun_writer.write_all(payload)?;
                         }
 

src/router.rs

@@ -2,23 +2,23 @@ use socket2::{Domain, Protocol, SockAddr, Socket, Type};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::net::ToSocketAddrs;
-use std::process::Command;
+use std::process::{Command, ExitStatus};
 use std::sync::{Arc, RwLock};
 use tun::{Reader, Writer};
 pub const SECRET_LENGTH: usize = 32;
-use crate::{local_secret, ConfigRouter};
 use base64::prelude::*;
+use crate::ConfigRouter;
 
 // tun -> raw
-pub struct RouterReader {
-    pub config: &'static ConfigRouter,
+pub struct RouterReader<'a> {
+    pub config: &'a ConfigRouter,
     pub secret: [u8; SECRET_LENGTH],
     pub tun_reader: Reader,
     pub socket: Arc<Socket>,
     pub endpoint: Arc<RwLock<Option<SockAddr>>>,
 }
 
-impl RouterReader {
+impl<'a> RouterReader<'a> {
     pub(crate) fn encrypt(&self, data: &mut [u8]) {
         for (i, b) in data.iter_mut().enumerate() {
             *b ^= self.secret[i % SECRET_LENGTH];
@@ -27,16 +27,16 @@ impl RouterReader {
 }
 
 // raw -> tun
-pub struct RouterWriter {
-    pub config: &'static ConfigRouter,
+pub struct RouterWriter<'a> {
+    pub config: &'a ConfigRouter,
     pub tun_writer: Writer,
     pub endpoint: Arc<RwLock<Option<SockAddr>>>,
 }
 
-impl RouterWriter {
-    pub(crate) fn decrypt(&self, data: &mut [u8]) {
+impl<'a> RouterWriter<'a> {
+    pub(crate) fn decrypt(&self, data: &mut [u8], secret: &[u8; SECRET_LENGTH]) {
         for (i, b) in data.iter_mut().enumerate() {
-            *b ^= local_secret[i % SECRET_LENGTH];
+            *b ^= secret[i % SECRET_LENGTH];
         }
     }
 
@@ -45,8 +45,8 @@ impl RouterWriter {
     }
 }
 
-pub struct Router {
-    pub config: &'static ConfigRouter,
+pub struct Router<'a> {
+    pub config: &'a ConfigRouter,
     pub secret: [u8; SECRET_LENGTH],
     pub tun_reader: Reader,
     pub tun_writer: Writer,
@@ -54,7 +54,7 @@ pub struct Router {
     pub endpoint: Arc<RwLock<Option<SockAddr>>>,
 }
 
-impl Router {
+impl<'a> Router<'a> {
     pub(crate) fn create_secret(
         config: &str,
     ) -> Result<[u8; SECRET_LENGTH], Box<dyn std::error::Error>> {
@@ -98,9 +98,8 @@ impl Router {
         let dev = tun::create(&tun_config)?;
         Ok(dev.split())
     }
-    fn run_up_script(config: &ConfigRouter) -> Result<(), Box<dyn std::error::Error>> {
-        Command::new(config.up.as_str()).status()?;
-        Ok(())
+    fn run_up_script(config: &ConfigRouter) -> std::io::Result<ExitStatus> {
+        Command::new(config.up.as_str()).status()
     }
 
     fn create_endpoint(
@@ -111,9 +110,9 @@ impl Router {
     }
 
     pub fn new(
-        config: &'static ConfigRouter,
+        config: &'a ConfigRouter,
         sockets: &mut HashMap<u16, Arc<Socket>>,
-    ) -> Result<Router, Box<dyn std::error::Error>> {
+    ) -> Result<Router<'a>, Box<dyn std::error::Error>> {
         let secret = Self::create_secret(config.remote_secret.as_str())?;
         let endpoint = Self::create_endpoint(&config)?;
         let socket = Self::create_raw_socket(&config, sockets)?;
@@ -132,7 +131,7 @@ impl Router {
         Ok(router)
     }
 
-    pub fn split(self) -> (RouterReader, RouterWriter) {
+    pub fn split(self) -> (RouterReader<'a>, RouterWriter<'a>) {
         let writer = RouterWriter {
             config: self.config,
             endpoint: Arc::clone(&self.endpoint),