# [−] [src] Struct tokio::net::UdpSocket

    pub struct UdpSocket { /* fields omitted */ }

A UDP socket

UDP is "connectionless", unlike TCP. Meaning, regardless of what address you've bound to, a `UdpSocket` is free to communicate with many different remotes. In tokio there are basically two main ways to use `UdpSocket`:

- one to many: `bind` and use `send_to` and `recv_from` to communicate with many different addresses
- one to one: `connect` and associate with a single address, using `send` and `recv` to communicate only with that remote address

`UdpSocket` can also be used concurrently to `send_to` and `recv_from` in different tasks, all that's required is that you `Arc<UdpSocket>` and clone a reference for each task.

# Streams

If you need to listen over UDP and produce a `Stream`, you can look at `UdpFramed`.

# Example: one to many (bind)

Using `bind` we can create a simple echo server that sends and recv's with many different clients:

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let sock = UdpSocket::bind("0.0.0.0:8080").await?;
        let mut buf = [0; 1024];
        loop {
            let (len, addr) = sock.recv_from(&mut buf).await?;
            println!("{:?} bytes received from {:?}", len, addr);

            let len = sock.send_to(&buf[..len], addr).await?;
            println!("{:?} bytes sent", len);
        }
    }

# Example: one to one (connect)

Or using `connect` we can echo with a single remote address using `send` and `recv`:

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let sock = UdpSocket::bind("0.0.0.0:8080").await?;

        let remote_addr = "127.0.0.1:59611";
        sock.connect(remote_addr).await?;
        let mut buf = [0; 1024];
        loop {
            let len = sock.recv(&mut buf).await?;
            println!("{:?} bytes received from {:?}", len, remote_addr);

            let len = sock.send(&buf[..len]).await?;
            println!("{:?} bytes sent", len);
        }
    }

# Example: Sending/Receiving concurrently

Because `send_to` and `recv_from` take `&self`. It's perfectly alright to `Arc<UdpSocket>` and share the references to multiple tasks, in order to send/receive concurrently. Here is a similar "echo" example but that supports concurrent sending/receiving:

    use tokio::{net::UdpSocket, sync::mpsc};
    use std::{io, net::SocketAddr, sync::Arc};

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let sock = UdpSocket::bind("0.0.0.0:8080".parse::<SocketAddr>().unwrap()).await?;
        let r = Arc::new(sock);
        let s = r.clone();
        let (tx, mut rx) = mpsc::channel::<(Vec<u8>, SocketAddr)>(1_000);

        tokio::spawn(async move {
            while let Some((bytes, addr)) = rx.recv().await {
                let len = s.send_to(&bytes, &addr).await.unwrap();
                println!("{:?} bytes sent", len);
            }
        });

        let mut buf = [0; 1024];
        loop {
            let (len, addr) = r.recv_from(&mut buf).await?;
            println!("{:?} bytes received from {:?}", len, addr);
            tx.send((buf[..len].to_vec(), addr)).await.unwrap();
        }
    }

## Implementations

### `impl UdpSocket` [src]

#### `pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<UdpSocket>` [src]

This function will create a new UDP socket and attempt to bind it to the `addr` provided.

# Example

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let sock = UdpSocket::bind("0.0.0.0:8080").await?;
        // use `sock`
        Ok(())
    }

#### `pub fn from_std(socket: UdpSocket) -> Result<UdpSocket>` [src]

Creates new `UdpSocket` from a previously bound `std::net::UdpSocket`.

This function is intended to be used to wrap a UDP socket from the standard library in the Tokio equivalent. The conversion assumes nothing about the underlying socket; it is left up to the user to set it in non-blocking mode.

This can be used in conjunction with socket2's `Socket` interface to configure a socket before it's handed off, such as setting options like `reuse_address` or binding to multiple addresses.

# Panics

This function panics if thread-local runtime is not set.

The runtime is usually set implicitly when this function is called from a future driven by a tokio runtime, otherwise runtime can be set explicitly with `Runtime::enter` function.

# Example

    use tokio::net::UdpSocket;

    let addr = "0.0.0.0:8080".parse::<SocketAddr>().unwrap();
    let std_sock = std::net::UdpSocket::bind(addr)?;
    std_sock.set_nonblocking(true)?;
    let sock = UdpSocket::from_std(std_sock)?;
    // use `sock`

#### `pub fn local_addr(&self) -> Result<SocketAddr>` [src]

Returns the local address that this socket is bound to.

# Example

    use tokio::net::UdpSocket;

    let addr = "0.0.0.0:8080".parse::<SocketAddr>().unwrap();
    let sock = UdpSocket::bind(addr).await?;
    // the address the socket is bound to
    let local_addr = sock.local_addr()?;

#### `pub async fn connect<A: ToSocketAddrs, '_>(&'_ self, addr: A) -> Result<()>` [src]

Connects the UDP socket setting the default destination for send() and limiting packets that are read via recv from the address specified in `addr`.

# Example

    use tokio::net::UdpSocket;

    let sock = UdpSocket::bind("0.0.0.0:8080".parse::<SocketAddr>().unwrap()).await?;

    let remote_addr = "127.0.0.1:59600".parse::<SocketAddr>().unwrap();
    sock.connect(remote_addr).await?;
    let mut buf = [0u8; 32];
    // recv from remote_addr
    let len = sock.recv(&mut buf).await?;
    // send to remote_addr
    let _len = sock.send(&buf[..len]).await?;

#### `pub async fn ready<'_>(&'_ self, interest: Interest) -> Result<Ready>` [src]

Wait for any of the requested ready states.

This function is usually paired with `try_recv()` or `try_send()`. It can be used to concurrently recv / send to the same socket on a single task without splitting the socket.

The function may complete without the socket being ready. This is a false-positive and attempting an operation will return with `io::ErrorKind::WouldBlock`.

# Examples

Concurrently receive from and send to the socket on the same task without splitting.

    use tokio::io::{self, Interest};
    use tokio::net::UdpSocket;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        loop {
            let ready = socket.ready(Interest::READABLE | Interest::WRITABLE).await?;

            if ready.is_readable() {
                // The buffer is **not** included in the async task and will only exist
                // on the stack.
                let mut data = [0; 1024];
                match socket.try_recv(&mut data[..]) {
                    Ok(n) => {
                        println!("received {:?}", &data[..n]);
                    }
                    // False-positive, continue
                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                    Err(e) => {
                        return Err(e);
                    }
                }
            }

            if ready.is_writable() {
                // Write some data
                match socket.try_send(b"hello world") {
                    Ok(n) => {
                        println!("sent {} bytes", n);
                    }
                    // False-positive, continue
                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
                    Err(e) => {
                        return Err(e);
                    }
                }
            }
        }
    }

#### `pub async fn writable<'_>(&'_ self) -> Result<()>` [src]

Wait for the socket to become writable.

This function is equivalent to `ready(Interest::WRITABLE)` and is usually paired with `try_send()` or `try_send_to()`.

The function may complete without the socket being writable. This is a false-positive and attempting a `try_send()` will return with `io::ErrorKind::WouldBlock`.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Bind socket
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        loop {
            // Wait for the socket to be writable
            socket.writable().await?;

            // Try to send data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match socket.try_send(b"hello world") {
                Ok(n) => {
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e);
                }
            }
        }

        Ok(())
    }

#### `pub async fn send<'_, '_>(&'_ self, buf: &'_ [u8]) -> Result<usize>` [src]

Sends data on the socket to the remote address that the socket is connected to.

The `connect` method will connect this socket to a remote address. This method will fail if the socket is not connected.

# Return

On success, the number of bytes sent is returned, otherwise, the encountered error is returned.

# Examples

    use tokio::io;
    use tokio::net::UdpSocket;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Bind socket
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        // Send a message
        socket.send(b"hello world").await?;

        Ok(())
    }

#### `pub fn poll_send(&self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>>` [src]

Attempts to send data on the socket to the remote address to which it was previously `connect`ed.

The `connect` method will connect this socket to a remote address. This method will fail if the socket is not connected.

Note that on multiple calls to a `poll_*` method in the send direction, only the `Waker` from the `Context` passed to the most recent call will be scheduled to receive a wakeup.

# Return value

The function returns:

- `Poll::Pending` if the socket is not available to write
- `Poll::Ready(Ok(n))` `n` is the number of bytes sent
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_send(&self, buf: &[u8]) -> Result<usize>` [src]

Try to send data on the socket to the remote address to which it is connected.

When the socket buffer is full, `Err(io::ErrorKind::WouldBlock)` is returned. This function is usually paired with `writable()`.

# Returns

If successful, `Ok(n)` is returned, where `n` is the number of bytes sent. If the socket is not ready to send data, `Err(ErrorKind::WouldBlock)` is returned.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Bind a UDP socket
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;

        // Connect to a peer
        socket.connect("127.0.0.1:8081").await?;

        loop {
            // Wait for the socket to be writable
            socket.writable().await?;

            // Try to send data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match socket.try_send(b"hello world") {
                Ok(n) => {
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e);
                }
            }
        }

        Ok(())
    }

#### `pub async fn readable<'_>(&'_ self) -> Result<()>` [src]

Wait for the socket to become readable.

This function is equivalent to `ready(Interest::READABLE)` and is usually paired with `try_recv()`.

The function may complete without the socket being readable. This is a false-positive and attempting a `try_recv()` will return with `io::ErrorKind::WouldBlock`.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Connect to a peer
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        loop {
            // Wait for the socket to be readable
            socket.readable().await?;

            // The buffer is **not** included in the async task and will
            // only exist on the stack.
            let mut buf = [0; 1024];

            // Try to recv data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match socket.try_recv(&mut buf) {
                Ok(n) => {
                    println!("GOT {:?}", &buf[..n]);
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e);
                }
            }
        }

        Ok(())
    }

#### `pub async fn recv<'_, '_>(&'_ self, buf: &'_ mut [u8]) -> Result<usize>` [src]

Receives a single datagram message on the socket from the remote address to which it is connected. On success, returns the number of bytes read.

The function must be called with valid byte array `buf` of sufficient size to hold the message bytes. If a message is too long to fit in the supplied buffer, excess bytes may be discarded.

The `connect` method will connect this socket to a remote address. This method will fail if the socket is not connected.

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Bind socket
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        let mut buf = vec![0; 10];
        let n = socket.recv(&mut buf).await?;

        println!("received {} bytes {:?}", n, &buf[..n]);

        Ok(())
    }

#### `pub fn poll_recv(
&self,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>` [src]

Attempts to receive a single datagram message on the socket from the remote address to which it is `connect`ed.

The `connect` method will connect this socket to a remote address. This method resolves to an error if the socket is not connected.

Note that on multiple calls to a `poll_*` method in the recv direction, only the `Waker` from the `Context` passed to the most recent call will be scheduled to receive a wakeup.

# Return value

The function returns:

- `Poll::Pending` if the socket is not ready to read
- `Poll::Ready(Ok(()))` reads data `ReadBuf` if the socket is ready
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_recv(&self, buf: &mut [u8]) -> Result<usize>` [src]

Try to receive a single datagram message on the socket from the remote address to which it is connected. On success, returns the number of bytes read.

The function must be called with valid byte array buf of sufficient size to hold the message bytes. If a message is too long to fit in the supplied buffer, excess bytes may be discarded.

When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is returned. This function is usually paired with `readable()`.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Connect to a peer
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        loop {
            // Wait for the socket to be readable
            socket.readable().await?;

            // The buffer is **not** included in the async task and will
            // only exist on the stack.
            let mut buf = [0; 1024];

            // Try to recv data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match socket.try_recv(&mut buf) {
                Ok(n) => {
                    println!("GOT {:?}", &buf[..n]);
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e);
                }
            }
        }

        Ok(())
    }

#### `pub async fn send_to<A: ToSocketAddrs, '_, '_>(
&'_ self,
buf: &'_ [u8],
target: A
) -> Result<usize>` [src]

Sends data on the socket to the given address. On success, returns the number of bytes written.

Address type can be any implementor of `ToSocketAddrs` trait. See its documentation for concrete examples.

It is possible for `addr` to yield multiple addresses, but `send_to` will only send data to the first address yielded by `addr`.

This will return an error when the IP version of the local socket does not match that returned from `ToSocketAddrs`.

# Example

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        let len = socket.send_to(b"hello world", "127.0.0.1:8081").await?;

        println!("Sent {} bytes", len);

        Ok(())
    }

#### `pub fn poll_send_to(
&self,
cx: &mut Context<'_>,
buf: &[u8],
target: SocketAddr
) -> Poll<Result<usize>>` [src]

Attempts to send data on the socket to a given address.

Note that on multiple calls to a `poll_*` method in the send direction, only the `Waker` from the `Context` passed to the most recent call will be scheduled to receive a wakeup.

# Return value

The function returns:

- `Poll::Pending` if the socket is not ready to write
- `Poll::Ready(Ok(n))` `n` is the number of bytes sent.
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_send_to(&self, buf: &[u8], target: SocketAddr) -> Result<usize>` [src]

Try to send data on the socket to the given address, but if the send is blocked this will return right away.

This function is usually paired with `writable()`.

# Returns

If successfull, returns the number of bytes sent

Users should ensure that when the remote cannot receive, the `ErrorKind::WouldBlock` is properly handled. An error can also occur if the IP version of the socket does not match that of `target`.

# Example

    use tokio::net::UdpSocket;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;

        let dst = "127.0.0.1:8081".parse()?;

        loop {
            socket.writable().await?;

            match socket.try_send_to(&b"hello world"[..], dst) {
                Ok(sent) => {
                    println!("sent {} bytes", sent);
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    // Writable false positive.
                    continue;
                }
                Err(e) => return Err(e.into()),
            }
        }

        Ok(())
    }

#### `pub async fn recv_from<'_, '_>(
&'_ self,
buf: &'_ mut [u8]
) -> Result<(usize, SocketAddr)>` [src]

Receives a single datagram message on the socket. On success, returns the number of bytes read and the origin.

The function must be called with valid byte array `buf` of sufficient size to hold the message bytes. If a message is too long to fit in the supplied buffer, excess bytes may be discarded.

# Example

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;

        let mut buf = vec![0u8; 32];
        let (len, addr) = socket.recv_from(&mut buf).await?;

        println!("received {:?} bytes from {:?}", len, addr);

        Ok(())
    }

#### `pub fn poll_recv_from(
&self,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<SocketAddr>>` [src]

Attempts to receive a single datagram on the socket.

Note that on multiple calls to a `poll_*` method in the recv direction, only the `Waker` from the `Context` passed to the most recent call will be scheduled to receive a wakeup.

# Return value

The function returns:

- `Poll::Pending` if the socket is not ready to read
- `Poll::Ready(Ok(addr))` reads data from `addr` into `ReadBuf` if the socket is ready
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>` [src]

Try to receive a single datagram message on the socket. On success, returns the number of bytes read and the origin.

The function must be called with valid byte array buf of sufficient size to hold the message bytes. If a message is too long to fit in the supplied buffer, excess bytes may be discarded.

When there is no pending data, `Err(io::ErrorKind::WouldBlock)` is returned. This function is usually paired with `readable()`.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Connect to a peer
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;
        socket.connect("127.0.0.1:8081").await?;

        loop {
            // Wait for the socket to be readable
            socket.readable().await?;

            // The buffer is **not** included in the async task and will
            // only exist on the stack.
            let mut buf = [0; 1024];

            // Try to recv data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match socket.try_recv_from(&mut buf) {
                Ok((n, _addr)) => {
                    println!("GOT {:?}", &buf[..n]);
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e);
                }
            }
        }

        Ok(())
    }

#### `pub async fn peek_from<'_, '_>(
&'_ self,
buf: &'_ mut [u8]
) -> Result<(usize, SocketAddr)>` [src]

Receives data from the socket, without removing it from the input queue. On success, returns the number of bytes read and the address from whence the data came.

# Notes

On Windows, if the data is larger than the buffer specified, the buffer is filled with the first part of the data, and peek_from returns the error WSAEMSGSIZE(10040). The excess data is lost. Make sure to always use a sufficiently large buffer to hold the maximum UDP packet size, which can be up to 65536 bytes in size.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        let socket = UdpSocket::bind("127.0.0.1:8080").await?;

        let mut buf = vec![0u8; 32];
        let (len, addr) = socket.peek_from(&mut buf).await?;

        println!("peeked {:?} bytes from {:?}", len, addr);

        Ok(())
    }

#### `pub fn poll_peek_from(
&self,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<SocketAddr>>` [src]

Receives data from the socket, without removing it from the input queue. On success, returns the number of bytes read.

# Notes

Note that on multiple calls to a `poll_*` method in the recv direction, only the `Waker` from the `Context` passed to the most recent call will be scheduled to receive a wakeup

On Windows, if the data is larger than the buffer specified, the buffer is filled with the first part of the data, and peek returns the error WSAEMSGSIZE(10040). The excess data is lost. Make sure to always use a sufficiently large buffer to hold the maximum UDP packet size, which can be up to 65536 bytes in size.

# Return value

The function returns:

- `Poll::Pending` if the socket is not ready to read
- `Poll::Ready(Ok(addr))` reads data from `addr` into `ReadBuf` if the socket is ready
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn broadcast(&self) -> Result<bool>` [src]

Gets the value of the `SO_BROADCAST` option for this socket.

For more information about this option, see `set_broadcast`.

#### `pub fn set_broadcast(&self, on: bool) -> Result<()>` [src]

Sets the value of the `SO_BROADCAST` option for this socket.

When enabled, this socket is allowed to send packets to a broadcast address.

#### `pub fn multicast_loop_v4(&self) -> Result<bool>` [src]

Gets the value of the `IP_MULTICAST_LOOP` option for this socket.

For more information about this option, see `set_multicast_loop_v4`.

#### `pub fn set_multicast_loop_v4(&self, on: bool) -> Result<()>` [src]

Sets the value of the `IP_MULTICAST_LOOP` option for this socket.

If enabled, multicast packets will be looped back to the local socket.

# Note

This may not have any affect on IPv6 sockets.

#### `pub fn multicast_ttl_v4(&self) -> Result<u32>` [src]

Gets the value of the `IP_MULTICAST_TTL` option for this socket.

For more information about this option, see `set_multicast_ttl_v4`.

#### `pub fn set_multicast_ttl_v4(&self, ttl: u32) -> Result<()>` [src]

Sets the value of the `IP_MULTICAST_TTL` option for this socket.

Indicates the time-to-live value of outgoing multicast packets for this socket. The default value is 1 which means that multicast packets don't leave the local network unless explicitly requested.

# Note

This may not have any affect on IPv6 sockets.

#### `pub fn multicast_loop_v6(&self) -> Result<bool>` [src]

Gets the value of the `IPV6_MULTICAST_LOOP` option for this socket.

For more information about this option, see `set_multicast_loop_v6`.

#### `pub fn set_multicast_loop_v6(&self, on: bool) -> Result<()>` [src]

Sets the value of the `IPV6_MULTICAST_LOOP` option for this socket.

Controls whether this socket sees the multicast packets it sends itself.

# Note

This may not have any affect on IPv4 sockets.

#### `pub fn ttl(&self) -> Result<u32>` [src]

Gets the value of the `IP_TTL` option for this socket.

For more information about this option, see `set_ttl`.

# Examples

    use tokio::net::UdpSocket;

    let sock = UdpSocket::bind("127.0.0.1:8080").await?;

    println!("{:?}", sock.ttl()?);

#### `pub fn set_ttl(&self, ttl: u32) -> Result<()>` [src]

Sets the value for the `IP_TTL` option on this socket.

This value sets the time-to-live field that is used in every packet sent from this socket.

# Examples

    use tokio::net::UdpSocket;

    let sock = UdpSocket::bind("127.0.0.1:8080").await?;
    sock.set_ttl(60)?;

#### `pub fn join_multicast_v4(
&self,
multiaddr: Ipv4Addr,
interface: Ipv4Addr
) -> Result<()>` [src]

Executes an operation of the `IP_ADD_MEMBERSHIP` type.

This function specifies a new multicast group for this socket to join. The address must be a valid multicast address, and `interface` is the address of the local interface with which the system should join the multicast group. If it's equal to `INADDR_ANY` then an appropriate interface is chosen by the system.

#### `pub fn join_multicast_v6(
&self,
multiaddr: &Ipv6Addr,
interface: u32
) -> Result<()>` [src]

Executes an operation of the `IPV6_ADD_MEMBERSHIP` type.

This function specifies a new multicast group for this socket to join. The address must be a valid multicast address, and `interface` is the index of the interface to join/leave (or 0 to indicate any interface).

#### `pub fn leave_multicast_v4(
&self,
multiaddr: Ipv4Addr,
interface: Ipv4Addr
) -> Result<()>` [src]

Executes an operation of the `IP_DROP_MEMBERSHIP` type.

For more information about this option, see `join_multicast_v4`.

#### `pub fn leave_multicast_v6(
&self,
multiaddr: &Ipv6Addr,
interface: u32
) -> Result<()>` [src]

Executes an operation of the `IPV6_DROP_MEMBERSHIP` type.

For more information about this option, see `join_multicast_v6`.

#### `pub fn take_error(&self) -> Result<Option<Error>>` [src]

Returns the value of the `SO_ERROR` option.

# Examples

    use tokio::net::UdpSocket;
    use std::io;

    #[tokio::main]
    async fn main() -> io::Result<()> {
        // Create a socket
        let socket = UdpSocket::bind("0.0.0.0:8080").await?;

        if let Ok(Some(err)) = socket.take_error() {
            println!("Got error: {:?}", err);
        }

        Ok(())
    }

## Trait Implementations

### `impl AsRawFd for UdpSocket` [src]

#### `fn as_raw_fd(&self) -> RawFd` [src]

Extracts the raw file descriptor. Read more

### `impl Debug for UdpSocket` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl TryFrom<UdpSocket> for UdpSocket` [src]

#### `type Error = Error`

The type returned in the event of a conversion error.

#### `fn try_from(stream: UdpSocket) -> Result<Self, Self::Error>` [src]

Consumes stream, returning the tokio I/O object.

This is equivalent to `UdpSocket::from_std(stream)`.

## Auto Trait Implementations

### `impl !RefUnwindSafe for UdpSocket`

### `impl Send for UdpSocket`

### `impl Sync for UdpSocket`

### `impl Unpin for UdpSocket`

### `impl !UnwindSafe for UdpSocket`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.