Struct UdpListener 

pub struct UdpListener { /* private fields */ }

An I/O object representing a UDP socket listening for incoming connections.

This object can be converted into a stream of incoming connections for various forms of processing.

Implementations

impl UdpListener

pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<Self, Error>

Usage is exactly the same as tokio::net::TcpListener::bind

Examples found in repository

examples/udp_datagram_echo.rs (line 6)

async fn main() -> Result<()> {
    let listener = UdpListener::bind("127.0.0.1:9000").await?;
    println!("udp datagram echo server listening on 127.0.0.1:9000");

    loop {
        let (stream, addr) = listener.accept().await?;
        println!("accepted udp peer: {addr}");

        tokio::spawn(async move {
            let (mut reader, writer) = stream.split();
            loop {
                let msg = match reader.recv_datagram().await {
                    Ok(msg) => msg,
                    Err(err) => {
                        println!("recv_datagram error: {err}");
                        return;
                    }
                };
                if let Err(err) = writer.send_datagram(&msg).await {
                    println!("send_datagram error: {err}");
                    return;
                }
            }
        });
    }
}

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local address that this socket is bound to.

pub async fn accept(&self) -> Result<(UdpStream, SocketAddr)>

Accepts a new incoming UDP connection.

Examples found in repository

examples/udp_datagram_echo.rs (line 10)

async fn main() -> Result<()> {
    let listener = UdpListener::bind("127.0.0.1:9000").await?;
    println!("udp datagram echo server listening on 127.0.0.1:9000");

    loop {
        let (stream, addr) = listener.accept().await?;
        println!("accepted udp peer: {addr}");

        tokio::spawn(async move {
            let (mut reader, writer) = stream.split();
            loop {
                let msg = match reader.recv_datagram().await {
                    Ok(msg) => msg,
                    Err(err) => {
                        println!("recv_datagram error: {err}");
                        return;
                    }
                };
                if let Err(err) = writer.send_datagram(&msg).await {
                    println!("send_datagram error: {err}");
                    return;
                }
            }
        });
    }
}

Trait Implementations

impl Drop for UdpListener

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.