Struct UnixListener 

pub struct UnixListener { /* private fields */ }

A Unix socket which can accept connections from other Unix sockets.

You can accept a new connection by using the accept method. Alternatively UnixListener implements the Stream trait, which allows you to use the listener in places that want a stream. The stream will never return None and will also not yield the peer’s SocketAddr structure. Iterating over it is equivalent to calling accept in a loop.

Errors

Note that accepting a connection can lead to various errors and not all of them are necessarily fatal ‒ for example having too many open file descriptors or the other side closing the connection while it waits in an accept queue. These would terminate the stream if not handled in any way.

Examples

use tokio::net::UnixListener;
use tokio::stream::StreamExt;

#[tokio::main]
async fn main() {
    let mut listener = UnixListener::bind("/path/to/the/socket").unwrap();
    while let Some(stream) = listener.next().await {
        match stream {
            Ok(stream) => {
                println!("new client!");
            }
            Err(e) => { /* connection failed */ }
        }
    }
}

Implementations

impl UnixListener

pub fn bind<P>(path: P) -> Result<UnixListener, Error>

where P: AsRef<Path>,

Creates a new UnixListener bound to the specified path.

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 from_std(listener: UnixListener) -> Result<UnixListener, Error>

Consumes a UnixListener in the standard library and returns a nonblocking UnixListener from this crate.

The returned listener 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 local_addr(&self) -> Result<SocketAddr, Error>

Returns the local socket address of this listener.

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

Returns the value of the SO_ERROR option.

pub async fn accept(&mut self) -> Result<(UnixStream, SocketAddr), Error>

Accepts a new incoming connection to this listener.

pub fn poll_accept( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(UnixStream, SocketAddr), Error>>

Polls to accept a new incoming connection to this listener.

If there is no connection to accept, Poll::Pending is returned and the current task will be notified by a waker.

pub fn incoming(&mut self) -> Incoming<'_>

Returns a stream over the connections being received on this listener.

Note that UnixListener also directly implements Stream.

The returned stream will never return None and will also not yield the peer’s SocketAddr structure. Iterating over it is equivalent to calling accept in a loop.

Errors

Note that accepting a connection can lead to various errors and not all of them are necessarily fatal ‒ for example having too many open file descriptors or the other side closing the connection while it waits in an accept queue. These would terminate the stream if not handled in any way.

Examples

use tokio::net::UnixListener;
use tokio::stream::StreamExt;

#[tokio::main]
async fn main() {
    let mut listener = UnixListener::bind("/path/to/the/socket").unwrap();
    let mut incoming = listener.incoming();

    while let Some(stream) = incoming.next().await {
        match stream {
            Ok(stream) => {
                println!("new client!");
            }
            Err(e) => { /* connection failed */ }
        }
    }
}

Trait Implementations

impl AsRawFd for UnixListener

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl Debug for UnixListener

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Stream for UnixListener

Available on crate feature stream only.

type Item = Result<UnixStream, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut UnixListener>, cx: &mut Context<'_>, ) -> Poll<Option<<UnixListener as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl TryFrom<UnixListener> for UnixListener

fn try_from(stream: UnixListener) -> Result<UnixListener, Error>

Consumes stream, returning the tokio I/O object.

This is equivalent to UnixListener::from_std(stream).

type Error = Error

The type returned in the event of a conversion error.