Struct mio::net::UnixStream

source ·

pub struct UnixStream { /* private fields */ }

Expand description

A non-blocking Unix stream socket.

Implementations§

source §

impl UnixStream

source

pub fn connect<P: AsRef<Path>>(path: P) -> Result<UnixStream>

Connects to the socket named by path.

This may return a WouldBlock in which case the socket connection cannot be completed immediately. Usually it means the backlog is full.

source

pub fn from_std(stream: UnixStream) -> UnixStream ⓘ

Creates a new UnixStream from a standard net::UnixStream.

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

Note

The Unix stream here will not have connect called on it, so it should already be connected via some other means (be it manually, or the standard library).

source

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

Creates an unnamed pair of connected sockets.

Returns two UnixStreams which are connected to each other.

source

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

Returns the socket address of the local half of this connection.

source

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

Returns the socket address of the remote half of this connection.

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

pub fn try_io<F, T>(&self, f: F) -> Result<T>where F: FnOnce() -> Result<T>,

Execute an I/O operation ensuring that the socket receives more events if it hits a WouldBlock error.

Notes

This method is required to be called for all I/O operations to ensure the user will receive events once the socket is ready again after returning a WouldBlock error.

Examples

use std::io;
use std::os::unix::io::AsRawFd;
use mio::net::UnixStream;

let (stream1, stream2) = UnixStream::pair()?;

// Wait until the stream is writable...

// Write to the stream using a direct libc call, of course the
// `io::Write` implementation would be easier to use.
let buf = b"hello";
let n = stream1.try_io(|| {
    let buf_ptr = &buf as *const _ as *const _;
    let res = unsafe { libc::send(stream1.as_raw_fd(), buf_ptr, buf.len(), 0) };
    if res != -1 {
        Ok(res as usize)
    } else {
        // If EAGAIN or EWOULDBLOCK is set by libc::send, the closure
        // should return `WouldBlock` error.
        Err(io::Error::last_os_error())
    }
})?;
eprintln!("write {} bytes", n);

// Wait until the stream is readable...

// Read from the stream using a direct libc call, of course the
// `io::Read` implementation would be easier to use.
let mut buf = [0; 512];
let n = stream2.try_io(|| {
    let buf_ptr = &mut buf as *mut _ as *mut _;
    let res = unsafe { libc::recv(stream2.as_raw_fd(), buf_ptr, buf.len(), 0) };
    if res != -1 {
        Ok(res as usize)
    } else {
        // If EAGAIN or EWOULDBLOCK is set by libc::recv, the closure
        // should return `WouldBlock` error.
        Err(io::Error::last_os_error())
    }
})?;
eprintln!("read {} bytes", n);