pub struct UnixListener { /* fields omitted */ }
A structure representing a Unix domain socket server.
use std::thread;
use unix_socket::{UnixStream, UnixListener};
fn handle_client(stream: UnixStream) {
}
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
for stream in listener.incoming() {
match stream {
Ok(stream) => {
thread::spawn(|| handle_client(stream));
}
Err(err) => {
break;
}
}
}
drop(listener);
Creates a new UnixListener
bound to the specified socket.
Linux provides, as a nonportable extension, a separate "abstract"
address namespace as opposed to filesystem-based addressing. If path
begins with a null byte, it will be interpreted as an "abstract"
address. Otherwise, it will be interpreted as a "pathname" address,
corresponding to a path on the filesystem.
use unix_socket::UnixListener;
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
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.
use unix_socket::UnixListener;
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
let (client_stream, addr) = listener.accept().unwrap();
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.
use unix_socket::UnixListener;
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
let copy = listener.try_clone().unwrap();
Returns the local socket address of this listener.
use unix_socket::UnixListener;
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
println!("{}", match listener.local_addr() {
Ok(addr) => format!("local address: {:?}", addr),
Err(_) => "no local address".to_owned(),
});
Moves the socket into or out of nonblocking mode.
use unix_socket::UnixListener;
let mut listener = UnixListener::bind("/path/to/the/socket").unwrap();
listener.set_nonblocking(true).unwrap();
Returns the value of the SO_ERROR
option.
use unix_socket::UnixListener;
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
println!("{}", match listener.take_error() {
Ok(ret) => format!("error: {:?}", ret),
Err(_) => "error".to_owned(),
});
Returns an iterator over incoming connections.
The iterator will never return None
and will also not yield the
peer's SocketAddr
structure.
use std::thread;
use unix_socket::{UnixStream, UnixListener};
fn handle_client(stream: UnixStream) {
}
let listener = UnixListener::bind("/path/to/the/socket").unwrap();
for stream in listener.incoming() {
match stream {
Ok(stream) => {
println!("incoming connection succeeded!");
thread::spawn(|| handle_client(stream));
}
Err(err) => {
println!("incoming connection failed...");
}
}
}
Formats the value using the given formatter. Read more
Constructs a new instance of Self
from the given raw file descriptor. Read more
Consumes this object, returning the raw underlying file descriptor. Read more
type Error = !
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Immutably borrows from an owned value. Read more
🔬 This is a nightly-only experimental API. (get_type_id
)
this method will likely be replaced by an associated static
type Error = <U as TryFrom<T>>::Error
🔬 This is a nightly-only experimental API. (try_from
)
The type returned in the event of a conversion error.
🔬 This is a nightly-only experimental API. (try_from
)
Mutably borrows from an owned value. Read more