add server::congestion_control config setting

Author: miquels

Cargo.lock

@@ -64,7 +64,7 @@ regex = "1.5.4"
 rustls-pemfile = "1.0.0"
 serde = { version = "1.0.125", features = ["derive"] }
 serde_json = "1.0.64"
-socket2 = "0.4.0"
+socket2 = { version = "0.5.5", features = ["all"] }
 time = "0.1.42"
 tls-listener = { version = "0.5.1", features = [ "hyper-h1", "hyper-h2", "rustls" ] }
 tokio = { version = "1.5.0", features = ["full"] }

Cargo.toml

@@ -45,6 +45,8 @@ pub struct Server {
     pub identification: Option<String>,
     #[serde(default)]
     pub cors:             bool,
+    #[serde(default)]
+    pub congestion_control: Option<String>,
 }
 
 #[derive(Deserialize, Debug, Clone, Default)]

src/config.rs

@@ -21,6 +21,7 @@ mod rootfs;
 #[doc(hidden)]
 pub mod router;
 mod suid;
+mod tcp_cong;
 mod tls;
 mod unixuser;
 mod userfs;
@@ -458,7 +459,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         // Plaintext servers.
         for sockaddr in addrs {
-            let listener = match make_listener(sockaddr) {
+            let listener = match make_listener(&config.server, sockaddr) {
                 Ok(l) => l,
                 Err(e) => {
                     eprintln!("{}: listener on {:?}: {}", PROGNAME, &sockaddr, e);
@@ -495,7 +496,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             for sockaddr in tls_addrs {
                 let tls_acceptor = tls_acceptor.clone();
-                let listener = make_listener(sockaddr).unwrap_or_else(|e| {
+                let listener = make_listener(&config.server, sockaddr).unwrap_or_else(|e| {
                     eprintln!("{}: listener on {:?}: {}", PROGNAME, &sockaddr, e);
                     exit(1);
                 });
@@ -624,9 +625,17 @@ fn expand_directory(dir: &str, pwd: Option<&Arc<unixuser::User>>) -> Result<Stri
 
 // Make a new TcpListener, and if it's a V6 listener, set the
 // V6_V6ONLY socket option on it.
-fn make_listener(addr: SocketAddr) -> io::Result<tokio::net::TcpListener> {
+fn make_listener(srv: &config::Server, addr: SocketAddr) -> io::Result<tokio::net::TcpListener> {
     use socket2::{Domain, SockAddr, Socket, Type, Protocol};
     let s = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?;
+    if let Some(cong) = srv.congestion_control.as_ref() {
+        tcp_cong::set_congestion_control(&s, cong).map_err(|e| {
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("congestion control {}: {}", cong, e),
+            )
+        })?;
+    }
     if addr.is_ipv6() {
         s.set_only_v6(true)?;
     }

src/main.rs

@@ -0,0 +1,57 @@
+use std::io;
+use socket2::Socket;
+
+#[cfg(not(any(target_os = "freebsd", target_os = "linux")))]
+pub fn set_congestion_control(_sock: &Socket, _algo: &str) -> io::Result<()> {
+    return Err(io::Error::new(io::ErrorKind::InvalidInput, "not implemented"));
+}
+
+#[cfg(target_os = "linux")]
+pub fn set_congestion_control(sock: &Socket, algo: &str) -> io::Result<()> {
+    sock.set_tcp_congestion(algo.as_bytes())
+}
+
+#[cfg(target_os = "freebsd")]
+pub fn set_congestion_control(sock: &Socket, algo: &str) -> io::Result<()> {
+    match algo {
+        "bbr" => set_tcp_functions(sock, algo)?,
+        "rack" => set_tcp_functions(sock, algo)?,
+        _ => {
+            set_tcp_functions(sock, "freebsd")?;
+            sock.set_tcp_congestion(algo.as_bytes())?;
+        },
+    }
+    Ok(())
+}
+
+#[cfg(target_os = "freebsd")]
+fn set_tcp_functions(sock: &Socket, funcs: &str) -> io::Result<()> {
+    const TCP_FUNCTION_BLK: libc::c_int = 8192;
+    let slen = funcs.len();
+    if slen >= libc::TCP_FUNCTION_NAME_LEN_MAX as usize {
+        return Err(io::Error::new(io::ErrorKind::InvalidInput, "name too long"));
+    }
+    let mut function_set_name = [0 as libc::c_char; libc::TCP_FUNCTION_NAME_LEN_MAX as usize];
+    let bytes = funcs.as_bytes();
+    for idx in 0..slen {
+        function_set_name[idx] = bytes[idx] as libc::c_char;
+    }
+    let fsn = libc::tcp_function_set {
+        function_set_name,
+        pcbcnt: 0,
+    };
+    use std::os::fd::AsRawFd;
+    let res = unsafe {
+        libc::setsockopt(
+            sock.as_raw_fd(),
+            libc::IPPROTO_TCP,
+            TCP_FUNCTION_BLK,
+            &fsn as *const libc::tcp_function_set as *const libc::c_void,
+            std::mem::size_of_val(&fsn) as libc::socklen_t,
+        )
+    };
+    if res == 0 {
+        return Ok(());
+    }
+    Err(io::Error::last_os_error())
+}