set default tcp keepalive

readme.md

@@ -151,6 +151,7 @@ PROXY OPTIONS:
 TIMEOUT OPTIONS:
         --tcp-timeout <second>    override tcp timeout
         --udp-timeout <second>    override udp timeout
+        --tcp-keepalive <second>  override default tcp keepalive interval(15s)
 
 SUBCOMMANDS:
     convert    convert your legacy configuration into an advanced one
@@ -260,6 +261,7 @@ remote = "www.google.com:443"
 ├── network
 │   ├── no_tcp
 │   ├── use_udp
+│   ├── tcp_keepalive
 │   ├── tcp_timeout
 │   ├── udp_timeout
 │   ├── send_proxy
@@ -486,6 +488,14 @@ default: false
 
 ~~default: false~~
 
+#### network.tcp_keepalive: unsigned int64
+
+TCP Keepalive interval.
+
+To use system tcp keepalive interval, you need to explicitly set timeout value to 0.
+
+default: 15
+
 #### network.tcp_timeout: unsigned int
 
 This is **connect** timeout. An attempt to connect to a remote peer fails after waiting for a period of time.

realm_core/Cargo.toml

@@ -27,6 +27,7 @@ pin-project = "1"
 trust-dns-resolver = "0.22"
 tokio = { version = "1.18", features = ["rt", "net", "time"] }
 proxy-protocol = { version = "0.5", optional = true }
+socket2 = "0.5.5"
 
 [features]
 default = []

realm_core/src/endpoint.rs

@@ -37,6 +37,7 @@ impl ProxyOpts {
 /// Connect or associate options.
 #[derive(Debug, Default, Clone)]
 pub struct ConnectOpts {
+    pub tcp_keepalive: u64,
     pub connect_timeout: usize,
     pub associate_timeout: usize,
     pub bind_address: Option<SocketAddr>,
@@ -86,6 +87,7 @@ impl Display for Endpoint {
 impl Display for ConnectOpts {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let ConnectOpts {
+            tcp_keepalive,
             connect_timeout,
             associate_timeout,
             bind_address,
@@ -126,8 +128,8 @@ impl Display for ConnectOpts {
 
         write!(
             f,
-            "connect-timeout={}s, associate-timeout={}s; ",
-            connect_timeout, associate_timeout
+            "tcp-keepalive={}s connect-timeout={}s, associate-timeout={}s; ",
+            tcp_keepalive, connect_timeout, associate_timeout
         )?;
 
         #[cfg(feature = "transport")]

realm_core/src/tcp/middle.rs

@@ -1,4 +1,5 @@
 use std::io::Result;
+use std::time::Duration;
 
 use tokio::net::TcpStream;
 
@@ -16,7 +17,6 @@ use super::transport;
 
 use crate::trick::Ref;
 use crate::endpoint::{RemoteAddr, ConnectOpts};
-
 #[allow(unused)]
 pub async fn connect_and_relay(
     mut local: TcpStream,
@@ -33,6 +33,8 @@ pub async fn connect_and_relay(
 
         #[cfg(feature = "balance")]
         balancer,
+
+        tcp_keepalive,
         ..
     } = conn_opts.as_ref();
 
@@ -75,6 +77,16 @@ pub async fn connect_and_relay(
 
     // connect!
     let mut remote = socket::connect(raddr, conn_opts.as_ref()).await?;
+
+    if *tcp_keepalive > 0 {
+        let sockref = socket2::SockRef::from(&remote);
+        let mut ka = socket2::TcpKeepalive::new();
+
+        ka = ka
+            .with_time(Duration::from_secs(*tcp_keepalive))
+            .with_interval(Duration::from_secs(*tcp_keepalive));
+        let _ = sockref.set_tcp_keepalive(&ka);
+    }
     log::info!("[tcp]{} => {} as {}", local.peer_addr()?, raddr, remote.peer_addr()?);
 
     // after connected

realm_core/src/tcp/mod.rs

@@ -14,6 +14,7 @@ mod proxy;
 mod transport;
 
 use std::io::{ErrorKind, Result};
+use std::time::Duration;
 
 use crate::trick::Ref;
 use crate::endpoint::Endpoint;
@@ -50,7 +51,15 @@ pub async fn run_tcp(endpoint: Endpoint) -> Result<()> {
 
         // ignore error
         let _ = local.set_nodelay(true);
+        if conn_opts.tcp_keepalive > 0 {
+            let sockref = socket2::SockRef::from(&local);
+            let mut ka = socket2::TcpKeepalive::new();
+            ka = ka
+                .with_time(Duration::from_secs(conn_opts.tcp_keepalive))
+                .with_interval(Duration::from_secs(conn_opts.tcp_keepalive));
 
+            let _ = sockref.set_tcp_keepalive(&ka);
+        }
         tokio::spawn(async move {
             match connect_and_relay(local, raddr, conn_opts, extra_raddrs).await {
                 Ok(..) => log::debug!("[tcp]{} => {}, finish", addr, raddr.as_ref()),

src/cmd/flag.rs

@@ -222,6 +222,12 @@ pub fn add_global_options(app: Command) -> Command {
             .value_name("second")
             .takes_value(true)
             .display_order(1),
+        Arg::new("tcp_keepalive")
+            .long("tcp-keepalive")
+            .help("override default tcp keepalive interval(15s)")
+            .value_name("second")
+            .takes_value(true)
+            .display_order(2),
     ]);
 
     app

src/conf/net.rs

@@ -2,7 +2,7 @@ use serde::{Serialize, Deserialize};
 use realm_core::endpoint::{ConnectOpts, ProxyOpts};
 
 use super::Config;
-use crate::consts::{TCP_TIMEOUT, UDP_TIMEOUT};
+use crate::consts::{TCP_KEEPALIVE, TCP_TIMEOUT, UDP_TIMEOUT};
 use crate::consts::PROXY_PROTOCOL_VERSION;
 use crate::consts::PROXY_PROTOCOL_TIMEOUT;
 
@@ -31,6 +31,10 @@ pub struct NetConf {
     #[serde(default)]
     pub accept_proxy_timeout: Option<usize>,
 
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tcp_keepalive: Option<u64>,
+
     #[serde(default)]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tcp_timeout: Option<usize>,
@@ -53,7 +57,7 @@ impl Config for NetConf {
     fn is_empty(&self) -> bool {
         crate::empty![self =>
             send_proxy, accept_proxy, send_proxy_version, accept_proxy_timeout,
-            tcp_timeout, udp_timeout
+            tcp_keepalive, tcp_timeout, udp_timeout
         ]
     }
 
@@ -69,7 +73,7 @@ impl Config for NetConf {
 
         let no_tcp = unbox!(no_tcp);
         let use_udp = unbox!(use_udp);
-
+        let tcp_keepalive = unbox!(tcp_keepalive, TCP_KEEPALIVE);
         let tcp_timeout = unbox!(tcp_timeout, TCP_TIMEOUT);
         let udp_timeout = unbox!(udp_timeout, UDP_TIMEOUT);
 
@@ -80,6 +84,7 @@ impl Config for NetConf {
         let accept_proxy_timeout = unbox!(accept_proxy_timeout, PROXY_PROTOCOL_TIMEOUT);
 
         let conn_opts = ConnectOpts {
+            tcp_keepalive: tcp_keepalive,
             connect_timeout: tcp_timeout,
             associate_timeout: udp_timeout,
 
@@ -114,6 +119,7 @@ impl Config for NetConf {
 
         rst!(self, no_tcp, other);
         rst!(self, use_udp, other);
+        rst!(self, tcp_keepalive, other);
         rst!(self, tcp_timeout, other);
         rst!(self, udp_timeout, other);
         rst!(self, send_proxy, other);
@@ -129,6 +135,7 @@ impl Config for NetConf {
 
         take!(self, no_tcp, other);
         take!(self, use_udp, other);
+        take!(self, tcp_keepalive, other);
         take!(self, tcp_timeout, other);
         take!(self, udp_timeout, other);
         take!(self, send_proxy, other);
@@ -155,6 +162,7 @@ impl Config for NetConf {
         let no_tcp = unpack!("no_tcp");
         let use_udp = unpack!("use_udp");
 
+        let tcp_keepalive = unpack!("tcp_keepalive", u64);
         let tcp_timeout = unpack!("tcp_timeout", usize);
         let udp_timeout = unpack!("udp_timeout", usize);
 
@@ -167,6 +175,7 @@ impl Config for NetConf {
         Self {
             no_tcp,
             use_udp,
+            tcp_keepalive,
             tcp_timeout,
             udp_timeout,
             send_proxy,

src/consts.rs

@@ -4,6 +4,7 @@ use std::fmt::{Display, Formatter};
 pub const DEFAULT_LOG_FILE: &str = "stdout";
 
 // default timeout
+pub const TCP_KEEPALIVE: u64 = 15;
 pub const TCP_TIMEOUT: usize = 5;
 pub const UDP_TIMEOUT: usize = 30;