Struct tokio::net::UnixDatagram [−][src]
An I/O object representing a Unix datagram socket.
Implementations
impl UnixDatagram
[src]
pub fn bind<P>(path: P) -> Result<UnixDatagram> where
P: AsRef<Path>,
[src]
P: AsRef<Path>,
Creates a new UnixDatagram
bound to the specified path.
pub fn pair() -> Result<(UnixDatagram, UnixDatagram)>
[src]
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>
[src]
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>
[src]
Creates a new UnixDatagram
which is not bound to any address.
pub fn connect<P: AsRef<Path>>(&self, path: P) -> Result<()>
[src]
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>
[src]
Sends data on the socket to the socket’s peer.
pub fn try_send(&mut self, buf: &[u8]) -> Result<usize>
[src]
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> where
P: AsRef<Path>,
[src]
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>
[src]
Receives data from the socket.
pub fn try_recv(&mut self, buf: &mut [u8]) -> Result<usize>
[src]
Try to receive a datagram from the peer without waiting.
pub async fn send_to<P>(&mut self, buf: &[u8], target: P) -> Result<usize> where
P: AsRef<Path> + Unpin,
[src]
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)>
[src]
Receives data from the socket.
pub fn try_recv_from(&mut self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>
[src]
Try to receive data from the socket without waiting.
pub fn local_addr(&self) -> Result<SocketAddr>
[src]
Returns the local address that this socket is bound to.
pub fn peer_addr(&self) -> Result<SocketAddr>
[src]
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>>
[src]
Returns the value of the SO_ERROR
option.
pub fn shutdown(&self, how: Shutdown) -> Result<()>
[src]
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>)
[src]
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)
[src]
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
[src]
impl AsRef<UnixDatagram> for RecvHalf<'_>
[src]
fn as_ref(&self) -> &UnixDatagram
[src]
impl AsRef<UnixDatagram> for SendHalf<'_>
[src]
fn as_ref(&self) -> &UnixDatagram
[src]
impl AsRef<UnixDatagram> for OwnedSendHalf
[src]
fn as_ref(&self) -> &UnixDatagram
[src]
impl AsRef<UnixDatagram> for OwnedRecvHalf
[src]
fn as_ref(&self) -> &UnixDatagram
[src]
impl Debug for UnixDatagram
[src]
impl TryFrom<UnixDatagram> for UnixDatagram
[src]
type Error = Error
The type returned in the event of a conversion error.
fn try_from(stream: UnixDatagram) -> Result<Self, Self::Error>
[src]
Consumes stream, returning the tokio I/O object.
This is equivalent to
UnixDatagram::from_std(stream)
.
Auto Trait Implementations
impl !RefUnwindSafe for UnixDatagram
impl Send for UnixDatagram
impl Sync for UnixDatagram
impl Unpin for UnixDatagram
impl !UnwindSafe for UnixDatagram
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
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]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,