aboutsummaryrefslogtreecommitdiff
path: root/src/sys/unix/tcp.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/sys/unix/tcp.rs')
-rw-r--r--src/sys/unix/tcp.rs304
1 files changed, 295 insertions, 9 deletions
diff --git a/src/sys/unix/tcp.rs b/src/sys/unix/tcp.rs
index 65b7400..9e1d700 100644
--- a/src/sys/unix/tcp.rs
+++ b/src/sys/unix/tcp.rs
@@ -1,12 +1,26 @@
+use std::convert::TryInto;
use std::io;
use std::mem;
use std::mem::{size_of, MaybeUninit};
use std::net::{self, SocketAddr};
-use std::time::Duration;
use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::time::Duration;
use crate::sys::unix::net::{new_socket, socket_addr, to_socket_addr};
+use crate::net::TcpKeepalive;
+#[cfg(any(target_os = "openbsd", target_os = "netbsd", target_os = "haiku"))]
+use libc::SO_KEEPALIVE as KEEPALIVE_TIME;
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+use libc::TCP_KEEPALIVE as KEEPALIVE_TIME;
+#[cfg(not(any(
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "openbsd",
+ target_os = "netbsd",
+ target_os = "haiku"
+)))]
+use libc::TCP_KEEPIDLE as KEEPALIVE_TIME;
pub type TcpSocket = libc::c_int;
pub(crate) fn new_v4_socket() -> io::Result<TcpSocket> {
@@ -19,14 +33,14 @@ pub(crate) fn new_v6_socket() -> io::Result<TcpSocket> {
pub(crate) fn bind(socket: TcpSocket, addr: SocketAddr) -> io::Result<()> {
let (raw_addr, raw_addr_length) = socket_addr(&addr);
- syscall!(bind(socket, raw_addr, raw_addr_length))?;
+ syscall!(bind(socket, raw_addr.as_ptr(), raw_addr_length))?;
Ok(())
}
pub(crate) fn connect(socket: TcpSocket, addr: SocketAddr) -> io::Result<net::TcpStream> {
let (raw_addr, raw_addr_length) = socket_addr(&addr);
- match syscall!(connect(socket, raw_addr, raw_addr_length)) {
+ match syscall!(connect(socket, raw_addr.as_ptr(), raw_addr_length)) {
Err(err) if err.raw_os_error() != Some(libc::EINPROGRESS) => {
Err(err)
}
@@ -37,8 +51,6 @@ pub(crate) fn connect(socket: TcpSocket, addr: SocketAddr) -> io::Result<net::Tc
}
pub(crate) fn listen(socket: TcpSocket, backlog: u32) -> io::Result<net::TcpListener> {
- use std::convert::TryInto;
-
let backlog = backlog.try_into().unwrap_or(i32::max_value());
syscall!(listen(socket, backlog))?;
Ok(unsafe { net::TcpListener::from_raw_fd(socket) })
@@ -56,7 +68,8 @@ pub(crate) fn set_reuseaddr(socket: TcpSocket, reuseaddr: bool) -> io::Result<()
libc::SO_REUSEADDR,
&val as *const libc::c_int as *const libc::c_void,
size_of::<libc::c_int>() as libc::socklen_t,
- )).map(|_| ())
+ ))
+ .map(|_| ())
}
pub(crate) fn get_reuseaddr(socket: TcpSocket) -> io::Result<bool> {
@@ -84,7 +97,8 @@ pub(crate) fn set_reuseport(socket: TcpSocket, reuseport: bool) -> io::Result<()
libc::SO_REUSEPORT,
&val as *const libc::c_int as *const libc::c_void,
size_of::<libc::c_int>() as libc::socklen_t,
- )).map(|_| ())
+ ))
+ .map(|_| ())
}
#[cfg(all(unix, not(any(target_os = "solaris", target_os = "illumos"))))]
@@ -119,7 +133,9 @@ pub(crate) fn get_localaddr(socket: TcpSocket) -> io::Result<SocketAddr> {
pub(crate) fn set_linger(socket: TcpSocket, dur: Option<Duration>) -> io::Result<()> {
let val: libc::linger = libc::linger {
l_onoff: if dur.is_some() { 1 } else { 0 },
- l_linger: dur.map(|dur| dur.as_secs() as libc::c_int).unwrap_or_default(),
+ l_linger: dur
+ .map(|dur| dur.as_secs() as libc::c_int)
+ .unwrap_or_default(),
};
syscall!(setsockopt(
socket,
@@ -127,7 +143,277 @@ pub(crate) fn set_linger(socket: TcpSocket, dur: Option<Duration>) -> io::Result
libc::SO_LINGER,
&val as *const libc::linger as *const libc::c_void,
size_of::<libc::linger>() as libc::socklen_t,
- )).map(|_| ())
+ ))
+ .map(|_| ())
+}
+
+pub(crate) fn get_linger(socket: TcpSocket) -> io::Result<Option<Duration>> {
+ let mut val: libc::linger = unsafe { std::mem::zeroed() };
+ let mut len = mem::size_of::<libc::linger>() as libc::socklen_t;
+
+ syscall!(getsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_LINGER,
+ &mut val as *mut _ as *mut _,
+ &mut len,
+ ))?;
+
+ if val.l_onoff == 0 {
+ Ok(None)
+ } else {
+ Ok(Some(Duration::from_secs(val.l_linger as u64)))
+ }
+}
+
+pub(crate) fn set_recv_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> {
+ let size = size.try_into().ok().unwrap_or_else(i32::max_value);
+ syscall!(setsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_RCVBUF,
+ &size as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+pub(crate) fn get_recv_buffer_size(socket: TcpSocket) -> io::Result<u32> {
+ let mut optval: libc::c_int = 0;
+ let mut optlen = size_of::<libc::c_int>() as libc::socklen_t;
+ syscall!(getsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_RCVBUF,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(optval as u32)
+}
+
+pub(crate) fn set_send_buffer_size(socket: TcpSocket, size: u32) -> io::Result<()> {
+ let size = size.try_into().ok().unwrap_or_else(i32::max_value);
+ syscall!(setsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_SNDBUF,
+ &size as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+pub(crate) fn get_send_buffer_size(socket: TcpSocket) -> io::Result<u32> {
+ let mut optval: libc::c_int = 0;
+ let mut optlen = size_of::<libc::c_int>() as libc::socklen_t;
+
+ syscall!(getsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_SNDBUF,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(optval as u32)
+}
+
+pub(crate) fn set_keepalive(socket: TcpSocket, keepalive: bool) -> io::Result<()> {
+ let val: libc::c_int = if keepalive { 1 } else { 0 };
+ syscall!(setsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_KEEPALIVE,
+ &val as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+pub(crate) fn get_keepalive(socket: TcpSocket) -> io::Result<bool> {
+ let mut optval: libc::c_int = 0;
+ let mut optlen = mem::size_of::<libc::c_int>() as libc::socklen_t;
+
+ syscall!(getsockopt(
+ socket,
+ libc::SOL_SOCKET,
+ libc::SO_KEEPALIVE,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(optval != 0)
+}
+
+pub(crate) fn set_keepalive_params(socket: TcpSocket, keepalive: TcpKeepalive) -> io::Result<()> {
+ if let Some(dur) = keepalive.time {
+ set_keepalive_time(socket, dur)?;
+ }
+
+ #[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "netbsd",
+ ))]
+ {
+ if let Some(dur) = keepalive.interval {
+ set_keepalive_interval(socket, dur)?;
+ }
+
+ if let Some(retries) = keepalive.retries {
+ set_keepalive_retries(socket, retries)?;
+ }
+ }
+
+
+ Ok(())
+}
+
+fn set_keepalive_time(socket: TcpSocket, time: Duration) -> io::Result<()> {
+ let time_secs = time
+ .as_secs()
+ .try_into()
+ .ok()
+ .unwrap_or_else(i32::max_value);
+ syscall!(setsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ KEEPALIVE_TIME,
+ &(time_secs as libc::c_int) as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+pub(crate) fn get_keepalive_time(socket: TcpSocket) -> io::Result<Option<Duration>> {
+ if !get_keepalive(socket)? {
+ return Ok(None);
+ }
+
+ let mut optval: libc::c_int = 0;
+ let mut optlen = mem::size_of::<libc::c_int>() as libc::socklen_t;
+ syscall!(getsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ KEEPALIVE_TIME,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(Some(Duration::from_secs(optval as u64)))
+}
+
+/// Linux, FreeBSD, and NetBSD support setting the keepalive interval via
+/// `TCP_KEEPINTVL`.
+/// See:
+/// - https://man7.org/linux/man-pages/man7/tcp.7.html
+/// - https://www.freebsd.org/cgi/man.cgi?query=tcp#end
+/// - http://man.netbsd.org/tcp.4#DESCRIPTION
+///
+/// OpenBSD does not:
+/// https://man.openbsd.org/tcp
+#[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "netbsd",
+))]
+fn set_keepalive_interval(socket: TcpSocket, interval: Duration) -> io::Result<()> {
+ let interval_secs = interval
+ .as_secs()
+ .try_into()
+ .ok()
+ .unwrap_or_else(i32::max_value);
+ syscall!(setsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ libc::TCP_KEEPINTVL,
+ &(interval_secs as libc::c_int) as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+#[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "netbsd",
+))]
+pub(crate) fn get_keepalive_interval(socket: TcpSocket) -> io::Result<Option<Duration>> {
+ if !get_keepalive(socket)? {
+ return Ok(None);
+ }
+
+ let mut optval: libc::c_int = 0;
+ let mut optlen = mem::size_of::<libc::c_int>() as libc::socklen_t;
+ syscall!(getsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ libc::TCP_KEEPINTVL,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(Some(Duration::from_secs(optval as u64)))
+}
+
+/// Linux, macOS/iOS, FreeBSD, and NetBSD support setting the number of TCP
+/// keepalive retries via `TCP_KEEPCNT`.
+/// See:
+/// - https://man7.org/linux/man-pages/man7/tcp.7.html
+/// - https://www.freebsd.org/cgi/man.cgi?query=tcp#end
+/// - http://man.netbsd.org/tcp.4#DESCRIPTION
+///
+/// OpenBSD does not:
+/// https://man.openbsd.org/tcp
+#[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "netbsd",
+))]
+fn set_keepalive_retries(socket: TcpSocket, retries: u32) -> io::Result<()> {
+ let retries = retries.try_into().ok().unwrap_or_else(i32::max_value);
+ syscall!(setsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ libc::TCP_KEEPCNT,
+ &(retries as libc::c_int) as *const _ as *const libc::c_void,
+ size_of::<libc::c_int>() as libc::socklen_t
+ ))
+ .map(|_| ())
+}
+
+#[cfg(any(
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "netbsd",
+))]
+pub(crate) fn get_keepalive_retries(socket: TcpSocket) -> io::Result<Option<u32>> {
+ if !get_keepalive(socket)? {
+ return Ok(None);
+ }
+
+ let mut optval: libc::c_int = 0;
+ let mut optlen = mem::size_of::<libc::c_int>() as libc::socklen_t;
+ syscall!(getsockopt(
+ socket,
+ libc::IPPROTO_TCP,
+ libc::TCP_KEEPCNT,
+ &mut optval as *mut _ as *mut _,
+ &mut optlen,
+ ))?;
+
+ Ok(Some(optval as u32))
}
pub fn accept(listener: &net::TcpListener) -> io::Result<(net::TcpStream, SocketAddr)> {
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-25 15:55:19 +0000