Recommended way to handle TcpListener::accept() errors

[sammko]

Examples such as hello.rs simply propagate any errors returned by accept()

hyper/examples/hello.rs

Line 44 in 9c438e3

let (tcp, _) = listener.accept().await?;

The Linux accept(2) man page states the following:

Error handling
Linux accept() (and accept4()) passes already-pending network
errors on the new socket as an error code from accept(). This
behavior differs from other BSD socket implementations. For
reliable operation the application should detect the network
errors defined for the protocol after accept() and treat them
like EAGAIN by retrying. In the case of TCP/IP, these are
ENETDOWN, EPROTO, ENOPROTOOPT, EHOSTDOWN, ENONET, EHOSTUNREACH,
EOPNOTSUPP, and ENETUNREACH.

This suggests that at least some return codes of accept should be ignored and accept should be called again. The Rust documentation on TcpListener::accept (either std or tokio) is quite scant. I have found discussions with no conclusions.

Hyper v0.14 Server had some logic to differentiate accept Errors, but I believe this served a different purpose.

hyper/src/server/tcp.rs

Lines 279 to 286 in dedcb67

	fn is_connection_error(e: &io::Error) -> bool {
	matches!(
	e.kind(),
	io::ErrorKind::ConnectionRefused
	| io::ErrorKind::ConnectionAborted
	| io::ErrorKind::ConnectionReset
	)
	}

Is something like this correct or can it get stuck in a busy loop if something is wrong with the socket?

let stream = match listener.accept().await {
    Ok((stream, _)) => stream,
    #[cfg(target_os = "linux")]
    Err(e) => match e.raw_os_error() {
        Some(
            // Refer to accept(2)
            libc::EAGAIN
            | libc::ENETDOWN
            | libc::EPROTO
            | libc::ENOPROTOOPT
            | libc::EHOSTDOWN
            | libc::ENONET
            | libc::EHOSTUNREACH
            | libc::EOPNOTSUPP
            | libc::ENETUNREACH,
        ) => continue, // Should we sleep here?
        _ => return Err(anyhow!(e).context("Fatal accept error")),
    },
    #[cfg(not(target_os = "linux"))]
    Err(e) => return Err(anyhow!(e).context("Accept error")),
};

Does anyone have examples of Rust software where this is handled?

[sammko]

Or is this entirely handled by libc? accept(3) doesn't really talk about this.

[beroal]

See also https://utcc.utoronto.ca/~cks/space/blog/unix/AcceptErrnoProblem and https://stackoverflow.com/questions/76955978/which-socket-accept-errors-are-fatal .