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

    pub struct UnixListener { /* fields omitted */ }

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

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

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

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

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

#### `pub fn from_std(listener: UnixListener) -> Result<UnixListener>` [src]

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. The conversion assumes nothing about the underlying listener; 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 local_addr(&self) -> Result<SocketAddr>` [src]

Returns the local socket address of this listener.

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

Returns the value of the `SO_ERROR` option.

#### `pub async fn accept<'_>(&'_ self) -> Result<(UnixStream, SocketAddr)>` [src]

Accepts a new incoming connection to this listener.

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

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.

## Trait Implementations

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

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

Extracts the raw file descriptor. Read more

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

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

Formats the value using the given formatter. Read more

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

#### `type Error = Error`

The type returned in the event of a conversion error.

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

Consumes stream, returning the tokio I/O object.

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

## Auto Trait Implementations

### `impl !RefUnwindSafe for UnixListener`

### `impl Send for UnixListener`

### `impl Sync for UnixListener`

### `impl Unpin for UnixListener`

### `impl !UnwindSafe for UnixListener`

## 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.