Struct compio_net::UdpSocket

pub struct UdpSocket { /* private fields */ }

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. 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

Examples

Bind and connect a pair of sockets and send a packet:

use std::net::SocketAddr;

use compio_net::UdpSocket;

compio_runtime::block_on(async {
    let first_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let second_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();

    // bind sockets
    let socket = UdpSocket::bind(first_addr).unwrap();
    let first_addr = socket.local_addr().unwrap();
    let other_socket = UdpSocket::bind(second_addr).unwrap();
    let second_addr = other_socket.local_addr().unwrap();

    // connect sockets
    socket.connect(second_addr).unwrap();
    other_socket.connect(first_addr).unwrap();

    let buf = Vec::with_capacity(12);

    // write data
    socket.send("Hello world!").await.unwrap();

    // read data
    let (n_bytes, buf) = other_socket.recv(buf).await.unwrap();

    assert_eq!(n_bytes, buf.len());
    assert_eq!(buf, b"Hello world!");
});

Send and receive packets without connecting:

use std::net::SocketAddr;

use compio_net::UdpSocket;
use socket2::SockAddr;

compio_runtime::block_on(async {
    let first_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let second_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();

    // bind sockets
    let socket = UdpSocket::bind(first_addr).unwrap();
    let first_addr = socket.local_addr().unwrap();
    let other_socket = UdpSocket::bind(second_addr).unwrap();
    let second_addr = other_socket.local_addr().unwrap();

    let buf = Vec::with_capacity(32);

    // write data
    socket
        .send_to("hello world", SockAddr::from(second_addr))
        .await
        .unwrap();

    // read data
    let ((n_bytes, addr), buf) = other_socket.recv_from(buf).await.unwrap();

    assert_eq!(addr, first_addr);
    assert_eq!(n_bytes, buf.len());
    assert_eq!(buf, b"hello world");
});

Implementations

impl UdpSocket

pub fn bind(addr: impl ToSockAddrs) -> Result<Self>

Creates a new UDP socket and attempt to bind it to the addr provided.

pub fn connect(&self, addr: impl ToSockAddrs) -> Result<()>

Connects this UDP socket to a remote address, allowing the send and recv to be used to send data and also applies filters to only receive data from the specified address.

Note that usually, a successful connect call does not specify that there is a remote server listening on the port, rather, such an error would only be detected after the first send.

pub fn try_clone(&self) -> Result<Self>

Creates a new independently owned handle to the underlying socket.

It does not clear the attach state.

pub fn peer_addr(&self) -> Result<SockAddr>

Returns the socket address of the remote peer this socket was connected to.

Examples

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

use compio_net::UdpSocket;
use socket2::SockAddr;

let socket = UdpSocket::bind("127.0.0.1:34254").expect("couldn't bind to address");
socket
    .connect("192.168.0.1:41203")
    .expect("couldn't connect to address");
assert_eq!(
    socket.peer_addr().unwrap(),
    SockAddr::from(SocketAddr::V4(SocketAddrV4::new(
        Ipv4Addr::new(192, 168, 0, 1),
        41203
    )))
);

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

Returns the local address that this socket is bound to.

Example

use std::net::SocketAddr;

use compio_net::UdpSocket;
use socket2::SockAddr;

let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let sock = UdpSocket::bind(&addr).unwrap();
// the address the socket is bound to
let local_addr = sock.local_addr().unwrap().as_socket().unwrap();
assert_eq!(local_addr, addr);

pub async fn recv<T: IoBufMut>(&self, buffer: T) -> BufResult<usize, T>

Receives a packet of data from the socket into the buffer, returning the original buffer and quantity of data received.

pub async fn recv_vectored<T: IoVectoredBufMut>( &self, buffer: T ) -> BufResult<usize, T>

Receives a packet of data from the socket into the buffer, returning the original buffer and quantity of data received.

pub async fn send<T: IoBuf>(&self, buffer: T) -> BufResult<usize, T>

Sends some data to the socket from the buffer, returning the original buffer and quantity of data sent.

pub async fn send_vectored<T: IoVectoredBuf>( &self, buffer: T ) -> BufResult<usize, T>

Sends some data to the socket from the buffer, returning the original buffer and quantity of data sent.

pub async fn recv_from<T: IoBufMut>( &self, buffer: T ) -> BufResult<(usize, SockAddr), T>

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

pub async fn recv_from_vectored<T: IoVectoredBufMut>( &self, buffer: T ) -> BufResult<(usize, SockAddr), T>

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

pub async fn send_to<T: IoBuf>( &self, buffer: T, addr: impl ToSockAddrs ) -> BufResult<usize, T>

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

pub async fn send_to_vectored<T: IoVectoredBuf>( &self, buffer: T, addr: impl ToSockAddrs ) -> BufResult<usize, T>

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

Trait Implementations

impl AsRawFd for UdpSocket

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl FromRawFd for UdpSocket

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for UdpSocket

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.