Struct futures_net::UnixDatagram

pub struct UnixDatagram { /* fields omitted */ }

An I/O object representing a Unix datagram socket.

Implementations

impl UnixDatagram

pub fn bind(path: impl AsRef<Path>) -> Result<UnixDatagram>

Creates a new UnixDatagram bound to the specified path.

Examples

use futures_net::uds::UnixDatagram;

let sock = UnixDatagram::bind("/tmp/sock")?;

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 event loop whose handle is also provided.

Examples

use futures_net::uds::UnixDatagram;

let (sock1, sock2) = UnixDatagram::pair()?;

pub fn unbound() -> Result<UnixDatagram>

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

Examples

use futures_net::uds::UnixDatagram;

let sock = UnixDatagram::unbound()?;

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

Returns the local address that this socket is bound to.

Examples

use futures_net::uds::UnixDatagram;

let stream = UnixDatagram::bind("/tmp/sock")?;
let addr = stream.local_addr()?;

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

use futures_net::uds::UnixDatagram;

let stream = UnixDatagram::bind("/tmp/sock")?;
let addr = stream.peer_addr()?;

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

Shut 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 futures_net::uds::UnixDatagram;
use std::net::Shutdown;

let stream = UnixDatagram::bind("/tmp/sock")?;
stream.shutdown(Shutdown::Both)?;

pub fn send_to<'a, 'b>(
    &'a mut self,
    buf: &'b [u8],
    target: &'b PathBuf
) -> SendTo<'a, 'b>

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

Examples

use futures_net::udp::UdpSocket;

const THE_MERCHANT_OF_VENICE: &[u8] = b"
    If you prick us, do we not bleed?
    If you tickle us, do we not laugh?
    If you poison us, do we not die?
    And if you wrong us, shall we not revenge?
";

let addr = "/tmp/out.socket".parse()?;
let target = "/tmp/in.socket".parse()?;
let mut socket = UdpSocket::bind(&addr)?;

socket.send_to(THE_MERCHANT_OF_VENICE, &target).await?;

pub fn recv_from<'a, 'b>(&'a mut self, buf: &'b mut [u8]) -> RecvFrom<'a, 'b>

Receives data from the socket. On success, returns the number of bytes read and the address from whence the data came.

Exampes

use futures_net::udp::UdpSocket;

let addr = "/tmp/in.socket".parse()?;
let mut socket = UdpSocket::bind(&addr)?;
let mut buf = vec![0; 1024];

socket.recv_from(&mut buf).await?;

Trait Implementations

impl AsRawFd for UnixDatagram

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncDatagram for UnixDatagram

type Sender = SocketAddr

Specifies which target to send the data to.

type Receiver = PathBuf

Specifies which target the data was received from.

type Err = Error

The type of failures yielded by this trait.

fn poll_send_to(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &[u8],
    receiver: &Self::Receiver
) -> Poll<Result<usize>>

Sends data on the IO interface to the specified target.

fn poll_recv_from(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<(usize, Self::Sender)>>

Receives data from the IO interface.

impl AsyncReadReady for UnixDatagram

type Ok = Ready

The type of successful values yielded by this trait.

type Err = Error

The type of failures yielded by this trait.

fn poll_read_ready(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Err>>

Test whether this socket is ready to be read or not.

fn poll_read_ready_unpin(
    &mut self,
    cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Err>> where
    Self: Unpin, 

A convenience for calling AsyncReadReady::poll_read_ready on Unpin types.

impl AsyncWriteReady for UnixDatagram

type Ok = Ready

The type of successful values yielded by this trait.

type Err = Error

The type of failures yielded by this trait.

fn poll_write_ready(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Err>>

Test whether this socket is ready to be written to or not.

fn poll_write_ready_unpin(
    &mut self,
    cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Err>> where
    Self: Unpin, 

A convenience for calling AsyncWriteReady::poll_write_ready on Unpin types.

impl Debug for UnixDatagram

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

Formats the value using the given formatter.

impl TakeError for UnixDatagram

type Ok = Error

The type of successful values yielded by this trait.

type Err = Error

The type of failures yielded by this trait.

fn take_error(&self) -> Result<Option<Self::Ok>, Self::Err>

Returns the value of the SO_ERROR option.

Examples

use async_ready::TakeError;
use futures_net::uds::UnixDatagram;

let stream = UnixDatagram::bind("/tmp/sock")?;
if let Ok(Some(err)) = stream.take_error() {
    println!("Got error: {:?}", err);
}