Struct UnixDatagram 

pub struct UnixDatagram { /* private fields */ }

An I/O object representing a Unix datagram socket.

Implementations

impl UnixDatagram

pub fn bind<P>(path: P) -> Result<UnixDatagram, Error>

where P: AsRef<Path>,

Creates a new UnixDatagram bound to the specified path.

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

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. Each socket will be associated with the default event loop’s handle.

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

Consumes a UnixDatagram in the standard library and returns a nonblocking UnixDatagram from this crate.

The returned datagram will be associated with the given event loop specified by handle and is ready to perform I/O.

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 Handle::enter function.

pub fn unbound() -> Result<UnixDatagram, Error>

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

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

where P: AsRef<Path>,

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.

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

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

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

Try to send a datagram to the peer without waiting.

use tokio::net::UnixDatagram;

let bytes = b"bytes";
// We use a socket pair so that they are assigned
// each other as a peer.
let (mut first, mut 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.as_slice()[..size];
assert_eq!(dgram, bytes);

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

where P: AsRef<Path>,

Try to send a datagram to the peer without waiting.

use {
    tokio::net::UnixDatagram,
    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 mut server = UnixDatagram::bind(&server_path)?;

let client_path = tmp.path().join("client");
let mut 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.as_slice()[..size];
assert_eq!(dgram, bytes);
assert_eq!(addr.as_pathname().unwrap(), &client_path);

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

Receives data from the socket.

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

Try to receive a datagram from the peer without waiting.

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

where P: AsRef<Path> + Unpin,

Sends data on the socket to the specified address.

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

Receives data from the socket.

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

Try to receive data from the socket without waiting.

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

Returns the local address that this socket is bound to.

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

Returns the address of this socket’s peer.

The connect method will connect the socket to a peer.

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

Returns the value of the SO_ERROR option.

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

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

pub fn split<'a>(&'a mut self) -> (RecvHalf<'a>, SendHalf<'a>)

Split a UnixDatagram into a receive half and a send half, which can be used to receive and send the datagram concurrently.

This method is more efficient than into_split, but the halves cannot be moved into independently spawned tasks.

pub fn into_split(self) -> (OwnedRecvHalf, OwnedSendHalf)

Split a UnixDatagram into a receive half and a send half, which can be used to receive and send the datagram concurrently.

Unlike split, the owned halves can be moved to separate tasks, however this comes at the cost of a heap allocation.

Note: Dropping the write half will shut down the write half of the datagram. This is equivalent to calling shutdown(Write).

Trait Implementations

impl AsRawFd for UnixDatagram

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl Debug for UnixDatagram

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

Formats the value using the given formatter.

impl TryFrom<UnixDatagram> for UnixDatagram

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

Consumes stream, returning the tokio I/O object.

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

type Error = Error

The type returned in the event of a conversion error.