pub struct ListenOptions { /* private fields */ }Expand description
Options set on a listening socket before bind and listen.
use net_io::{ListenOptions, TcpListener};
let options = ListenOptions::new().backlog(4096).reuse_port(cfg!(target_os = "linux"));
let listener = TcpListener::bind_with("127.0.0.1:0", options)?;
println!("effective backlog {:?}", listener.info().backlog);Implementations§
Source§impl ListenOptions
impl ListenOptions
Sourcepub fn new() -> ListenOptions
pub fn new() -> ListenOptions
Backlog 1,024; reuse address on Unix, exclusive address use on Windows;
IPv6-only; TCP_NODELAY on accepted sockets.
Sourcepub fn backlog(self, n: u32) -> ListenOptions
pub fn backlog(self, n: u32) -> ListenOptions
The listen backlog (capped by the OS; the effective value is in ListenerInfo).
Sourcepub fn reuse_address(self, on: bool) -> ListenOptions
pub fn reuse_address(self, on: bool) -> ListenOptions
Unix: SO_REUSEADDR, so a restart binds while connections of the old
process linger. Windows: ignored, the port is always SO_EXCLUSIVEADDRUSE.
An exclusive listener there can already bind again at once after a restart,
and Windows SO_REUSEADDR means something else: another local socket could
bind the same port over the listener and take its connections.
Sourcepub fn reuse_port(self, on: bool) -> ListenOptions
pub fn reuse_port(self, on: bool) -> ListenOptions
SO_REUSEPORT (Unsupported on Windows).
Sourcepub fn ipv6_only(self, on: bool) -> ListenOptions
pub fn ipv6_only(self, on: bool) -> ListenOptions
IPV6_V6ONLY for IPv6 addresses (on by default; decision D-026).
Sourcepub fn send_buffer(self, bytes: u32) -> ListenOptions
pub fn send_buffer(self, bytes: u32) -> ListenOptions
SO_SNDBUF on the listener (before listen).
Sourcepub fn receive_buffer(self, bytes: u32) -> ListenOptions
pub fn receive_buffer(self, bytes: u32) -> ListenOptions
SO_RCVBUF on the listener (before listen, so window scaling is negotiated).
Sourcepub fn defer_accept(self, wait: Option<Duration>) -> ListenOptions
pub fn defer_accept(self, wait: Option<Duration>) -> ListenOptions
accept returns once the client has sent bytes, or after wait
(TCP_DEFER_ACCEPT, whole seconds; Unsupported off Linux). A client that
connects and stays silent costs no accept for that long. Cost: the gate sees
the connection later, and a server that speaks first must not use this.
Sourcepub fn fast_open(self, queue: Option<u32>) -> ListenOptions
pub fn fast_open(self, queue: Option<u32>) -> ListenOptions
Server TCP Fast Open with this many pending requests. Saves a round trip for a
client that returns. Security: the first flight of data can be replayed by the
network, so turn this on only for requests that are safe to run twice; the gate
and the PROXY check run as usual. Linux also needs net.ipv4.tcp_fastopen.
Sourcepub fn incoming_cpu(self, cpu: Option<u32>) -> ListenOptions
pub fn incoming_cpu(self, cpu: Option<u32>) -> ListenOptions
Accepts on this listener the connections the given CPU received
(SO_INCOMING_CPU, Linux; Unsupported elsewhere). For one reuse-port
listener per CPU.
Sourcepub fn per_worker(self, on: bool) -> ListenOptions
pub fn per_worker(self, on: bool) -> ListenOptions
One socket per reactor worker, in a SO_REUSEPORT group (Linux; Unsupported
elsewhere, InvalidConfig on the blocking driver). Each worker accepts on its
own socket in its own event loop, runs the caps and the gate there, and starts
the connection in the same turn: no accept thread, no hand-off between threads,
and no connection crosses to another worker. With ServerBuilder::placement
each socket also takes the connections its worker’s CPU received. Costs: a
socket per worker; the kernel’s hash decides the balance; the gate’s admit
runs on the worker, so a slow gate delays that worker’s other connections; and
such a listener cannot be handed off: closing one socket of a group resets what
is queued on it.
Sourcepub fn tcp_options(self, options: TcpOptions) -> ListenOptions
pub fn tcp_options(self, options: TcpOptions) -> ListenOptions
Options applied to every accepted socket.