Bump version v7.9.1

Cargo.lock

@@ -1608,7 +1608,7 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "wstunnel"
-version = "7.9.0"
+version = "7.9.1"
 dependencies = [
  "ahash",
  "anyhow",
@@ -1631,6 +1631,7 @@ dependencies = [
  "rustls-pemfile",
  "scopeguard",
  "serde",
+ "socket2 0.5.5",
  "testcontainers",
  "tokio",
  "tokio-fd",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wstunnel"
-version = "7.9.0"
+version = "7.9.1"
 edition = "2021"
 repository = "https://github.com/erebe/wstunnel.git"
 
@@ -39,6 +39,7 @@ log = "0.4.20"
 
 bb8 = { version = "0.8", features = [] }
 async-trait = "0.1.74"
+socket2 = { version = "0.5.5", features = [] }
 
 [target.'cfg(target_family = "unix")'.dependencies]
 tokio-fd = "0.3.0"

src/tunnel/io.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadHalf, WriteHalf};
 use tokio::select;
 use tokio::sync::oneshot;
+use tokio::time::Instant;
 use tracing::log::debug;
 use tracing::{error, info, trace, warn};
 
@@ -24,7 +25,10 @@ pub(super) async fn propagate_read(
 
     // We do our own pin_mut! to avoid shadowing timeout and be able to reset it, on next loop iteration
     // We reuse the future to avoid creating a timer in the tight loop
-    let timeout = tokio::time::interval_at(tokio::time::Instant::now() + ping_frequency, ping_frequency);
+    let start_at = Instant::now()
+        .checked_add(ping_frequency)
+        .unwrap_or(Instant::now() + Duration::from_secs(3600 * 24));
+    let timeout = tokio::time::interval_at(start_at, ping_frequency);
     pin_mut!(timeout);
 
     pin_mut!(local_rx);

src/udp.rs

@@ -8,7 +8,6 @@ use std::future::Future;
 use std::io;
 use std::io::{Error, ErrorKind};
 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
-use std::os::fd::AsRawFd;
 
 use log::warn;
 use std::pin::{pin, Pin};
@@ -36,24 +35,20 @@ struct UdpServer {
 }
 
 impl UdpServer {
-    pub fn new(listener: Arc<UdpSocket>, timeout: Option<Duration>) -> Self {
+    pub fn new(listener: UdpSocket, timeout: Option<Duration>) -> Self {
-        unsafe {
+        let socket = socket2::Socket::from(listener.into_std().unwrap());
-            // Increase socket buffer length to 64MB
+
-            let buf_len: libc::c_int = 64 * 1024 * 1024;
+        // Increase receive buffer
-            let ret = libc::setsockopt(
+        if let Err(err) = socket.set_recv_buffer_size(64 * 1024 * 1024) {
-                listener.as_raw_fd(),
+            warn!("Cannot set UDP server recv buffer: {}", err);
-                libc::SOL_SOCKET,
+        }
-                libc::SO_RCVBUF,
+
-                &buf_len as *const _ as *const libc::c_void,
+        if let Err(err) = socket.set_send_buffer_size(64 * 1024 * 1024) {
-                std::mem::size_of_val(&buf_len) as libc::socklen_t,
+            warn!("Cannot set UDP server recv buffer: {}", err);
-            );
-            if ret != 0 {
-                warn!("Cannot set UDP server recv buffer: {}", io::Error::last_os_error());
         }
-        };
 
         Self {
-            listener,
+            listener: Arc::new(UdpSocket::from_std(socket.into()).unwrap()),
             peers: HashMap::with_hasher(ahash::RandomState::new()),
             keys_to_delete: Default::default(),
             cnx_timeout: timeout,
@@ -210,7 +205,7 @@ pub async fn run_server(
         .await
         .with_context(|| format!("Cannot create UDP server {:?}", bind))?;
 
-    let udp_server = UdpServer::new(Arc::new(listener), timeout);
+    let udp_server = UdpServer::new(listener, timeout);
     let stream = stream::unfold((udp_server, None), |(mut server, peer_with_data)| async move {
         // New returned peer hasn't read its data yet, await for it.
         if let Some(await_peer) = peer_with_data {