Struct tokio::net::UnixDatagram

pub struct UnixDatagram { /* fields omitted */ }

An I/O object representing a Unix datagram socket.

A socket can be either named (associated with a filesystem path) or unnamed.

Note: named sockets are persisted even after the object is dropped and the program has exited, and cannot be reconnected. It is advised that you either check for and unlink the existing socket if it exists, or use a temporary file that is guaranteed to not already exist.

Examples

Using named sockets, associated with a filesystem path:

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind each socket to a filesystem path
let tx_path = tmp.path().join("tx");
let tx = UnixDatagram::bind(&tx_path)?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

let bytes = b"hello world";
tx.send_to(bytes, &rx_path).await?;

let mut buf = vec![0u8; 24];
let (size, addr) = rx.recv_from(&mut buf).await?;

let dgram = &buf[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &tx_path);

Using unnamed sockets, created as a pair

use tokio::net::UnixDatagram;

// Create the pair of sockets
let (sock1, sock2) = UnixDatagram::pair()?;

// Since the sockets are paired, the paired send/recv
// functions can be used
let bytes = b"hello world";
sock1.send(bytes).await?;

let mut buff = vec![0u8; 24];
let size = sock2.recv(&mut buff).await?;

let dgram = &buff[..size];
assert_eq!(dgram, bytes);

Implementations

impl UnixDatagram

pub fn bind<P>(path: P) -> Result<UnixDatagram> where
    P: AsRef<Path>, 

Creates a new UnixDatagram bound to the specified path.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind the socket to a filesystem path
let socket_path = tmp.path().join("socket");
let socket = UnixDatagram::bind(&socket_path)?;

pub fn pair() -> Result<(UnixDatagram, UnixDatagram)>

Creates an unnamed pair of connected sockets.

This function will create a pair of interconnected Unix sockets for communicating back and forth between one another.

Examples

use tokio::net::UnixDatagram;

// Create the pair of sockets
let (sock1, sock2) = UnixDatagram::pair()?;

// Since the sockets are paired, the paired send/recv
// functions can be used
let bytes = b"hail eris";
sock1.send(bytes).await?;

let mut buff = vec![0u8; 24];
let size = sock2.recv(&mut buff).await?;

let dgram = &buff[..size];
assert_eq!(dgram, bytes);

pub fn from_std(datagram: UnixDatagram) -> Result<UnixDatagram>

Creates new UnixDatagram from a std::os::unix::net::UnixDatagram.

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

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.

Examples

use tokio::net::UnixDatagram;
use std::os::unix::net::UnixDatagram as StdUDS;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind the socket to a filesystem path
let socket_path = tmp.path().join("socket");
let std_socket = StdUDS::bind(&socket_path)?;
std_socket.set_nonblocking(true)?;
let tokio_socket = UnixDatagram::from_std(std_socket)?;

pub fn unbound() -> Result<UnixDatagram>

Creates a new UnixDatagram which is not bound to any address.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// Create an unbound socket
let tx = UnixDatagram::unbound()?;

// Create another, bound socket
let tmp = tempdir()?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

// Send to the bound socket
let bytes = b"hello world";
tx.send_to(bytes, &rx_path).await?;

let mut buf = vec![0u8; 24];
let (size, addr) = rx.recv_from(&mut buf).await?;

let dgram = &buf[..size];
assert_eq!(dgram, bytes);

pub fn connect<P: AsRef<Path>>(&self, path: P) -> Result<()>

Connects the socket to the specified address.

The send method may be used to send data to the specified address. recv and recv_from will only receive data from that address.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// Create an unbound socket
let tx = UnixDatagram::unbound()?;

// Create another, bound socket
let tmp = tempdir()?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

// Connect to the bound socket
tx.connect(&rx_path)?;

// Send to the bound socket
let bytes = b"hello world";
tx.send(bytes).await?;

let mut buf = vec![0u8; 24];
let (size, addr) = rx.recv_from(&mut buf).await?;

let dgram = &buf[..size];
assert_eq!(dgram, bytes);

pub async fn send(&self, buf: &[u8]) -> Result<usize>

Sends data on the socket to the socket’s peer.

Examples

use tokio::net::UnixDatagram;

// Create the pair of sockets
let (sock1, sock2) = UnixDatagram::pair()?;

// Since the sockets are paired, the paired send/recv
// functions can be used
let bytes = b"hello world";
sock1.send(bytes).await?;

let mut buff = vec![0u8; 24];
let size = sock2.recv(&mut buff).await?;

let dgram = &buff[..size];
assert_eq!(dgram, bytes);

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

Try to send a datagram to the peer without waiting.

Examples

use tokio::net::UnixDatagram;

let bytes = b"bytes";
// We use a socket pair so that they are assigned
// each other as a peer.
let (first, second) = UnixDatagram::pair()?;

let size = first.try_send(bytes)?;
assert_eq!(size, bytes.len());

let mut buffer = vec![0u8; 24];
let size = second.try_recv(&mut buffer)?;

let dgram = &buffer[..size];
assert_eq!(dgram, bytes);

pub fn try_send_to<P>(&self, buf: &[u8], target: P) -> Result<usize> where
    P: AsRef<Path>, 

Try to send a datagram to the peer without waiting.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

let bytes = b"bytes";
// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir().unwrap();

let server_path = tmp.path().join("server");
let server = UnixDatagram::bind(&server_path)?;

let client_path = tmp.path().join("client");
let client = UnixDatagram::bind(&client_path)?;

let size = client.try_send_to(bytes, &server_path)?;
assert_eq!(size, bytes.len());

let mut buffer = vec![0u8; 24];
let (size, addr) = server.try_recv_from(&mut buffer)?;

let dgram = &buffer[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &client_path);

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

Receives data from the socket.

Examples

use tokio::net::UnixDatagram;

// Create the pair of sockets
let (sock1, sock2) = UnixDatagram::pair()?;

// Since the sockets are paired, the paired send/recv
// functions can be used
let bytes = b"hello world";
sock1.send(bytes).await?;

let mut buff = vec![0u8; 24];
let size = sock2.recv(&mut buff).await?;

let dgram = &buff[..size];
assert_eq!(dgram, bytes);

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

Try to receive a datagram from the peer without waiting.

Examples

use tokio::net::UnixDatagram;

let bytes = b"bytes";
// We use a socket pair so that they are assigned
// each other as a peer.
let (first, second) = UnixDatagram::pair()?;

let size = first.try_send(bytes)?;
assert_eq!(size, bytes.len());

let mut buffer = vec![0u8; 24];
let size = second.try_recv(&mut buffer)?;

let dgram = &buffer[..size];
assert_eq!(dgram, bytes);

pub async fn send_to<P>(&self, buf: &[u8], target: P) -> Result<usize> where
    P: AsRef<Path>, 

Sends data on the socket to the specified address.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind each socket to a filesystem path
let tx_path = tmp.path().join("tx");
let tx = UnixDatagram::bind(&tx_path)?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

let bytes = b"hello world";
tx.send_to(bytes, &rx_path).await?;

let mut buf = vec![0u8; 24];
let (size, addr) = rx.recv_from(&mut buf).await?;

let dgram = &buf[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &tx_path);

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

Receives data from the socket.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind each socket to a filesystem path
let tx_path = tmp.path().join("tx");
let tx = UnixDatagram::bind(&tx_path)?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

let bytes = b"hello world";
tx.send_to(bytes, &rx_path).await?;

let mut buf = vec![0u8; 24];
let (size, addr) = rx.recv_from(&mut buf).await?;

let dgram = &buf[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &tx_path);

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

Try to receive data from the socket without waiting.

Examples

use tokio::net::UnixDatagram;
use tempfile::tempdir;

let bytes = b"bytes";
// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir().unwrap();

let server_path = tmp.path().join("server");
let server = UnixDatagram::bind(&server_path)?;

let client_path = tmp.path().join("client");
let client = UnixDatagram::bind(&client_path)?;

let size = client.try_send_to(bytes, &server_path)?;
assert_eq!(size, bytes.len());

let mut buffer = vec![0u8; 24];
let (size, addr) = server.try_recv_from(&mut buffer)?;

let dgram = &buffer[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &client_path);

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

Returns the local address that this socket is bound to.

Examples

For a socket bound to a local path

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// We use a temporary directory so that the socket
// files left by the bound sockets will get cleaned up.
let tmp = tempdir()?;

// Bind socket to a filesystem path
let socket_path = tmp.path().join("socket");
let socket = UnixDatagram::bind(&socket_path)?;

assert_eq!(socket.local_addr()?.as_pathname().unwrap(), &socket_path);

For an unbound socket

use tokio::net::UnixDatagram;

// Create an unbound socket
let socket = UnixDatagram::unbound()?;

assert!(socket.local_addr()?.is_unnamed());

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

Returns the address of this socket’s peer.

The connect method will connect the socket to a peer.

Examples

For a peer with a local path

use tokio::net::UnixDatagram;
use tempfile::tempdir;

// Create an unbound socket
let tx = UnixDatagram::unbound()?;

// Create another, bound socket
let tmp = tempdir()?;
let rx_path = tmp.path().join("rx");
let rx = UnixDatagram::bind(&rx_path)?;

// Connect to the bound socket
tx.connect(&rx_path)?;

assert_eq!(tx.peer_addr()?.as_pathname().unwrap(), &rx_path);

For an unbound peer

use tokio::net::UnixDatagram;

// Create the pair of sockets
let (sock1, sock2) = UnixDatagram::pair()?;

assert!(sock1.peer_addr()?.is_unnamed());

pub fn take_error(&self) -> Result<Option<Error>>

Returns the value of the SO_ERROR option.

Examples

use tokio::net::UnixDatagram;

// Create an unbound socket
let socket = UnixDatagram::unbound()?;

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

pub fn shutdown(&self, how: Shutdown) -> Result<()>

Shuts down the read, write, or both halves of this connection.

This function will cause all pending and future I/O calls on the specified portions to immediately return with an appropriate value (see the documentation of Shutdown).

Examples

use tokio::net::UnixDatagram;
use std::net::Shutdown;

// Create an unbound socket
let (socket, other) = UnixDatagram::pair()?;

socket.shutdown(Shutdown::Both)?;

// NOTE: the following commented out code does NOT work as expected.
// Due to an underlying issue, the recv call will block indefinitely.
// See: https://github.com/tokio-rs/tokio/issues/1679
//let mut buff = vec![0u8; 24];
//let size = socket.recv(&mut buff).await?;
//assert_eq!(size, 0);

let send_result = socket.send(b"hello world").await;
assert!(send_result.is_err());

Trait Implementations

impl AsRawFd for UnixDatagram

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for UnixDatagram

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl TryFrom<UnixDatagram> for UnixDatagram

type Error = Error

The type returned in the event of a conversion error.

fn try_from(stream: UnixDatagram) -> Result<Self, Self::Error>

Consumes stream, returning the Tokio I/O object.

This is equivalent to UnixDatagram::from_std(stream).