Struct fd_queue::UnixListener

source · [−]

pub struct UnixListener { /* private fields */ }

Expand description

A structure representing a Unix domain socket server whose connected sockets have support for passing RawFd.

Implementations

source

impl UnixListener

source

pub fn bind(path: impl AsRef<Path>) -> Result<UnixListener>

Create a new UnixListener bound to the specified socket.

Examples

use fd_queue::UnixListener;
// let path = ...
let listener = match UnixListener::bind(&path) {
    Ok(listener) => listener,
    Err(e) => {
        println!("Can't bind the unix socket libtest: {}", e);
        return Ok(());
    }
};

source

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

Accepts a new incoming connection to this server.

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

Examples

use fd_queue::UnixListener;

// let path = ...
let listener = UnixListener::bind(&path)?;

let (sock, addr) = match listener.accept() {
    Ok((sock, addr)) => (sock, addr),
    Err(e) => {
        println!("Can't accept unix stream: {}", e);
        return Ok(());
    }
};

source

pub fn try_clone(&self) -> Result<UnixListener>

Create 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 will affect the other.

Examples

use fd_queue::UnixListener;

// let path = ...
let listener1 = UnixListener::bind(&path)?;

let listener2 = match listener1.try_clone() {
    Ok(listener) => listener,
    Err(e) => {
        println!("Can't clone listener: {}", e);
        return Ok(());
    }
};

source

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local address of of this listener.

Examples

use fd_queue::UnixListener;

// let path = ...
let listener = UnixListener::bind(&path)?;

let addr = match listener.local_addr() {
    Ok(addr) => addr,
    Err(e) => {
        println!("Couldn't get local address: {}", e);
        return Ok(());
    }
};

source

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

Return the value of the SO_ERROR option.

Examples

use fd_queue::UnixListener;

// let path = ...
let listener = UnixListener::bind(&path)?;

let err = match listener.take_error() {
    Ok(Some(err)) => err,
    Ok(None) => {
        println!("There was no SO_ERROR option pending.");
        return Ok(());
    }
    Err(e) => {
        println!("Couldn't get the SO_ERROR option: {}", e);
        return Ok(())
    }
};

source

pub fn incoming(&self) -> Incoming<'_>ⓘNotable traits for Incoming<'_>`impl Iterator for Incoming<'_> type Item = Result<UnixStream>;`

Returns an iterator over incoming connections.

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

Examples

use fd_queue::UnixListener;

// let path = ...
let listener = UnixListener::bind(&path)?;

let mut incoming = listener.incoming();

let sock = match incoming.next() {
    Some(Ok(sock)) => sock,
    Some(Err(e)) => {
        println!("Can't get the next incoming socket: {}", e);
        return Ok(());
    }
    None => unreachable!(),
};