From cf08d2d53c890e9304775f26de2a71bb85741bb1 Mon Sep 17 00:00:00 2001 From: asxalex Date: Sat, 6 Jul 2024 22:58:18 +0800 Subject: [PATCH] fix stun request --- Makefile | 3 +++ src/bin/sdlan/main.rs | 31 ++++++++++++++++++++----------- src/lib.rs | 3 +++ src/network/async_main.rs | 27 ++++++++++++++++++++++++++- src/network/packet.rs | 4 +++- src/utils/command.rs | 4 ++++ 6 files changed, 59 insertions(+), 13 deletions(-) diff --git a/Makefile b/Makefile index 3e8562c..a33e48a 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,6 @@ +linux: + RUSTFLAGS="-L ." cargo build --release + pb: cargo run --bin build_pb mv src/pb/_.rs src/pb/message.rs diff --git a/src/bin/sdlan/main.rs b/src/bin/sdlan/main.rs index cf92cdf..05f6bfe 100644 --- a/src/bin/sdlan/main.rs +++ b/src/bin/sdlan/main.rs @@ -4,22 +4,31 @@ use sdlan_rs::CommandLine; use sdlan_sn_rs::log; use std::time::Duration; use tokio::sync::mpsc::Sender; +use tokio::sync::oneshot; #[tokio::main] async fn main() { let _guard = log::init_log(); - tokio::spawn(run_sdlan(CommandLine { - sn: "39.98.184.67:1265".to_owned(), - tcp: "39.98.184.67:18083".to_owned(), - _allow_routing: true, - register_ttl: 1, - mtu: 1290, - name: "tau".to_owned(), - tos: 0, - token: "".to_owned(), - })); - tokio::time::sleep(Duration::from_secs(3)).await; + let (tx, rx) = oneshot::channel(); + tokio::spawn(run_sdlan( + CommandLine { + sn: "39.98.184.67:1265".to_owned(), + tcp: "39.98.184.67:18083".to_owned(), + _allow_routing: true, + register_ttl: 1, + mtu: 1290, + name: "tau".to_owned(), + tos: 0, + token: "".to_owned(), + allow_p2p: true, + }, + tx, + )); + + // waiting edge to be inited + let _ = rx.await; + let edge = get_edge(); edge.start("0".to_owned()).await; diff --git a/src/lib.rs b/src/lib.rs index a50b7a4..f731ccc 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -23,6 +23,7 @@ use sdlan_sn_rs::{ pub async fn run_sdlan( args: CommandLine, + sender: tokio::sync::oneshot::Sender, // start_stop_sender: Sender, // start_stop_receiver: Receiver, ) -> Result<()> { @@ -33,6 +34,7 @@ pub async fn run_sdlan( if let Err(e) = init_edge(&args.token, node_conf, args.tos, start_stop_sender).await { panic!("failed to init edge: {:?}", e); } + let _ = sender.send(true); debug!("edge inited"); let cancel = CancellationToken::new(); @@ -50,6 +52,7 @@ async fn parse_config(uuid: String, args: &CommandLine) -> Result { return Err(SDLanError::NormalError("no sn is specified")); } let mut node_conf = NodeConfig::new(); + node_conf.allow_p2p = args.allow_p2p; let sns: Vec<&str> = args.sn.split(",").collect(); let mut correct_sns: Vec<_>; diff --git a/src/network/async_main.rs b/src/network/async_main.rs index 86a6d07..f228d88 100644 --- a/src/network/async_main.rs +++ b/src/network/async_main.rs @@ -65,6 +65,7 @@ async fn handle_tcp_message(msg: SdlanTcp) { edge.network_id.store(dev.network_id, Ordering::Relaxed); edge.set_authorized(true, aes); + send_stun_request(edge).await; } PacketType::RegisterSuperNAK => { let Ok(_nak) = SdlRegisterSuperNak::decode(&msg.current_packet[..]) else { @@ -223,6 +224,7 @@ pub async fn async_main( debug!("waiting for authorization..."); + /* loop { // let _ = edge.send_register_super().await; // let _ = read_and_parse_packet(edge, &edge.udp_sock_v4, Some(Duration::from_secs(3))).await; @@ -239,6 +241,7 @@ pub async fn async_main( } } } + */ { let cancel = cancel.clone(); @@ -303,6 +306,26 @@ async fn run_edge_loop(eee: &'static Node, cancel: CancellationToken) { } } +async fn send_stun_request(eee: &Node) { + let req = SdlStunRequest { + cookie: 0, + client_id: eee.config.node_uuid.clone(), + network_id: eee.network_id.load(Ordering::Relaxed), + ip: eee.device_config.get_ip(), + nat_type: 0, + }; + let msg = encode_to_udp_message(Some(req), PacketType::StunRequest as u8).unwrap(); + if let Err(e) = send_to_sock( + eee, + &msg, + &eee.config.super_nodes[eee.config.super_node_index.load(Ordering::Relaxed) as usize], + ) + .await + { + error!("failed to send to sock: {:?}", e); + } +} + async fn loop_socket_v4(eee: &Node, socket: &Socket, cancel: CancellationToken) { debug!("loop sock v4"); loop { @@ -312,6 +335,8 @@ async fn loop_socket_v4(eee: &Node, socket: &Socket, cancel: CancellationToken) } _ = read_and_parse_packet(eee, socket,Some(Duration::from_secs(10))) => { } _ = tokio::time::sleep(Duration::from_secs(10)) => { + send_stun_request(eee).await; + /* let req = SdlStunRequest { cookie: 0, client_id: eee.config.node_uuid.clone(), @@ -322,7 +347,7 @@ async fn loop_socket_v4(eee: &Node, socket: &Socket, cancel: CancellationToken) let msg = encode_to_udp_message(Some(req), PacketType::StunRequest as u8).unwrap(); if let Err(e) = send_to_sock(eee, &msg, &eee.config.super_nodes[eee.config.super_node_index.load(Ordering::Relaxed) as usize]).await { error!("failed to send to sock: {:?}", e); - } + }*/ } } } diff --git a/src/network/packet.rs b/src/network/packet.rs index 565554a..ae10baf 100644 --- a/src/network/packet.rs +++ b/src/network/packet.rs @@ -100,6 +100,8 @@ pub async fn handle_packet(eee: &Node, addr: SocketAddr, buf: &[u8]) -> Result<( let _ = handle_packet_register_ack(eee, &buf[1..], &from_sock).await; } PacketType::Data => { + let from_sock = get_sdlan_sock_from_socketaddr(addr).unwrap(); + debug!("[PPP]Rx data from {}", from_sock.to_string()); if !eee.is_authorized() { error!("dropping PACKET received before authorized"); return Ok(()); @@ -109,7 +111,7 @@ pub async fn handle_packet(eee: &Node, addr: SocketAddr, buf: &[u8]) -> Result<( error!("failed to decode to SDLData"); return Err(SDLanError::NormalError("failed to decode to SDLData")); }; - let from_sock = get_sdlan_sock_from_socketaddr(addr).unwrap(); + // let from_sock = get_sdlan_sock_from_socketaddr(addr).unwrap(); if data.is_p2p { debug!("[P2P] Rx data from {}", from_sock.to_string()); } else { diff --git a/src/utils/command.rs b/src/utils/command.rs index 1fdc85c..02ed1c8 100644 --- a/src/utils/command.rs +++ b/src/utils/command.rs @@ -29,6 +29,9 @@ pub struct CommandLine { #[structopt(long = "token", default_value = "0")] pub token: String, + + #[structopt(short = "p")] + pub allow_p2p: bool, } impl Clone for CommandLine { @@ -42,6 +45,7 @@ impl Clone for CommandLine { name: self.name.clone(), tos: self.tos, token: self.token.clone(), + allow_p2p: self.allow_p2p, } } }