# [−] [src] Struct tokio::net::UnixStream

    pub struct UnixStream { /* fields omitted */ }

A structure representing a connected Unix socket.

This socket can be connected directly with `UnixStream::connect` or accepted from a listener with `UnixListener::incoming`. Additionally, a pair of anonymous Unix sockets can be created with `UnixStream::pair`.

To shut down the stream in the write direction, you can call the `shutdown()` method. This will cause the other peer to receive a read of length 0, indicating that no more data will be sent. This only closes the stream in one direction.

## Implementations

### `impl UnixStream` [src]

#### `pub async fn connect<P>(path: P) -> Result<UnixStream> where
P: AsRef<Path>,` [src]

Connects to the socket named by `path`.

This function will create a new Unix socket and connect to the path specified, associating the returned stream with the default event loop's handle.

#### `pub async fn ready<'_>(&'_ self, interest: Interest) -> Result<Ready>` [src]

Wait for any of the requested ready states.

This function is usually paired with `try_read()` or `try_write()`. It can be used to concurrently read / write to the same socket on a single task without splitting the socket.

# Examples

Concurrently read and write to the stream on the same task without splitting.

    use tokio::io::Interest;
    use tokio::net::UnixStream;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        let dir = tempfile::tempdir().unwrap();
        let bind_path = dir.path().join("bind_path");
        let stream = UnixStream::connect(bind_path).await?;

        loop {
            let ready = stream.ready(Interest::READABLE | Interest::WRITABLE).await?;

            if ready.is_readable() {
                let mut data = vec![0; 1024];
                // Try to read data, this may still fail with `WouldBlock`
                // if the readiness event is a false positive.
                match stream.try_read(&mut data) {
                    Ok(n) => {
                        println!("read {} bytes", n);
                    }
                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                        continue;
                    }
                    Err(e) => {
                        return Err(e.into());
                    }
                }

            }

            if ready.is_writable() {
                // Try to write data, this may still fail with `WouldBlock`
                // if the readiness event is a false positive.
                match stream.try_write(b"hello world") {
                    Ok(n) => {
                        println!("write {} bytes", n);
                    }
                    Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                        continue;
                    }
                    Err(e) => {
                        return Err(e.into());
                    }
                }
            }
        }
    }

#### `pub async fn readable<'_>(&'_ self) -> Result<()>` [src]

Wait for the socket to become readable.

This function is equivalent to `ready(Interest::READABLE)` and is usually paired with `try_read()`.

# Examples

    use tokio::net::UnixStream;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        // Connect to a peer
        let dir = tempfile::tempdir().unwrap();
        let bind_path = dir.path().join("bind_path");
        let stream = UnixStream::connect(bind_path).await?;

        let mut msg = vec![0; 1024];

        loop {
            // Wait for the socket to be readable
            stream.readable().await?;

            // Try to read data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_read(&mut msg) {
                Ok(n) => {
                    msg.truncate(n);
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e.into());
                }
            }
        }

        println!("GOT = {:?}", msg);
        Ok(())
    }

#### `pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

Polls for read readiness.

If the unix stream is not currently ready for reading, this method will store a clone of the `Waker` from the provided `Context`. When the unix stream becomes ready for reading, `Waker::wake` will be called on the waker.

Note that on multiple calls to `poll_read_ready` or `poll_read`, only the `Waker` from the `Context` passed to the most recent call is scheduled to receive a wakeup. (However, `poll_write_ready` retains a second, independent waker.)

This function is intended for cases where creating and pinning a future via `readable` is not feasible. Where possible, using `readable` is preferred, as this supports polling from multiple tasks at once.

# Return value

The function returns:

- `Poll::Pending` if the unix stream is not ready for reading.
- `Poll::Ready(Ok(()))` if the unix stream is ready for reading.
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_read(&self, buf: &mut [u8]) -> Result<usize>` [src]

Try to read data from the stream into the provided buffer, returning how many bytes were read.

Receives any pending data from the socket but does not wait for new data to arrive. On success, returns the number of bytes read. Because `try_read()` is non-blocking, the buffer does not have to be stored by the async task and can exist entirely on the stack.

Usually, `readable()` or `ready()` is used with this function.

# Return

If data is successfully read, `Ok(n)` is returned, where `n` is the number of bytes read. `Ok(0)` indicates the stream's read half is closed and will no longer yield data. If the stream is not ready to read data `Err(io::ErrorKind::WouldBlock)` is returned.

# Examples

    use tokio::net::UnixStream;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        // Connect to a peer
        let dir = tempfile::tempdir().unwrap();
        let bind_path = dir.path().join("bind_path");
        let stream = UnixStream::connect(bind_path).await?;

        loop {
            // Wait for the socket to be readable
            stream.readable().await?;

            // Creating the buffer **after** the `await` prevents it from
            // being stored in the async task.
            let mut buf = [0; 4096];

            // Try to read data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_read(&mut buf) {
                Ok(0) => break,
                Ok(n) => {
                    println!("read {} bytes", n);
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e.into());
                }
            }
        }

        Ok(())
    }

#### `pub async fn writable<'_>(&'_ self) -> Result<()>` [src]

Wait for the socket to become writable.

This function is equivalent to `ready(Interest::WRITABLE)` and is usually paired with `try_write()`.

# Examples

    use tokio::net::UnixStream;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        // Connect to a peer
        let dir = tempfile::tempdir().unwrap();
        let bind_path = dir.path().join("bind_path");
        let stream = UnixStream::connect(bind_path).await?;

        loop {
            // Wait for the socket to be writable
            stream.writable().await?;

            // Try to write data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_write(b"hello world") {
                Ok(n) => {
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e.into());
                }
            }
        }

        Ok(())
    }

#### `pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>` [src]

Polls for write readiness.

If the unix stream is not currently ready for writing, this method will store a clone of the `Waker` from the provided `Context`. When the unix stream becomes ready for writing, `Waker::wake` will be called on the waker.

Note that on multiple calls to `poll_write_ready` or `poll_write`, only the `Waker` from the `Context` passed to the most recent call is scheduled to receive a wakeup. (However, `poll_read_ready` retains a second, independent waker.)

This function is intended for cases where creating and pinning a future via `writable` is not feasible. Where possible, using `writable` is preferred, as this supports polling from multiple tasks at once.

# Return value

The function returns:

- `Poll::Pending` if the unix stream is not ready for writing.
- `Poll::Ready(Ok(()))` if the unix stream is ready for writing.
- `Poll::Ready(Err(e))` if an error is encountered.

# Errors

This function may encounter any standard I/O error except `WouldBlock`.

#### `pub fn try_write(&self, buf: &[u8]) -> Result<usize>` [src]

Try to write a buffer to the stream, returning how many bytes were written.

The function will attempt to write the entire contents of `buf`, but only part of the buffer may be written.

This function is usually paired with `writable()`.

# Return

If data is successfully written, `Ok(n)` is returned, where `n` is the number of bytes written. If the stream is not ready to write data, `Err(io::ErrorKind::WouldBlock)` is returned.

# Examples

    use tokio::net::UnixStream;
    use std::error::Error;
    use std::io;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn Error>> {
        // Connect to a peer
        let dir = tempfile::tempdir().unwrap();
        let bind_path = dir.path().join("bind_path");
        let stream = UnixStream::connect(bind_path).await?;

        loop {
            // Wait for the socket to be writable
            stream.writable().await?;

            // Try to write data, this may still fail with `WouldBlock`
            // if the readiness event is a false positive.
            match stream.try_write(b"hello world") {
                Ok(n) => {
                    break;
                }
                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) => {
                    return Err(e.into());
                }
            }
        }

        Ok(())
    }

#### `pub fn from_std(stream: UnixStream) -> Result<UnixStream>` [src]

Creates new `UnixStream` from a `std::os::unix::net::UnixStream`.

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

# 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 `Runtime::enter` function.

#### `pub fn pair() -> Result<(UnixStream, UnixStream)>` [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 local_addr(&self) -> Result<SocketAddr>` [src]

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

#### `pub fn peer_addr(&self) -> Result<SocketAddr>` [src]

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

#### `pub fn peer_cred(&self) -> Result<UCred>` [src]

Returns effective credentials of the process which called `connect` or `pair`.

#### `pub fn take_error(&self) -> Result<Option<Error>>` [src]

Returns the value of the `SO_ERROR` option.

#### `pub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>)` [src]

Split a `UnixStream` into a read half and a write half, which can be used to read and write the stream concurrently.

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

#### `pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf)` [src]

Splits a `UnixStream` into a read half and a write half, which can be used to read and write the stream 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 stream. This is equivalent to calling `shutdown()` on the `UnixStream`.

## Trait Implementations

### `impl AsRawFd for UnixStream` [src]

#### `fn as_raw_fd(&self) -> RawFd` [src]

Extracts the raw file descriptor. Read more

### `impl<'_> AsRef<UnixStream> for ReadHalf<'_>` [src]

#### `fn as_ref(&self) -> &UnixStream` [src]

Performs the conversion.

### `impl<'_> AsRef<UnixStream> for WriteHalf<'_>` [src]

#### `fn as_ref(&self) -> &UnixStream` [src]

Performs the conversion.

### `impl AsRef<UnixStream> for OwnedReadHalf` [src]

#### `fn as_ref(&self) -> &UnixStream` [src]

Performs the conversion.

### `impl AsRef<UnixStream> for OwnedWriteHalf` [src]

#### `fn as_ref(&self) -> &UnixStream` [src]

Performs the conversion.

### `impl AsyncRead for UnixStream` [src]

#### `fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<()>>` [src]

Attempts to read from the `AsyncRead` into `buf`. Read more

### `impl AsyncWrite for UnixStream` [src]

#### `fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>` [src]

Attempt to write bytes from `buf` into the object. Read more

#### `fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>` [src]

Like `poll_write`, except that it writes from a slice of buffers. Read more

#### `fn is_write_vectored(&self) -> bool` [src]

Determines if this writer has an efficient `poll_write_vectored` implementation. Read more

#### `fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>>` [src]

Attempts to flush the object, ensuring that any buffered data reach their destination. Read more

#### `fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>>` [src]

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. Read more

### `impl Debug for UnixStream` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl TryFrom<UnixStream> for UnixStream` [src]

#### `type Error = Error`

The type returned in the event of a conversion error.

#### `fn try_from(stream: UnixStream) -> Result<Self>` [src]

Consumes stream, returning the tokio I/O object.

This is equivalent to `UnixStream::from_std(stream)`.

## Auto Trait Implementations

### `impl !RefUnwindSafe for UnixStream`

### `impl Send for UnixStream`

### `impl Sync for UnixStream`

### `impl Unpin for UnixStream`

### `impl !UnwindSafe for UnixStream`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `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]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.