如何让同一局域网内两个Rust编写的HTTP服务器互相发现？

一、最优方案：UDP广播/多播 #

你的遍历扫描思路可行，但效率低且容易触发网络安全机制。局域网内设备发现的首选方案是UDP广播：客户端发送广播包到局域网特定端口，目标服务器监听该端口，收到广播后主动回复自身IP，无需逐个扫描。

Rust实现示例 #

服务器端（监听广播并回复）

use std::net::{UdpSocket, SocketAddr};
use std::str;

fn main() -> std::io::Result<()> {
    // 绑定到所有接口的目标端口
    let socket = UdpSocket::bind("0.0.0.0:8080")?;
    socket.set_broadcast(true)?;

    let mut buf = [0; 1024];
    loop {
        let (_, src_addr) = socket.recv_from(&mut buf)?;
        let msg = str::from_utf8(&buf).unwrap_or("");
        
        // 验证发现请求标识
        if msg.trim() == "DISCOVER_TARGET_SERVER" {
            // 获取自身局域网IP（可根据实际网络环境调整）
            let local_ip = socket.local_addr()?.ip();
            socket.send_to(local_ip.to_string().as_bytes(), src_addr)?;
            println!("Sent IP to client: {}", src_addr);
        }
    }
}

客户端（发送广播并接收回复）

use std::net::{UdpSocket, SocketAddr};
use std::str;

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("0.0.0.0:0")?;
    socket.set_broadcast(true)?;
    
    // 替换为你的局域网广播地址（比如192.168.0.255/10.0.0.255）
    let broadcast_addr = "192.168.1.255:8080";
    socket.send_to(b"DISCOVER_TARGET_SERVER", broadcast_addr)?;

    let mut buf = [0; 1024];
    socket.set_read_timeout(Some(std::time::Duration::from_secs(5)))?;
    
    match socket.recv_from(&mut buf) {
        Ok((len, _)) => {
            let server_ip = str::from_utf8(&buf[..len]).unwrap();
            println!("Found target server at: {}", server_ip);
        }
        Err(e) => println!("No server responded within timeout: {}", e),
    }
    Ok(())
}

二、备选方案：网段遍历扫描 #

如果无法使用UDP广播，可通过遍历局域网网段实现，建议用异步请求提升效率。

1. 获取本机局域网网段 #

依赖ipnetwork和local-ip-address crate简化网段计算，先在Cargo.toml中添加：

[dependencies]
ipnetwork = "0.20.0"
local-ip-address = "0.5.4"
tokio = { version = "1.0", features = ["full"] }

获取网段的代码：

use local_ip_address::local_ip;
use ipnetwork::Ipv4Network;
use std::net::Ipv4Addr;

fn get_local_subnet() -> Option<Ipv4Network> {
    let local_ip = local_ip().ok()?;
    let ipv4 = match local_ip {
        std::net::IpAddr::V4(ip) => ip,
        _ => return None,
    };
    // 假设子网掩码为24位（255.255.255.0），可根据实际系统配置调整
    Ipv4Network::new(ipv4, 24).ok()
}

2. 异步遍历并检测目标端口 #

use tokio::net::TcpStream;
use tokio::time::{timeout, Duration};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    let subnet = match get_local_subnet() {
        Some(s) => s,
        None => {
            println!("Failed to get local subnet");
            return;
        }
    };

    let target_port = 8080;
    let mut tasks = Vec::new();

    for ip in subnet.iter() {
        // 跳过网络地址和广播地址
        if ip == subnet.network() || ip == subnet.broadcast() {
            continue;
        }
        let addr = SocketAddr::new(ip.into(), target_port);
        
        tasks.push(tokio::spawn(async move {
            // 500ms超时连接，可根据网络调整
            match timeout(Duration::from_millis(500), TcpStream::connect(&addr)).await {
                Ok(Ok(_)) => {
                    // 可进一步发送验证请求（如特定HTTP接口）确认目标
                    println!("Found potential target at: {}", addr);
                    Some(ip)
                }
                _ => None,
            }
        }));
    }

    for task in tasks {
        if let Ok(Some(ip)) = task.await {
            println!("Confirmed target server IP: {}", ip);
        }
    }
}

方案对比 #

• UDP广播：速度快、资源占用低，是局域网设备发现的最优选择，几乎无延迟。
• 遍历扫描：适用于无法使用广播的场景，但耗时较长，可能被防火墙拦截，需搭配验证逻辑避免误判。

内容的提问来源于stack exchange，提问作者Murad