Struct tokio::net::UnixDatagram

source · [−]

pub struct UnixDatagram { /* private fields */ }

Expand description

An I/O object representing a Unix datagram socket.

Implementations

source

impl UnixDatagram

source

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

Creates a new UnixDatagram bound to the specified path.

source

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

source

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

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.

source

pub fn unbound() -> Result<UnixDatagram>

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

source

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.

source

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

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

source

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

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

source

pub fn try_send_to(&mut self, buf: &[u8 ], target: P) -> Result<usize> 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);

source

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

Receives data from the socket.

source

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

Try to receive a datagram from the peer without waiting.

source

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

Sends data on the socket to the specified address.

source

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

Receives data from the socket.

source

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

Try to receive data from the socket without waiting.

source

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

Returns the local address that this socket is bound to.

source

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.

source

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

Returns the value of the SO_ERROR option.

source

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

source