a.0.0.6

src/net.rs

@@ -5,7 +5,7 @@ use socket2::{Domain, Protocol, Socket, Type};
 use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket as StdUdpSocket},
     sync::Arc,
-    time::Duration,
+    time::{Duration, Instant},
 };
 use tokio::{net::UdpSocket, sync::Semaphore};
 
@@ -14,16 +14,37 @@ const MAX_PROBE_BODY: usize = 8 * 1024;
 pub struct ProbeInfo {
     pub fp: String,
     pub name: String,
+    pub trusts_you: bool,
 }
 
 // ───────────────────────── Интерфейсы ─────────────────────────
-/// (ip, broadcast) всех локальных (private/link-local) IPv4-интерфейсов.
+fn is_virtual_if(name: &str) -> bool {
+    let n = name.to_ascii_lowercase();
+    n.starts_with("docker")
+        || n.starts_with("br-")
+        || n.starts_with("veth")
+        || n.starts_with("virbr")
+        || n.starts_with("vmnet")
+        || n.starts_with("vboxnet")
+}
+
+/// (ip, broadcast) всех локальных (private/link-local/CGNAT) IPv4-интерфейсов.
 pub fn lan_interfaces() -> Vec<(Ipv4Addr, Option<Ipv4Addr>)> {
     if_addrs::get_if_addrs()
         .unwrap_or_default()
         .into_iter()
         .filter_map(|i| match &i.addr {
-            if_addrs::IfAddr::V4(v4) if !i.is_loopback() && is_lan_v4(v4.ip) => Some((v4.ip, v4.broadcast)),
+            if_addrs::IfAddr::V4(v4) if !i.is_loopback() && is_lan_v4(v4.ip) => {
+                let bc = v4.broadcast.or_else(|| {
+                    let mask = u32::from(v4.netmask);
+                    if mask != 0 && mask != u32::MAX {
+                        Some(Ipv4Addr::from(u32::from(v4.ip) | !mask))
+                    } else {
+                        None
+                    }
+                });
+                Some((v4.ip, bc))
+            }
             _ => None,
         })
         .collect()
@@ -40,26 +61,62 @@ pub fn detect_lan_ip() -> Option<Ipv4Addr> {
             }
         }
     }
-    let all = lan_interfaces();
-    all.iter()
-        .map(|(ip, _)| *ip)
-        .find(|ip| !(ip.octets()[0] == 172 && ip.octets()[1] == 17)) // не docker0
-        .or_else(|| all.first().map(|(ip, _)| *ip))
+    let ifs = if_addrs::get_if_addrs().unwrap_or_default();
+    ifs.iter()
+        .filter(|i| !i.is_loopback() && !is_virtual_if(&i.name))
+        .find_map(|i| match &i.addr {
+            if_addrs::IfAddr::V4(v4) if is_lan_v4(v4.ip) => Some(v4.ip),
+            _ => None,
+        })
+        .or_else(|| lan_interfaces().first().map(|(ip, _)| *ip))
+}
+
+/// Сортирует список IP пира так, чтобы адреса из наших текущих подсетей (/24) проверялись первыми.
+pub fn prioritize_ips(ips: &[IpAddr]) -> Vec<IpAddr> {
+    let my_ips: Vec<Ipv4Addr> = lan_interfaces().into_iter().map(|(ip, _)| ip).collect();
+    let in_local_subnet = |ip: &IpAddr| match ip {
+        IpAddr::V4(v4) => {
+            let o = v4.octets();
+            my_ips.iter().any(|m| {
+                let mo = m.octets();
+                mo[0] == o[0] && mo[1] == o[1] && mo[2] == o[2]
+            })
+        }
+        IpAddr::V6(_) => false,
+    };
+    let mut out = ips.to_vec();
+    out.sort_by_key(|ip| !in_local_subnet(ip));
+    out
 }
 
 // ───────────────────────── Probe ─────────────────────────
 /// Рукопожатие с узлом. Отпечаток берём из РЕАЛЬНО предъявленного сертификата.
-pub async fn probe(state: &AppState, ip: IpAddr, port: u16) -> Result<ProbeInfo, String> {
+async fn probe_with_hint(
+    state: &AppState,
+    ip: IpAddr,
+    port: u16,
+    hint_fp: Option<&str>,
+) -> Result<ProbeInfo, String> {
+    let ip_s = ip.to_string();
+    let trust_hdr: Option<String> = {
+        let peers = state.peers.read();
+        let target = hint_fp
+            .and_then(|fp| peers.get(fp))
+            .or_else(|| peers.values().find(|p| p.ips.iter().any(|x| x == &ip_s)));
+        target.map(|p| if p.verified { p.id.clone() } else { "0".to_string() })
+    };
+
     let url = format!("https://{}:{}/p2p/info", ip, port);
-    let mut resp = state
+    let mut req = state
         .probe_client
         .get(&url)
         .header("x-node-name", pct_encode(&state.device_name))
-        .header("x-node-port", state.p2p_port.to_string())
-        .send()
-        .await
-        .map_err(|_| "узел недоступен".to_string())?;
+        .header("x-node-port", state.p2p_port.to_string());
+    if let Some(t) = &trust_hdr {
+        req = req.header("x-node-trusts", t);
+    }
 
+    let mut resp = req.send().await.map_err(|_| "узел недоступен".to_string())?;
     if !resp.status().is_success() {
         return Err(format!("узел вернул код {}", resp.status()));
     }
@@ -73,7 +130,7 @@ pub async fn probe(state: &AppState, ip: IpAddr, port: u16) -> Result<ProbeInfo,
     if resp.content_length().map_or(false, |l| l as usize > MAX_PROBE_BODY) {
         return Err("слишком большой ответ".into());
     }
-    let mut buf: Vec<u8> = Vec::new();
+    let mut buf: Vec<u8> = Vec::with_capacity(256);
     while let Some(chunk) = resp.chunk().await.map_err(|_| "ошибка чтения ответа".to_string())? {
         buf.extend_from_slice(&chunk);
         if buf.len() > MAX_PROBE_BODY {
@@ -84,23 +141,46 @@ pub async fn probe(state: &AppState, ip: IpAddr, port: u16) -> Result<ProbeInfo,
     Ok(ProbeInfo {
         fp,
         name: clean_label(v["name"].as_str().unwrap_or("Node"), 48),
+        trusts_you: v["trusts_you"].as_bool().unwrap_or(false),
     })
 }
 
+pub async fn probe(state: &AppState, ip: IpAddr, port: u16) -> Result<ProbeInfo, String> {
+    probe_with_hint(state, ip, port, None).await
+}
+
 pub async fn probe_and_register(state: &AppState, ip: IpAddr, port: u16) -> Result<ProbeInfo, String> {
-    let info = probe(state, ip, port).await?;
+    let ip_s = ip.to_string();
+    let had_ip = state
+        .peers
+        .read()
+        .values()
+        .any(|p| p.ips.iter().any(|x| x == &ip_s));
+
+    let info = probe_with_hint(state, ip, port, None).await?;
     if info.fp == state.my_fingerprint {
         return Err("это ваше собственное устройство".into());
     }
     state.upsert_peer(&info.name, ip, port, &info.fp);
+    state.set_remote_trust(&info.fp, info.trusts_you);
+
+    // Если доверенный узел объявился на новом IP, сразу сообщаем ему наш статус доверия
+    if !had_ip && state.trusted_name(&info.fp).is_some() {
+        if let Ok(info2) = probe_with_hint(state, ip, port, Some(&info.fp)).await {
+            state.set_remote_trust(&info.fp, info2.trusts_you);
+        }
+    }
     Ok(info)
 }
 
-// ───────────────────────── Ping ─────────────────────────
+// ───────────────────────── Ping и синхронизация доверия ─────────────────────────
 pub async fn ping_all_peers(state: &Arc<AppState>) {
     let Ok(_guard) = state.ping_lock.try_lock() else {
         return; // опрос уже идёт
     };
+    if let Some(ip) = detect_lan_ip() {
+        state.update_my_ip(ip);
+    }
     let targets: Vec<(String, Vec<String>, u16)> = state
         .peers
         .read()
@@ -117,11 +197,12 @@ pub async fn ping_all_peers(state: &Arc<AppState>) {
 }
 
 async fn ping_one(state: &AppState, id: &str, ips: Vec<String>, port: u16) {
-    for ip_s in ips {
-        let Ok(ip) = ip_s.parse::<IpAddr>() else { continue };
-        if let Ok(info) = probe(state, ip, port).await {
+    let parsed: Vec<IpAddr> = ips.iter().filter_map(|s| s.parse().ok()).collect();
+    for ip in prioritize_ips(&parsed) {
+        if let Ok(info) = probe_with_hint(state, ip, port, Some(id)).await {
             if info.fp == id {
                 state.upsert_peer(&info.name, ip, port, id);
+                state.set_remote_trust(id, info.trusts_you);
                 return;
             }
             // по этому адресу теперь другое устройство — игнорируем
@@ -135,6 +216,44 @@ async fn ping_one(state: &AppState, id: &str, ips: Vec<String>, port: u16) {
     }
 }
 
+/// Мгновенно отправляет обновлённый статус доверия пиру и обновляет его `trusts_me`.
+pub async fn push_trust(state: &AppState, id: &str) {
+    let Some((ips, port)) = state
+        .peers
+        .read()
+        .get(id)
+        .map(|p| (p.ips.clone(), p.port))
+    else {
+        return;
+    };
+    ping_one(state, id, ips, port).await;
+}
+
+/// Возвращает рабочий IP пира (для потоковой отправки файлов при возможной смене подсети).
+pub async fn select_peer_ip(state: &AppState, id: &str) -> Option<(IpAddr, u16)> {
+    let (ips, port, fresh) = {
+        let peers = state.peers.read();
+        let p = peers.get(id)?;
+        let parsed: Vec<IpAddr> = p.ips.iter().filter_map(|s| s.parse().ok()).collect();
+        let fresh = p.online && now_sec().saturating_sub(p.last_seen) < 5;
+        (parsed, p.port, fresh)
+    };
+    let ordered = prioritize_ips(&ips);
+    if fresh && ordered.first() == ips.first() {
+        return ordered.first().copied().map(|ip| (ip, port));
+    }
+    for ip in &ordered {
+        if let Ok(info) = probe_with_hint(state, *ip, port, Some(id)).await {
+            if info.fp == id {
+                state.upsert_peer(&info.name, *ip, port, id);
+                state.set_remote_trust(id, info.trusts_you);
+                return Some((*ip, port));
+            }
+        }
+    }
+    ordered.first().copied().map(|ip| (ip, port))
+}
+
 // ───────────────────────── Сканер ─────────────────────────
 pub async fn run_scan(state: Arc<AppState>, ips: Vec<Ipv4Addr>, port: u16) {
     let st = &state;
@@ -165,6 +284,22 @@ struct Beacon {
     fp: String,
 }
 
+fn broadcast_targets() -> Vec<Ipv4Addr> {
+    let mut targets: Vec<Ipv4Addr> = lan_interfaces()
+        .into_iter()
+        .map(|(ip, bc)| {
+            bc.unwrap_or_else(|| {
+                let o = ip.octets();
+                Ipv4Addr::new(o[0], o[1], o[2], 255)
+            })
+        })
+        .collect();
+    targets.push(Ipv4Addr::BROADCAST);
+    targets.sort();
+    targets.dedup();
+    targets
+}
+
 fn bind_discovery_socket() -> std::io::Result<UdpSocket> {
     let socket = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?;
     socket.set_reuse_address(true)?;
@@ -176,7 +311,9 @@ fn bind_discovery_socket() -> std::io::Result<UdpSocket> {
 }
 
 pub fn start_discovery(state: Arc<AppState>) {
-    // отправка
+    let serving = state.log_stdout;
+
+    // Отправка маяков (в режиме serve — периодическая + отслеживание смены сети; в CLI — разовый запрос port=0)
     let tx = state.clone();
     tokio::spawn(async move {
         let sock = match UdpSocket::bind("0.0.0.0:0").await {
@@ -189,26 +326,33 @@ pub fn start_discovery(state: Arc<AppState>) {
         let _ = sock.set_broadcast(true);
         let pkt = serde_json::to_vec(&Beacon {
             v: 1,
-            port: tx.p2p_port,
+            port: if serving { tx.p2p_port } else { 0 },
             fp: tx.my_fingerprint.clone(),
         })
         .unwrap_or_default();
 
+        if !serving {
+            for t in broadcast_targets() {
+                let _ = sock.send_to(&pkt, SocketAddr::new(IpAddr::V4(t), DISCOVERY_PORT)).await;
+            }
+            return;
+        }
+
+        let mut last_ifs: Vec<Ipv4Addr> = Vec::new();
         loop {
-            // интерфейсы пересчитываются каждый цикл — смена сети подхватится сама
-            let mut targets: Vec<Ipv4Addr> = lan_interfaces()
-                .into_iter()
-                .map(|(ip, bc)| {
-                    bc.unwrap_or_else(|| {
-                        let o = ip.octets();
-                        Ipv4Addr::new(o[0], o[1], o[2], 255)
-                    })
-                })
-                .collect();
-            targets.push(Ipv4Addr::BROADCAST);
-            targets.sort();
-            targets.dedup();
-            for t in targets {
+            let cur_ifs: Vec<Ipv4Addr> = lan_interfaces().into_iter().map(|(ip, _)| ip).collect();
+            if cur_ifs != last_ifs {
+                if let Some(ip) = detect_lan_ip() {
+                    if tx.update_my_ip(ip) {
+                        tx.add_log(format!("Смена сети: активный адрес {}", ip));
+                    }
+                }
+                tx.probe_cooldown.lock().clear();
+                tx.ping_notify.notify_one();
+                last_ifs = cur_ifs;
+            }
+
+            for t in broadcast_targets() {
                 let _ = sock
                     .send_to(&pkt, SocketAddr::new(IpAddr::V4(t), DISCOVERY_PORT))
                     .await;
@@ -217,7 +361,7 @@ pub fn start_discovery(state: Arc<AppState>) {
         }
     });
 
-    // приём
+    // Приём маяков
     tokio::spawn(async move {
         let socket = match bind_discovery_socket() {
             Ok(s) => s,
@@ -229,8 +373,16 @@ pub fn start_discovery(state: Arc<AppState>) {
                 return;
             }
         };
+        let reply_pkt = serde_json::to_vec(&Beacon {
+            v: 1,
+            port: state.p2p_port,
+            fp: state.my_fingerprint.clone(),
+        })
+        .unwrap_or_default();
+        let mut last_reply = Instant::now() - Duration::from_secs(2);
         let slots = Arc::new(Semaphore::new(8));
         let mut buf = [0u8; 512];
+
         loop {
             let (len, remote) = match socket.recv_from(&mut buf).await {
                 Ok(v) => v,
@@ -239,17 +391,30 @@ pub fn start_discovery(state: Arc<AppState>) {
                     continue;
                 }
             };
-            let Ok(b) = serde_json::from_slice::<Beacon>(&buf[..len]) else { continue };
-            if b.v != 1 || b.port == 0 || !is_valid_fp(&b.fp) || b.fp == state.my_fingerprint {
-                continue;
-            }
-            // адрес — только реальный адрес источника пакета
             let IpAddr::V4(ip4) = remote.ip() else { continue };
             if !is_lan_v4(ip4) {
                 continue;
             }
+            let Ok(b) = serde_json::from_slice::<Beacon>(&buf[..len]) else { continue };
+            if b.v != 1 || !is_valid_fp(&b.fp) || b.fp == state.my_fingerprint {
+                continue;
+            }
+
+            // port == 0 — запрос от CLI или нового узла; отвечаем своим маяком без ожидания 3 с
+            if b.port == 0 {
+                if serving && last_reply.elapsed() >= Duration::from_millis(500) {
+                    last_reply = Instant::now();
+                    for t in broadcast_targets() {
+                        let _ = socket
+                            .send_to(&reply_pkt, SocketAddr::new(IpAddr::V4(t), DISCOVERY_PORT))
+                            .await;
+                    }
+                }
+                continue;
+            }
+
             let ip = IpAddr::V4(ip4);
-            if state.is_fresh(&b.fp, ip) || !state.probe_allowed(ip) {
+            if state.is_fresh(&b.fp, ip, b.port) || !state.probe_allowed(ip, b.port) {
                 continue;
             }
             let Ok(permit) = slots.clone().try_acquire_owned() else { continue };