clean

config/config.json

-{
-  "id": 99,
-  "server": "43.142.53.161:500",
-  "port": 495,
-  "timeout": 10,
-  "history": 100,
-  "interval": 1000,
-  "table": 2000,
-  "proto": 250
-}

rustfmt.toml

+max_width = 180
\ No newline at end of file

src/connection.rs

@@ -2,12 +2,12 @@ use serde_derive::Deserialize;
 
 #[derive(Deserialize)]
 pub(crate) struct Connection {
-    pub metric: u32,
-    pub protocol: Schema,
-}
-#[derive(Deserialize)]
-pub(crate) enum Schema {
-    IP,
-    UDP,
-    TCP,
+    // pub metric: u32,
+    // pub protocol: Schema,
 }
+// #[derive(Deserialize)]
+// pub(crate) enum Schema {
+//     IP,
+//     UDP,
+//     TCP,
+// }

src/data.rs

 use serde::Deserialize;
-use std::collections::HashSet;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Router {
     pub id: u8,
-    pub name: String,
-    pub address: String,
-    pub location: String,
-    pub user: String,
-    pub host: String,
-    pub ssh_port: u16,
-    pub ssh_system: Option<u16>,
-    pub next_mark: u16,
-    pub dest_mark: u16,
-    pub port: u16,
-    pub port2: u16,
-    pub wg_private_key: Option<String>,
-    pub masq_interfaces: Vec<String>,
-    pub os: String,
-    pub arch: String,
-    pub ocserv_port: u16,
-    pub offset: u16,
-    pub offset2: u16,
+    // pub name: String,
+    // pub address: String,
+    // pub location: String,
+    // pub user: String,
+    // pub host: String,
+    // pub ssh_port: u16,
+    // pub ssh_system: Option<u16>,
+    // pub next_mark: u16,
+    // pub dest_mark: u16,
+    // pub port: u16,
+    // pub port2: u16,
+    // pub wg_private_key: Option<String>,
+    // pub masq_interfaces: Vec<String>,
+    // pub os: String,
+    // pub arch: String,
+    // pub ocserv_port: u16,
+    // pub offset: u16,
+    // pub offset2: u16,
 }
 
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GatewayGroup {
-    pub id: u16,
-    pub name: String,
-    pub description: String,
-    pub children: HashSet<String>,
-    pub dest_mark: u16,
-    pub location_prefix: Vec<String>,
-    pub include_routers: HashSet<String>,
-    pub exclude_routers: HashSet<String>,
-}
+// #[derive(Deserialize)]
+// #[serde(rename_all = "camelCase")]
+// pub struct GatewayGroup {
+//     pub id: u16,
+//     pub name: String,
+//     pub description: String,
+//     pub children: HashSet<String>,
+//     pub dest_mark: u16,
+//     pub location_prefix: Vec<String>,
+//     pub include_routers: HashSet<String>,
+//     pub exclude_routers: HashSet<String>,
+// }

src/gateway_group.rs

-use std::collections::{HashMap, HashSet};
-
-use crate::data::{GatewayGroup, Router};
-
-impl GatewayGroup {
-    pub fn routers(&self, groups: &[GatewayGroup], routers: &[Router]) -> HashSet<u8> {
-        routers
-            .iter()
-            .filter(|r| self.include_routers.contains(&r.name))
-            .chain(
-                self.location_prefix
-                    .iter()
-                    .flat_map(|p| routers.iter().filter(move |r| r.location.starts_with(p))),
-            )
-            .filter(|r| !self.exclude_routers.contains(&r.name))
-            .map(|r| r.id)
-            .chain(
-                groups
-                    .iter()
-                    .filter(|g| self.children.contains(&g.name))
-                    .flat_map(|g1| g1.routers(groups, routers)),
-            )
-            .collect()
-    }
-}
+// use std::collections::HashSet;
+//
+// use crate::data::{GatewayGroup, Router};
+//
+// impl GatewayGroup {
+//     pub fn routers(&self, groups: &[GatewayGroup], routers: &[Router]) -> HashSet<u8> {
+//         routers
+//             .iter()
+//             .filter(|r| self.include_routers.contains(&r.name))
+//             .chain(
+//                 self.location_prefix
+//                     .iter()
+//                     .flat_map(|p| routers.iter().filter(move |r| r.location.starts_with(p))),
+//             )
+//             .filter(|r| !self.exclude_routers.contains(&r.name))
+//             .map(|r| r.id)
+//             .chain(
+//                 groups
+//                     .iter()
+//                     .filter(|g| self.children.contains(&g.name))
+//                     .flat_map(|g1| g1.routers(groups, routers)),
+//             )
+//             .collect()
+//     }
+// }

src/main.rs

@@ -7,7 +7,6 @@ use crate::settings::{Settings, INTERVAL};
 use config::Config;
 use std::collections::HashMap;
 use std::fs;
-use std::net::{IpAddr, Ipv6Addr, SocketAddr};
 use std::time::SystemTime;
 use tokio::net::UdpSocket;
 use tokio::time;
@@ -23,20 +22,10 @@ mod settings;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    let config: Settings = Config::builder()
-        .add_source(config::File::with_name("config/config.json"))
-        .add_source(config::Environment::with_prefix("RAILGUN"))
-        .build()?
-        .try_deserialize()?;
+    let config: Settings = Config::builder().add_source(config::Environment::default()).build()?.try_deserialize()?;
     let routers_data = serde_json::from_slice::<Vec<RouterData>>(&fs::read("import/Router.json")?)?;
-    let mut routers: HashMap<u8, Router> = routers_data
-        .iter()
-        .map(|r| (r.id, Router::new(r, &config)))
-        .collect();
-
-    let connections = serde_json::from_slice::<HashMap<u8, HashMap<u8, Connection>>>(&fs::read(
-        "import/connections.json",
-    )?)?;
+    let mut routers: HashMap<u8, Router> = routers_data.iter().map(|r| (r.id, Router::new(r, &config))).collect();
+    let connections = serde_json::from_slice::<HashMap<u8, HashMap<u8, Connection>>>(&fs::read("import/connections.json")?)?;
     // let groups: Vec<GatewayGroup> = serde_json::from_slice(&fs::read("import/GatewayGroup.json")?)?;
 
     let mut server = Server::new(
@@ -49,31 +38,32 @@ async fn main() -> anyhow::Result<()> {
 
     let mut hello = Hello { time: 0 };
 
-    let socket = UdpSocket::bind(SocketAddr::new(
-        IpAddr::V6(Ipv6Addr::UNSPECIFIED),
-        config.port,
-    ))
-    .await?;
+    let socket = UdpSocket::bind(config.bind).await?;
 
     let mut timer = time::interval(INTERVAL);
     let mut buf = [0; 1500];
 
+    let mut syn: bool = true;
+
     loop {
         tokio::select! {
             biased; // 优先处理上面的
 
-            Ok((len, src)) = socket.recv_from(&mut buf) => {
+            result = socket.recv_from(&mut buf) => {
+                let (len, src) = result?;
                 if src == config.server {
                     // from server
                     let (message, _): (Change, usize) = bincode::decode_from_slice(&buf[..len], bincode::config::standard())?;
-                    server.on_message(&socket, &message, &mut routers, &hello);
+                    server.on_message(&message);
                     let report = Report {
                         id: config.id,
+                        syn: message.rst,
                         ack: server.ack,
                         peers: Vec::new()
                     };
                     let message = bincode::encode_to_vec(&report, bincode::config::standard())?;
-                    let _ = socket.send_to(message.as_slice(), config.server);
+                    let _ = socket.send_to(message.as_slice(), config.server).await;
+                    syn = false;
                 } else if let Some(peer) = Router::get(&mut routers, src){
                     // from client
                     let (message, _): (Hello, usize) = bincode::decode_from_slice(&buf[..len], bincode::config::standard())?;
@@ -87,12 +77,13 @@ async fn main() -> anyhow::Result<()> {
                 let message = bincode::encode_to_vec(&hello, bincode::config::standard())?;
                 for id in connections[&config.id].keys() {
                     let router = &routers[id];
-                    let _ = socket.send_to(message.as_slice(), router.link_address);
+                    let _ = socket.send_to(message.as_slice(), router.link_address).await;
                 }
 
                 // to server
                 let report = Report {
                     id: config.id,
+                    syn,
                     ack: server.ack,
                     peers: connections
                         .iter()
@@ -101,7 +92,7 @@ async fn main() -> anyhow::Result<()> {
                         .collect(),
                 };
                 let message = bincode::encode_to_vec(&report, bincode::config::standard())?;
-                let _ = socket.send_to(message.as_slice(), config.server);
+                let _ = socket.send_to(message.as_slice(), config.server).await;
             }
         }
     }

src/protocol.rs

+use std::collections::BTreeMap;
 use bincode::{Decode, Encode};
 
 #[derive(Encode, Decode)]
@@ -9,6 +10,7 @@ pub struct Hello {
 pub struct Report {
     pub id: u8,
     pub ack: u8,
+    pub syn: bool,
     pub peers: Vec<PeerQuality>,
 }
 
@@ -22,6 +24,7 @@ pub struct PeerQuality {
 #[derive(Encode, Decode)]
 pub struct Change {
     pub seq: u8,
-    pub via: Vec<(u8, u8)>,
-    pub plan: Vec<(u8, u8)>,
+    pub rst: bool,
+    pub via: BTreeMap<u8, u8>,
+    pub plan: BTreeMap<u8, BTreeMap<u8, u8>>,
 }

src/route_writer.rs

-use rtnetlink::{new_connection, Error, Handle};
-use std::collections::HashMap;
-
+// use rtnetlink::{new_connection, Error, Handle};
+// use std::collections::HashMap;
+// 
 // struct RouteWriter {
 //     via: HashMap<u8, u8>,
 //     plan: HashMap<u16, u8>,

src/router.rs

@@ -27,8 +27,8 @@ impl Router {
     pub fn new(data: &RouterData, config: &Settings) -> Router {
         Router {
             link_address: SocketAddr::new(
-                IpAddr::from([169, 254, data.id, config.id]),
-                config.port,
+                IpAddr::from([10, 200, data.id, config.id]),
+                config.bind.port(),
             ),
             quality: PeerQuality {
                 reliability: 0,
@@ -79,7 +79,7 @@ impl Router {
 
         self.history.push(Some(delay));
 
-        if (self.history.len() > HISTORY as usize) {
+        if self.history.len() > HISTORY as usize {
             self.history.drain(0..self.history.len() - HISTORY as usize);
         }
 

src/server.rs

-use std::collections::{HashMap, HashSet};
-
-use tokio::net::UdpSocket;
-
-use crate::protocol::{Change, Hello, Report};
-use crate::router::Router;
+use crate::protocol::Change;
 
 pub struct Server {
     pub(crate) ack: u8,
@@ -16,45 +11,35 @@ impl Server {
 
     pub fn on_message(
         &mut self,
-        socket: &UdpSocket,
         message: &Change,
-        routers: &mut HashMap<u8, Router>,
-        self_peer: &Hello,
+        // routers: &mut HashMap<u8, Router>,
+        // self_peer: &Hello,
     ) {
-        if message.seq == 0 {
-            self.ack = 0;
+        if message.rst {
+            self.ack = message.seq;
             // RouteWriter::reset();
         }
 
         if self.ack != message.seq {
-            println!(
-                "seq mismatch rejected, server seq={}, local ack={}",
-                message.seq, self.ack
-            );
+            println!("server seq={}, local ack={}", message.seq, self.ack);
             return;
         }
 
-        for (to, via) in message.via.iter() {
-            // RouteWriter::set_via(*to, *via);
-        }
+        // for (to, via) in message.via.iter() {
+        // RouteWriter::set_via(*to, *via);
+        // }
 
         // if let Some(plan) = message.plan.as_ref() {
-        for (group_id, to) in message.plan.iter() {
-            // RouteWriter::set_plan(&GatewayGroup::all()[*group_id], *to);
-        }
+        // for (group_id, to) in message.plan.iter() {
+        // RouteWriter::set_plan(&GatewayGroup::all()[*group_id], *to);
+        // }
         // }
 
         // RouteWriter::commit();
         self.ack += 1;
-        self.update(socket, routers, self_peer);
+        // self.update(socket, routers, self_peer);
     }
 
-    pub fn update(
-        &mut self,
-        socket: &UdpSocket,
-        routers: &mut HashMap<u8, Router>,
-        hello: &Hello,
-    ) {
-
-    }
+    // pub fn update(&mut self, socket: &UdpSocket, routers: &mut HashMap<u8, Router>, hello: &Hello) {
+    // }
 }

src/settings.rs

+use serde::Deserialize;
 use std::net::SocketAddr;
 use std::time::Duration;
-use config::Config;
-use serde::Deserialize;
-use tokio::time;
 
 #[derive(Deserialize)]
 pub struct Settings {
     pub id: u8,
     pub server: SocketAddr,
-    pub port: u16,
+    pub bind: SocketAddr,
     // pub TIMEOUT: u32,
     // pub history: usize,
     // pub INTERVAL: u64,