feat: add self info to get status

Author: ICKelin

src/client/http/models.rs

@@ -5,12 +5,27 @@ use serde::Serialize;
 /// Complete status response structure
 #[derive(Serialize, Debug, Clone)]
 pub struct StatusResponse {
+    pub self_info: Option<SelfInfo>,
     pub traffic: TrafficStats,
     pub relay: RelayStatusInfo,
     pub p2p: P2PStatus,
     pub cluster_peers: Vec<ClusterPeerInfo>,
 }
 
+/// Self/client information
+#[derive(Serialize, Debug, Clone)]
+pub struct SelfInfo {
+    pub identity: String,
+    pub private_ip: String,
+    pub mask: String,
+    pub gateway: String,
+    pub ciders: Vec<String>,
+    pub ipv6: String,
+    pub port: u16,
+    pub stun_ip: String,
+    pub stun_port: u16,
+}
+
 /// Traffic statistics
 #[derive(Serialize, Debug, Clone)]
 pub struct TrafficStats {

src/client/prettylog.rs

@@ -177,6 +177,9 @@ pub async fn build_status_response(
     peer: Option<&PeerHandler>,
     dev: &DeviceHandler,
 ) -> StatusResponse {
+    // Self information from relay
+    let self_info = relay.get_self_info().await;
+    
     // Traffic stats
     let traffic = TrafficStats {
         receive_bytes: dev.tx_bytes as u64,
@@ -290,6 +293,7 @@ pub async fn build_status_response(
         .collect();
 
     StatusResponse {
+        self_info,
         traffic,
         relay,
         p2p,

src/client/relay.rs

@@ -1,12 +1,13 @@
 use crate::client::Args;
 use crate::client::prettylog::log_handshake_success;
+use crate::client::http::SelfInfo;
 use crate::codec::frame::{Frame, HandshakeFrame, HandshakeReplyFrame, KeepAliveFrame};
 use crate::crypto::Block;
 use crate::network::{create_connection, Connection, ConnectionConfig, TCPConnectionConfig};
 use crate::utils;
 use std::sync::Arc;
 use std::time::Instant;
-use tokio::sync::mpsc;
+use tokio::sync::{mpsc, RwLock};
 use tokio::time::{Duration, interval};
 
 const OUTBOUND_BUFFER_SIZE: usize = 1000;
@@ -211,6 +212,9 @@ pub struct RelayHandler {
     inbound_tx: mpsc::Sender<Frame>,
     block: Arc<Box<dyn Block>>,
     metrics: RelayStatus,
+    // Self information
+    config: Option<RelayClientConfig>,
+    handshake_reply: Arc<RwLock<Option<HandshakeReplyFrame>>>,
 }
 
 impl RelayHandler {
@@ -222,11 +226,37 @@ impl RelayHandler {
             inbound_tx,
             block,
             metrics: Default::default(),
+            config: None,
+            handshake_reply: Arc::new(RwLock::new(None)),
+        }
+    }
+    
+    /// Get self information
+    pub async fn get_self_info(&self) -> Option<SelfInfo> {
+        let reply_guard = self.handshake_reply.read().await;
+        match (&self.config, reply_guard.as_ref()) {
+            (Some(cfg), Some(reply)) => {
+                Some(SelfInfo {
+                    identity: cfg.identity.clone(),
+                    private_ip: reply.private_ip.clone(),
+                    mask: reply.mask.clone(),
+                    gateway: reply.gateway.clone(),
+                    ciders: reply.ciders.clone(),
+                    ipv6: cfg.ipv6.clone(),
+                    port: cfg.port,
+                    stun_ip: cfg.stun_ip.clone(),
+                    stun_port: cfg.stun_port,
+                })
+            }
+            _ => None,
         }
     }
 
     pub fn run_client(&mut self, cfg: RelayClientConfig,
                       on_ready: mpsc::Sender<HandshakeReplyFrame>) {
+        // Store config
+        self.config = Some(cfg.clone());
+        
         let (outbound_tx, outbound_rx) = mpsc::channel(cfg.outbound_buffer_size);
         let mut client = RelayClient::new(
             cfg.clone(),
@@ -235,6 +265,9 @@ impl RelayHandler {
             self.block.clone(),
         );
         self.outbound_tx = Some(outbound_tx);
+        
+        // Store handshake reply when received
+        let handshake_reply = self.handshake_reply.clone();
 
         tokio::spawn(async move {
             loop {
@@ -258,6 +291,12 @@ impl RelayHandler {
 
                 tracing::info!("Handshake complete with {} peers", frame.peer_details.len());
 
+                // Store handshake reply in handler
+                {
+                    let mut guard = handshake_reply.write().await;
+                    *guard = Some(frame.clone());
+                }
+                
                 if let Err(e) = on_ready.send(frame.clone()).await {
                     tracing::error!("on ready send fail: {}", e);
                 }

src/codec/frame.rs

@@ -153,6 +153,9 @@ pub struct HandshakeReplyFrame {
     /// Used for routing traffic within the VPN
     pub gateway: String,
 
+    /// ciders to me
+    pub(crate) ciders: Vec<String>,
+
     /// List of other peers in the same cluster
     ///
     /// Each PeerDetail contains routing information for a peer node,

src/codec/parser.rs

@@ -41,6 +41,7 @@ impl Parser {
         let payload_size = u16::from_be_bytes([buf[6], buf[7]]);
 
         if !Self::validate(magic, version, payload_size, buf) {
+            tracing::warn!("validate header fail: magic = {} version={} payload_size={} buf size={}", magic, version, payload_size, buf.len());
             return Err(FrameError::Invalid.into());
         }
 

src/server/server.rs

@@ -144,6 +144,7 @@ impl Handler {
                 private_ip: client_config.private_ip.clone(),
                 mask: client_config.mask.clone(),
                 gateway: client_config.gateway.clone(),
+                ciders: client_config.ciders.clone(),
                 peer_details: route_items,
             }))
             .await?;