add more linux-specific TCP sockopts

Author: avsm

lib_eio_linux/eio_stubs.c

@@ -15,6 +15,7 @@
 #include <fcntl.h>
 #include <signal.h>
 #include <unistd.h>
+#include <string.h>
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 
@@ -258,3 +259,26 @@ CAMLprim value caml_eio_sockopt_int_get(value v_fd, value v_level, value v_optio
   if (ret == -1) uerror("getsockopt", Nothing);
   CAMLreturn(Val_int(val));
 }
+
+/* Socket option stubs for string options (e.g. TCP_CONGESTION) */
+CAMLprim value caml_eio_sockopt_string_set(value v_fd, value v_level, value v_option, value v_val) {
+  CAMLparam4(v_fd, v_level, v_option, v_val);
+  const char *str = String_val(v_val);
+  int ret = setsockopt(Int_val(v_fd), Int_val(v_level), Int_val(v_option),
+                       str, strlen(str) + 1);
+  if (ret == -1) uerror("setsockopt", Nothing);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value caml_eio_sockopt_string_get(value v_fd, value v_level, value v_option) {
+  CAMLparam3(v_fd, v_level, v_option);
+  CAMLlocal1(v_result);
+  char buffer[256];
+  socklen_t len = sizeof(buffer);
+  int ret = getsockopt(Int_val(v_fd), Int_val(v_level), Int_val(v_option),
+                       buffer, &len);
+  if (ret == -1) uerror("getsockopt", Nothing);
+  buffer[len < sizeof(buffer) ? len : sizeof(buffer) - 1] = '\0';
+  v_result = caml_copy_string(buffer);
+  CAMLreturn(v_result);
+}

lib_eio_linux/low_level.ml

@@ -629,15 +629,21 @@ module Process = struct
 end
 
 module Sockopt = struct
+  let tcp_maxseg = 2          (* TCP_MAXSEG from netinet/tcp.h *)
   let tcp_cork = 3           (* TCP_CORK from netinet/tcp.h *)
   let tcp_keepidle = 4       (* TCP_KEEPIDLE *)
   let tcp_keepintvl = 5      (* TCP_KEEPINTVL *)
   let tcp_keepcnt = 6        (* TCP_KEEPCNT *)
+  let tcp_linger2 = 8        (* TCP_LINGER2 *)
+  let tcp_defer_accept = 9   (* TCP_DEFER_ACCEPT *)
+  let tcp_congestion = 13    (* TCP_CONGESTION *)
   let tcp_user_timeout = 18  (* TCP_USER_TIMEOUT *)
   let ipproto_tcp = 6        (* IPPROTO_TCP *)
 
   external setsockopt_int : Unix.file_descr -> int -> int -> int -> unit = "caml_eio_sockopt_int_set"
   external getsockopt_int : Unix.file_descr -> int -> int -> int = "caml_eio_sockopt_int_get"
+  external setsockopt_string : Unix.file_descr -> int -> int -> string -> unit = "caml_eio_sockopt_string_set"
+  external getsockopt_string : Unix.file_descr -> int -> int -> string = "caml_eio_sockopt_string_get"
 
   (* Define Linux-specific socket options as extensions of Eio.Net.Sockopt.t *)
   type _ Eio.Net.Sockopt.t +=
@@ -646,6 +652,10 @@ module Sockopt = struct
     | TCP_KEEPINTVL : int Eio.Net.Sockopt.t
     | TCP_KEEPCNT : int Eio.Net.Sockopt.t
     | TCP_USER_TIMEOUT : int Eio.Net.Sockopt.t
+    | TCP_MAXSEG : int Eio.Net.Sockopt.t
+    | TCP_LINGER2 : int Eio.Net.Sockopt.t
+    | TCP_DEFER_ACCEPT : int Eio.Net.Sockopt.t
+    | TCP_CONGESTION : string Eio.Net.Sockopt.t
 
   let set : type a. Fd.t -> a Eio.Net.Sockopt.t -> a -> unit = fun fd opt v ->
     match opt with
@@ -664,6 +674,18 @@ module Sockopt = struct
     | TCP_USER_TIMEOUT ->
       Fd.use_exn "setsockopt" fd (fun unix_fd ->
         setsockopt_int unix_fd ipproto_tcp tcp_user_timeout v)
+    | TCP_MAXSEG ->
+      Fd.use_exn "setsockopt" fd (fun unix_fd ->
+        setsockopt_int unix_fd ipproto_tcp tcp_maxseg v)
+    | TCP_LINGER2 ->
+      Fd.use_exn "setsockopt" fd (fun unix_fd ->
+        setsockopt_int unix_fd ipproto_tcp tcp_linger2 v)
+    | TCP_DEFER_ACCEPT ->
+      Fd.use_exn "setsockopt" fd (fun unix_fd ->
+        setsockopt_int unix_fd ipproto_tcp tcp_defer_accept v)
+    | TCP_CONGESTION ->
+      Fd.use_exn "setsockopt" fd (fun unix_fd ->
+        setsockopt_string unix_fd ipproto_tcp tcp_congestion v)
     | _ -> Eio_unix.Net.Sockopt.set fd opt v
 
   let get : type a. Fd.t -> a Eio.Net.Sockopt.t -> a = fun fd opt ->
@@ -683,5 +705,17 @@ module Sockopt = struct
     | TCP_USER_TIMEOUT ->
       Fd.use_exn "getsockopt" fd (fun unix_fd ->
         getsockopt_int unix_fd ipproto_tcp tcp_user_timeout)
+    | TCP_MAXSEG ->
+      Fd.use_exn "getsockopt" fd (fun unix_fd ->
+        getsockopt_int unix_fd ipproto_tcp tcp_maxseg)
+    | TCP_LINGER2 ->
+      Fd.use_exn "getsockopt" fd (fun unix_fd ->
+        getsockopt_int unix_fd ipproto_tcp tcp_linger2)
+    | TCP_DEFER_ACCEPT ->
+      Fd.use_exn "getsockopt" fd (fun unix_fd ->
+        getsockopt_int unix_fd ipproto_tcp tcp_defer_accept)
+    | TCP_CONGESTION ->
+      Fd.use_exn "getsockopt" fd (fun unix_fd ->
+        getsockopt_string unix_fd ipproto_tcp tcp_congestion)
     | _ -> Eio_unix.Net.Sockopt.get fd opt
 end

lib_eio_linux/low_level.mli

@@ -216,6 +216,18 @@ module Sockopt : sig
     | TCP_USER_TIMEOUT : int Eio.Net.Sockopt.t
         (** Maximum time (in milliseconds) that transmitted data may remain unacknowledged
             before TCP will forcibly close the connection. *)
+    | TCP_MAXSEG : int Eio.Net.Sockopt.t
+        (** The maximum segment size for outgoing TCP packets. If set before connection
+            establishment, it also changes the MSS value announced to the other end. *)
+    | TCP_LINGER2 : int Eio.Net.Sockopt.t
+        (** The lifetime of orphaned FIN_WAIT2 state sockets (in seconds).
+            Not to be confused with SO_LINGER. *)
+    | TCP_DEFER_ACCEPT : int Eio.Net.Sockopt.t
+        (** Allow a listener to be awakened only when data arrives on the socket.
+            Value is the maximum time in seconds to wait for data. *)
+    | TCP_CONGESTION : string Eio.Net.Sockopt.t
+        (** Set the TCP congestion control algorithm to be used (e.g., "cubic", "reno").
+            Unprivileged processes are restricted to algorithms in tcp_allowed_congestion_control. *)
 
   val set : fd -> 'a Eio.Net.Sockopt.t -> 'a -> unit
   (** [set fd opt v] sets socket option [opt] to value [v] on file descriptor [fd]. *)

lib_eio_linux/tests/network.md

@@ -0,0 +1,87 @@
+# Linux-specific networking tests
+
+```ocaml
+# #require "eio_linux";;
+# #require "eio.unix";;
+# open Eio.Std;;
+# let addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, 0);;
+val addr : [> `Tcp of [> `V4 ] Eio.Net.Ipaddr.t * int ] =
+  `Tcp ("\127\000\000\001", 0)
+```
+
+## Linux-specific TCP socket options
+
+Test Linux-specific TCP socket options:
+
+```ocaml
+# Eio_linux.run @@ fun env ->
+  Switch.run @@ fun sw ->
+  let net = env#net in
+  let listen_sock = Eio.Net.listen net ~sw ~reuse_addr:true ~backlog:5 addr in
+  let listen_fd = Eio_unix.Net.fd listen_sock in
+  let listening_addr = Eio.Net.listening_addr listen_sock in
+  let module ELS = Eio_linux.Low_level.Sockopt in
+  (* Test TCP_DEFER_ACCEPT on listening socket *)
+  ELS.set listen_fd ELS.TCP_DEFER_ACCEPT 5;
+  let defer = ELS.get listen_fd ELS.TCP_DEFER_ACCEPT in
+  traceln "TCP_DEFER_ACCEPT on listening socket: %s" (if defer > 0 then "enabled" else "disabled");
+
+  (* Create a TCP connection for other tests *)
+  Eio.Fiber.both
+    (fun () ->
+      let client = Eio.Net.connect ~sw net listening_addr in
+      let fd = Eio_unix.Net.fd client in
+
+      (* Test TCP_CORK *)
+      ELS.set fd ELS.TCP_CORK true;
+      let cork = ELS.get fd ELS.TCP_CORK in
+      traceln "TCP_CORK enabled: %b" cork;
+      ELS.set fd ELS.TCP_CORK false;
+      let cork = ELS.get fd ELS.TCP_CORK in
+      traceln "TCP_CORK disabled: %b" cork;
+
+      (* Test TCP_KEEPIDLE, TCP_KEEPINTVL, TCP_KEEPCNT *)
+      ELS.set fd ELS.TCP_KEEPIDLE 60;
+      let keepidle = ELS.get fd ELS.TCP_KEEPIDLE in
+      traceln "TCP_KEEPIDLE: %d seconds" keepidle;
+
+      ELS.set fd ELS.TCP_KEEPINTVL 10;
+      let keepintvl = ELS.get fd ELS.TCP_KEEPINTVL in
+      traceln "TCP_KEEPINTVL: %d seconds" keepintvl;
+
+      ELS.set fd ELS.TCP_KEEPCNT 5;
+      let keepcnt = ELS.get fd ELS.TCP_KEEPCNT in
+      traceln "TCP_KEEPCNT: %d probes" keepcnt;
+
+      (* Test TCP_LINGER2 *)
+      ELS.set fd ELS.TCP_LINGER2 110;
+      let linger2 = ELS.get fd ELS.TCP_LINGER2 in
+      traceln "TCP_LINGER2: %d seconds" linger2;
+
+      (* Test TCP_CONGESTION *)
+      let congestion = ELS.get fd ELS.TCP_CONGESTION in
+      traceln "Current TCP_CONGESTION algorithm: %s" congestion;
+
+      (* Try to set cubic if available - may fail based on system config *)
+      (try
+        ELS.set fd ELS.TCP_CONGESTION "cubic";
+        let new_congestion = ELS.get fd ELS.TCP_CONGESTION in
+        traceln "Successfully set TCP_CONGESTION to: %s" new_congestion
+      with _ ->
+        traceln "Could not change TCP_CONGESTION (normal for unprivileged)");
+
+      Eio.Flow.close client)
+    (fun () ->
+      let conn, _addr = Eio.Net.accept ~sw listen_sock in
+      Eio.Flow.close conn);;
++TCP_DEFER_ACCEPT on listening socket: enabled
++TCP_CORK enabled: true
++TCP_CORK disabled: false
++TCP_KEEPIDLE: 60 seconds
++TCP_KEEPINTVL: 10 seconds
++TCP_KEEPCNT: 5 probes
++TCP_LINGER2: 110 seconds
++Current TCP_CONGESTION algorithm: cubic
++Successfully set TCP_CONGESTION to: cubic
+- : unit = ()
+```

tests/network.md

@@ -652,6 +652,7 @@ Error handling for read-only options:
 - : unit = ()
 ```
 
+
 ## Getaddrinfo
 
 ```ocaml