Struct `UnixListener`

struct UnixListener { ... }

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

You can accept a new connection by using the accept method.

A UnixListener can be turned into a Stream with UnixListenerStream.

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;

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

Implementations

`impl UnixListener`

fn bind<P>(path: P) -> Result<UnixListener> where P: AsRef<Path>

Creates a new UnixListener bound to the specified path.

Panics

This function panics if it is not called from within a runtime with IO enabled.

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.

fn from_std(listener: UnixListener) -> Result<UnixListener>

Creates new UnixListener from a std::os::unix::net::UnixListener.

This function is intended to be used to wrap a UnixListener from the standard library in the Tokio equivalent.

Notes

The caller is responsible for ensuring that the listener is in non-blocking mode. Otherwise all I/O operations on the listener will block the thread, which will cause unexpected behavior. Non-blocking mode can be set using set_nonblocking.

Passing a listener in blocking mode is always erroneous, and the behavior in that case may change in the future. For example, it could panic.

Examples

use tokio::net::UnixListener;
use std::os::unix::net::UnixListener as StdUnixListener;
# use std::error::Error;

# async fn dox() -> Result<(), Box<dyn Error>> {
let std_listener = StdUnixListener::bind("/path/to/the/socket")?;
std_listener.set_nonblocking(true)?;
let listener = UnixListener::from_std(std_listener)?;
# Ok(())
# }

Panics

This function panics if it is not called from within a runtime with IO enabled.

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.

fn into_std(self: Self) -> Result<UnixListener>

Turns a tokio::net::UnixListener into a std::os::unix::net::UnixListener.

The returned std::os::unix::net::UnixListener will have nonblocking mode set as true. Use set_nonblocking to change the blocking mode if needed.

Examples

# use std::error::Error;
# async fn dox() -> Result<(), Box<dyn Error>> {
let tokio_listener = tokio::net::UnixListener::bind("/path/to/the/socket")?;
let std_listener = tokio_listener.into_std()?;
std_listener.set_nonblocking(false)?;
# Ok(())
# }

fn local_addr(self: &Self) -> Result<SocketAddr>

Returns the local socket address of this listener.

fn take_error(self: &Self) -> Result<Option<Error>>

Returns the value of the SO_ERROR option.

async fn accept(self: &Self) -> Result<(UnixStream, SocketAddr)>

Accepts a new incoming connection to this listener.

Cancel safety

This method is cancel safe. If the method is used as the event in a tokio::select! statement and some other branch completes first, then it is guaranteed that no new connections were accepted by this method.

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

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. Note that on multiple calls to poll_accept, only the Waker from the Context passed to the most recent call is scheduled to receive a wakeup.

`impl AsFd for UnixListener`

fn as_fd(self: &Self) -> BorrowedFd<'_>

`impl AsRawFd for UnixListener`

fn as_raw_fd(self: &Self) -> RawFd

`impl Debug for UnixListener`

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

`impl Freeze for UnixListener`

`impl RefUnwindSafe for UnixListener`

`impl Send for UnixListener`

`impl Sync for UnixListener`

`impl TryFrom for UnixListener`

fn try_from(stream: UnixListener) -> Result<Self>

Consumes stream, returning the tokio I/O object.

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

`impl Unpin for UnixListener`

`impl UnsafeUnpin for UnixListener`

`impl UnwindSafe for UnixListener`

`impl<T> Any for UnixListener`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for UnixListener`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for UnixListener`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for UnixListener`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for UnixListener`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for UnixListener`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for UnixListener`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>