rust udp编程方法的具体使用

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // 绑定到本地地址和端口
    let socket = UdpSocket::bind("127.0.0.1:34254")?;
    println!("UDP socket created and bound to 127.0.0.1:34254");
    Ok(())
}

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

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:34254")?;

    // 发送数据到目标地址
    let dest_addr: SocketAddr = "127.0.0.1:34254".parse().unwrap();
    socket.send_to(b"Hello from Rust!", &dest_addr)?;

    // 接收数据（缓冲区大小为1024字节）
    let mut buf = [0; 1024];
    let (number_of_bytes, src_addr) = socket.recv_from(&mut buf)?;
    let received_data = &buf[..number_of_bytes];
    //将字节转换为字符串
    //String::from_utf8_lossy的作用是尽可能地将无效的字节序列转换为有效的Unicode字符，以便进行后续处理。
    let received_data = String::from_utf8_lossy(received_data);

    println!("Received {} bytes from {}: {:?}", number_of_bytes, src_addr, received_data);

    Ok(())
}

//UDP服务端
use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:8080")?;
    println!("UDP server running on 127.0.0.1:8080");

    let mut buf = [0u8; 1024];

    //循环接收数据
    loop {
        let (size, src) = socket.recv_from(&mut buf)?;
        let received = String::from_utf8_lossy(&buf[..size]);
        println!("Received from {}: {}", src, received);

        //发送响应
        let response = format!("Echo: {}", received);
        socket.send_to(response.as_bytes(), &src)?;
    }
}

//UDP客户端
use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // 创建UDP套接字并连接到服务器
    //:0表示动态端口
    let socket = UdpSocket::bind("0.0.0.0:0")?; // 动态端口
    //连接到服务器
    socket.connect("127.0.0.1:8080")?;

    // 发送数据到服务器
    let message = "Hello, server!";
    //使用send发送数据到服务器
    socket.send(message.as_bytes())?;

    // 接收服务器的响应
    let mut buf = [0u8; 1024];
    //使用recv接收服务器的响应
    let size = socket.recv(&mut buf)?;
    let response = String::from_utf8_lossy(&buf[..size]);

    println!("Response from server: {}", response);
    Ok(())
}

use std::net::{UdpSocket, SocketAddr};
use std::time::Duration;

fn configure_socket() -> std::io::Result<UdpSocket> {
    let socket = UdpSocket::bind("127.0.0.1:0")?;
    
    // 设置读取超时
    socket.set_read_timeout(Some(Duration::from_secs(1)))?;
    
    // 设置写入超时
    socket.set_write_timeout(Some(Duration::from_secs(1)))?;
    
    // 设置广播权限
    socket.set_broadcast(true)?;
    
    // 设置接收缓冲区大小
    socket.set_recv_buffer_size(1024 * 1024)?; // 1MB
    
    // 设置发送缓冲区大小
    socket.set_send_buffer_size(1024 * 1024)?; // 1MB
    
    Ok(socket)
}

use std::net::{UdpSocket, SocketAddrV4, Ipv4Addr};

fn broadcast_example() -> std::io::Result<()> {
    let socket = UdpSocket::bind("0.0.0.0:34254")?;
    socket.set_broadcast(true)?;
    
    // 广播地址是特定子网的广播地址或255.255.255.255
    let broadcast_addr = SocketAddrV4::new(Ipv4Addr::new(255, 255, 255, 255), 8080);
    
    // 发送广播消息
    socket.send_to(b"Hello broadcast world!", &broadcast_addr)?;
    
    Ok(())
}

use std::net::{UdpSocket, Ipv4Addr, SocketAddrV4};

fn multicast_example() -> std::io::Result<()> {
    let socket = UdpSocket::bind("0.0.0.0:34254")?;
    
    // 加入多播组
    let multi_addr = Ipv4Addr::new(224, 0, 0, 123);
    let interface = Ipv4Addr::new(0, 0, 0, 0);
    socket.join_multicast_v4(&multi_addr, &interface)?;
    
    // 发送到多播组
    let multi_sock_addr = SocketAddrV4::new(multi_addr, 8080);
    socket.send_to(b"Hello multicast world!", &multi_sock_addr)?;
    
    // 接收多播消息
    let mut buf = [0; 1024];
    let (size, src) = socket.recv_from(&mut buf)?;
    println!("Received {} bytes from {}: {:?}", size, src, &buf[..size]);
    
    // 离开多播组
    socket.leave_multicast_v4(&multi_addr, &interface)?;
    
    Ok(())
}