# Struct std::os::unix::net::UnixListener 1.10.0 [−] [src]

    pub struct UnixListener(_);

A structure representing a Unix domain socket server.

# Examples

fn main() { use std::thread; use std::os::unix::net::{UnixStream, UnixListener}; fn handle_client(stream: UnixStream) { // ... } let listener = UnixListener::bind("/path/to/the/socket").unwrap(); // accept connections and process them, spawning a new thread for each one for stream in listener.incoming() { match stream { Ok(stream) => { /* connection succeeded */ thread::spawn(|| handle_client(stream)); } Err(err) => { /* connection failed */ break; } } } // close the listener socket drop(listener); }

    use std::thread;
    use std::os::unix::net::{UnixStream, UnixListener};

    fn handle_client(stream: UnixStream) {
        // ...
    }

    let listener = UnixListener::bind("/path/to/the/socket").unwrap();

    // accept connections and process them, spawning a new thread for each one
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                /* connection succeeded */
                thread::spawn(|| handle_client(stream));
            }
            Err(err) => {
                /* connection failed */
                break;
            }
        }
    }

    // close the listener socket
    drop(listener);

## Methods

### `impl UnixListener`
[src]

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

Creates a new `UnixListener` bound to the specified socket.

#### `fn accept(&self) -> Result<(UnixStream, SocketAddr)>`

Accepts a new incoming connection to this listener.

This function will block the calling thread until a new Unix connection is established. When established, the corersponding `UnixStream` and the remote peer's address will be returned.

#### `fn try_clone(&self) -> Result<UnixListener>`

Creates a new independently owned handle to the underlying socket.

The returned `UnixListener` is a reference to the same socket that this object references. Both handles can be used to accept incoming connections and options set on one listener will affect the other.

#### `fn local_addr(&self) -> Result<SocketAddr>`

Returns the local socket address of this listener.

#### `fn set_nonblocking(&self, nonblocking: bool) -> Result<()>`

Moves the socket into or out of nonblocking mode.

#### `fn take_error(&self) -> Result<Option<Error>>`

Returns the value of the `SO_ERROR` option.

#### `fn incoming<'a>(&'a self) -> Incoming<'a>`

Returns an iterator over incoming connections.

The iterator will never return `None` and will also not yield the peer's `SocketAddr` structure.

## Trait Implementations

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

#### `fn fmt(&self, fmt: &mut Formatter) -> Result`

Formats the value using the given formatter.

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

#### `fn as_raw_fd(&self) -> RawFd`

Extracts the raw file descriptor. Read more

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

#### `unsafe fn from_raw_fd(fd: RawFd) -> UnixListener`

Constructs a new instances of `Self` from the given raw file descriptor. Read more

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

#### `fn into_raw_fd(self) -> RawFd`

Consumes this object, returning the raw underlying file descriptor. Read more

### `impl<'a> IntoIterator for &'a UnixListener`
[src]

#### `type Item = Result<UnixStream>`

The type of the elements being iterated over.

#### `type IntoIter = Incoming<'a>`

Which kind of iterator are we turning this into?

#### `fn into_iter(self) -> Incoming<'a>`

Creates an iterator from a value. Read more

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)