listen:detect backlog parameter as in std. library

Define the `listen` backlog parameters as in the standard library.

On one hand, this helps avoid hardcoded or unsynchronized values. On the
other hand, it allows better control of default values depending on the
target.

This is an initial version which deals with issue #1872

Author: alexs-sh

src/net/tcp/listener.rs

@@ -13,6 +13,7 @@ use std::{fmt, io};
 
 use crate::io_source::IoSource;
 use crate::net::TcpStream;
+use crate::sys::get_listen_backlog_size;
 #[cfg(any(unix, target_os = "hermit"))]
 use crate::sys::tcp::set_reuseaddr;
 #[cfg(not(target_os = "wasi"))]
@@ -78,7 +79,7 @@ impl TcpListener {
         set_reuseaddr(&listener.inner, true)?;
 
         bind(&listener.inner, addr)?;
-        listen(&listener.inner, 1024)?;
+        listen(&listener.inner, get_listen_backlog_size())?;
         Ok(listener)
     }
 

src/sys/mod.rs

@@ -80,3 +80,60 @@ cfg_not_os_poll! {
         pub use self::unix::SourceFd;
     }
 }
+
+/// Define the `listen` backlog parameters as in the standard library. This
+/// helps avoid hardcoded unsynchronized values and allows better control of
+/// default values depending on the target.
+///
+/// Selecting a “valid” default value can be tricky due to:
+///
+/// - It often serves only as a hint and may be rounded, trimmed, or ignored by
+///   the OS.
+///
+/// - It is sometimes provided as a "magic" value, for example, -1. This
+///   value is undocumented and not standard, but it is often used to represent
+///   the largest possible backlog size. This happens due to signed/unsigned
+///   conversion and rounding to the upper bound performed by the OS.
+///
+/// - Default values vary depending on the OS and its version. Common defaults
+///   include: -1, 128, 1024, and 4096.
+///
+#[allow(dead_code)]
+pub(crate) const fn get_listen_backlog_size() -> i32 {
+    // Here is the original code from the standard library
+    // https://github.com/rust-lang/rust/blob/4f808ba6bf9f1c8dde30d009e73386d984491587/library/std/src/os/unix/net/listener.rs#L72
+    #[cfg(any(
+        target_os = "windows",
+        target_os = "redox",
+        target_os = "espidf",
+        target_os = "horizon"
+    ))]
+    const BACKLOG_SIZE: i32 = 128;
+
+    #[allow(dead_code)]
+    #[cfg(any(
+                // Silently capped to `/proc/sys/net/core/somaxconn`.
+                target_os = "linux",
+                // Silently capped to `kern.ipc.soacceptqueue`.
+                target_os = "freebsd",
+                // Silently capped to `kern.somaxconn sysctl`.
+                target_os = "openbsd",
+                // Silently capped to the default 128.
+                target_vendor = "apple",
+            ))]
+    const BACKLOG_SIZE: i32 = -1;
+
+    #[allow(dead_code)]
+    #[cfg(not(any(
+        target_os = "windows",
+        target_os = "redox",
+        target_os = "espidf",
+        target_os = "horizon",
+        target_os = "linux",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+    )))]
+    const BACKLOG_SIZE: i32 = libc::SOMAXCONN;
+    BACKLOG_SIZE
+}

src/sys/shell/tcp.rs

@@ -17,7 +17,7 @@ pub(crate) fn connect(_: &net::TcpStream, _: SocketAddr) -> io::Result<()> {
 }
 
 #[cfg(not(target_os = "wasi"))]
-pub(crate) fn listen(_: &net::TcpListener, _: u32) -> io::Result<()> {
+pub(crate) fn listen(_: &net::TcpListener, _: i32) -> io::Result<()> {
     os_required!();
 }
 

src/sys/unix/tcp.rs

@@ -1,4 +1,3 @@
-use std::convert::TryInto;
 use std::io;
 use std::mem::{size_of, MaybeUninit};
 use std::net::{self, SocketAddr};
@@ -38,8 +37,7 @@ pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<(
     }
 }
 
-pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> {
-    let backlog = backlog.try_into().unwrap_or(i32::MAX);
+pub(crate) fn listen(socket: &net::TcpListener, backlog: i32) -> io::Result<()> {
     syscall!(listen(socket.as_raw_fd(), backlog))?;
     Ok(())
 }

src/sys/unix/uds/listener.rs

@@ -6,6 +6,7 @@ use std::path::Path;
 use std::{io, mem};
 
 use crate::net::UnixStream;
+use crate::sys::get_listen_backlog_size;
 use crate::sys::unix::net::new_socket;
 use crate::sys::unix::uds::{path_offset, unix_addr};
 
@@ -16,7 +17,7 @@ pub(crate) fn bind_addr(address: &SocketAddr) -> io::Result<net::UnixListener> {
     let (unix_address, addrlen) = unix_addr(address);
     let sockaddr = &unix_address as *const libc::sockaddr_un as *const libc::sockaddr;
     syscall!(bind(fd, sockaddr, addrlen))?;
-    syscall!(listen(fd, 1024))?;
+    syscall!(listen(fd, get_listen_backlog_size()))?;
 
     Ok(socket)
 }

src/sys/windows/tcp.rs

@@ -46,11 +46,10 @@ pub(crate) fn connect(socket: &net::TcpStream, addr: SocketAddr) -> io::Result<(
     }
 }
 
-pub(crate) fn listen(socket: &net::TcpListener, backlog: u32) -> io::Result<()> {
+pub(crate) fn listen(socket: &net::TcpListener, backlog: i32) -> io::Result<()> {
     use std::convert::TryInto;
     use WinSock::listen;
 
-    let backlog = backlog.try_into().unwrap_or(i32::MAX);
     syscall!(
         listen(socket.as_raw_socket() as _, backlog),
         PartialEq::eq,