Added capability to set TCP ACK Frequency on Windows

src/socket.rs

@@ -2280,6 +2280,35 @@ impl Socket {
             )
         }
     }
+
+    /// Sets the number of TCP segments that must be received 
+    /// before the delayed ACK timer is ignored for this socket.
+    ///
+    /// Currently this is only controllable per socket on Windows. 
+    ///
+    /// # Notes
+    ///
+    /// * On Windows, this will invoke the `SIO_TCP_SET_ACK_FREQUENCY` IOCTL 
+    ///   on the socket.
+    /// * This can be used to achieve results similiar to `TCP_QUICKACK` on 
+    ///   Windows by setting frequency to 1, but on a permanent basis. 
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use socket2::{Socket, Domain, Type, Protocol};
+    ///
+    /// # fn main() -> std::io::Result<()> {
+    /// let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP))?;
+    ///
+    /// socket.set_tcp_ack_frequency(1)?;
+    /// # Ok(()) }
+    /// ```
+    ///
+    #[cfg(all(feature = "all", windows))]
+    pub fn set_tcp_ack_frequency(&self, frequency: u8) -> io::Result<()> {
+        sys::set_tcp_ack_frequency(self.as_raw(), frequency)
+    }
 }
 
 impl Read for Socket {

src/sys/windows.rs

@@ -26,6 +26,7 @@ use windows_sys::Win32::Networking::WinSock::{
     POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, SD_BOTH, SD_RECEIVE, SD_SEND, SIO_KEEPALIVE_VALS,
     SOCKET_ERROR, WSABUF, WSAEMSGSIZE, WSAESHUTDOWN, WSAPOLLFD, WSAPROTOCOL_INFOW,
     WSA_FLAG_NO_HANDLE_INHERIT, WSA_FLAG_OVERLAPPED, WSA_FLAG_REGISTERED_IO,
+    SIO_TCP_SET_ACK_FREQUENCY, TCP_ACK_FREQUENCY_PARAMETERS,
 };
 #[cfg(feature = "all")]
 use windows_sys::Win32::Networking::WinSock::{
@@ -798,6 +799,29 @@ pub(crate) fn set_tcp_keepalive(socket: RawSocket, keepalive: &TcpKeepalive) ->
     Ok(())
 }
 
+pub(crate) fn set_tcp_ack_frequency(socket: RawSocket, frequency: u8) -> io::Result<()> {
+    let mut freq_params = TCP_ACK_FREQUENCY_PARAMETERS {
+        TcpDelayedAckFrequency: frequency,
+    };
+
+    let mut out = 0;
+    syscall!(
+        WSAIoctl(
+            socket,
+            SIO_TCP_SET_ACK_FREQUENCY,
+            &mut freq_params as *mut _ as *mut _,
+            size_of::<TCP_ACK_FREQUENCY_PARAMETERS>() as _,
+            ptr::null_mut(),
+            0,
+            &mut out,
+            ptr::null_mut(),
+            None,
+        ),
+        PartialEq::eq,
+        SOCKET_ERROR
+    ).map(|_| ())
+}
+
 /// Caller must ensure `T` is the correct type for `level` and `optname`.
 // NOTE: `optname` is actually `i32`, but all constants are `u32`.
 pub(crate) unsafe fn getsockopt<T>(socket: RawSocket, level: c_int, optname: i32) -> io::Result<T> {

tests/socket.rs

@@ -1824,6 +1824,22 @@ fn tcp_congestion() {
     );
 }
 
+#[test]
+#[cfg(all(feature = "all", windows))]
+fn tcp_set_ack_frequency() {
+    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
+    match socket.set_tcp_ack_frequency(1) {
+        Ok(_) => {},
+        Err(err) => panic!("set_tcp_ack_frequency on tcp socket should succeed, error: {err}"),
+    }
+
+    let socket = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP)).unwrap();
+    match socket.set_tcp_ack_frequency(1) {
+        Ok(_) => panic!("set_tcp_ack_frequency on udp socket should fail"),
+        Err(err) => assert_eq!(err.raw_os_error(), Some(windows_sys::Win32::Networking::WinSock::WSAEOPNOTSUPP)),
+    }
+}
+
 #[test]
 #[ignore = "DCCP support is not enabled in all kernels of majors Linux distros"]
 #[cfg(all(feature = "all", target_os = "linux"))]