Rust多播DNS库libmdns的使用，实现局域网设备发现与服务注册的高效mDNS协议支持

libmdns是一个纯Rust实现的mDNS（RFC 6762）和DNS-SD（RFC 6763）协议库。这意味着在响应5353端口上UDP广播的DNS请求时，libmdns会广播一个DNS响应，广告你注册的服务。

该库基于tokio异步运行时构建，可以在专用线程中运行，也可以使用现有的tokio Handle来生成。

使用方式

要在项目中使用，请在Cargo.toml中添加以下依赖：

[dependencies]
libmdns = "0.9"

完整示例

以下是使用libmdns实现服务注册和设备发现的完整示例代码：

use libmdns::{Responder, Service};
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 创建mDNS响应器
    let responder = Responder::new().unwrap();
    
    // 注册一个服务
    let service = responder.register(
        "_http._tcp".to_owned(),  // 服务类型
        "My Service".to_owned(),  // 服务名称
        8080,                     // 端口号
        &["path=/"],              // 文本记录
    );

    println!("Service registered: My Service._http._tcp.local:8080");

    // 保持服务运行
    loop {
        tokio::time::sleep(Duration::from_secs(10)).await;
    }
}

设备发现示例

以下是使用libmdns进行局域网设备发现的示例代码：

use libmdns::{Responder, Service};
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 创建mDNS响应器
    let responder = Responder::new().unwrap();
    
    // 监听特定服务类型
    let browser = responder.browse("_http._tcp").unwrap();
    
    println!("Discovering _http._tcp services...");
    
    // 处理发现的服务
    while let Ok(service) = browser.recv().await {
        println!("Discovered service: {:?}", service);
    }
}

依赖要求

libmdns支持的最低Rust工具链版本是1.70.0，但在旧版本的Rust上也可能编译成功。

该库建立在tokio 1.0运行时之上。

注意事项

1. 该库最初是plietar/rust-mdns的一个分支
2. 欢迎任何形式的贡献
3. 目前没有人在积极改进它，问题可能不会立即修复
4. 如果你愿意提交Pull Request来改进项目，会尽力进行审查和合并

通过使用libmdns库，你可以轻松地在Rust中实现mDNS协议支持，实现局域网内的服务发现和注册功能。

完整示例demo

服务注册与发现整合示例

以下是一个结合服务注册和设备发现的完整示例：

use libmdns::{Responder, Service};
use std::time::Duration;
use tokio::task;

#[tokio::main]
async fn main() {
    // 创建mDNS响应器
    let responder = Responder::new().unwrap();
    
    // 服务注册任务
    let register_task = task::spawn(async move {
        // 注册一个HTTP服务
        let _service = responder.register(
            "_http._tcp".to_owned(),  // 服务类型
            "Rust mDNS Demo".to_owned(),  // 服务名称
            8080,                     // 端口号
            &["path=/api"],           // 文本记录
        );
        
        println!("[Service] Registered: Rust mDNS Demo._http._tcp.local:8080");
        
        // 保持服务注册
        loop {
            tokio::time::sleep(Duration::from_secs(10)).await;
        }
    });
    
    // 服务发现任务
    let discover_task = task::spawn(async {
        // 创建新的响应器用于发现服务
        let responder = Responder::new().unwrap();
        let browser = responder.browse("_http._tcp").unwrap();
        
        println!("[Discovery] Starting to browse for _http._tcp services...");
        
        // 持续发现服务
        while let Ok(service) = browser.recv().await {
            println!("[Discovery] Found service: {:?}", service);
        }
    });
    
    // 等待两个任务完成
    tokio::try_join!(register_task, discover_task).unwrap();
}

带自定义参数的设备发现示例

use libmdns::{Responder, Service};
use std::time::Duration;

#[tokio::main]
async fn main() {
    // 创建mDNS响应器
    let responder = Responder::new().unwrap();
    
    // 监听打印机服务
    let browser = responder.browse("_printer._tcp").unwrap();
    
    println!("Searching for printers on local network...");
    
    // 处理发现的服务，带超时设置
    loop {
        tokio::select! {
            Ok(service) = browser.recv() => {
                println!("Found printer: {:?}", service);
                // 这里可以解析服务的具体信息
                if let Some(addr) = service.addresses().next() {
                    println!("Printer IP: {}", addr);
                }
            }
            _ = tokio::time::sleep(Duration::from_secs(30)) => {
                println!("Discovery timeout reached");
                break;
            }
        }
    }
}

多服务注册示例

use libmdns::{Responder, Service};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let responder = Responder::new().unwrap();
    
    // 注册HTTP服务
    let http_service = responder.register(
        "_http._tcp".to_owned(),
        "Web Server".to_owned(),
        80,
        &["path=/", "version=1.0"],
    );
    
    // 注册自定义服务
    let custom_service = responder.register(
        "_myapp._tcp".to_owned(),
        "Rust App".to_owned(),
        3000,
        &["id=123", "secure=true"],
    );
    
    println!("Services registered:");
    println!("- Web Server._http._tcp.local:80");
    println!("- Rust App._myapp._tcp.local:3000");
    
    // 保持运行
    loop {
        tokio::time::sleep(Duration::from_secs(60)).await;
    }
}