From c60b7436a8dec17795f95e3b58d88a85ab69384a Mon Sep 17 00:00:00 2001 From: recatek Date: Sun, 12 Nov 2023 20:48:23 -0500 Subject: [PATCH 01/15] Added FreeBSD's SCM_REALTIME and SCM_MONOTONIC into sys::socket::ControlMessageOwned. --- src/sys/socket/mod.rs | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 2d94b47aea..f333916526 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -1,7 +1,7 @@ //! Socket interface functions //! //! [Further reading](https://man7.org/linux/man-pages/man7/socket.7.html) -#[cfg(any(target_os = "android", target_os = "linux"))] +#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))] #[cfg(feature = "uio")] use crate::sys::time::TimeSpec; #[cfg(not(target_os = "redox"))] @@ -779,6 +779,18 @@ pub enum ControlMessageOwned { #[cfg(any(target_os = "android", target_os = "linux"))] #[cfg_attr(docsrs, doc(cfg(all())))] ScmTimestampns(TimeSpec), + /// Realtime clock timestamp + /// + /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) + #[cfg(any(target_os = "freebsd"))] + #[cfg_attr(docsrs, doc(cfg(all())))] + ScmRealtime(TimeSpec), + /// Monotonic clock timestamp + /// + /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) + #[cfg(any(target_os = "freebsd"))] + #[cfg_attr(docsrs, doc(cfg(all())))] + ScmMonotonic(TimeSpec), #[cfg(any( target_os = "android", apple_targets, @@ -958,6 +970,16 @@ impl ControlMessageOwned { let ts: libc::timespec = ptr::read_unaligned(p as *const _); ControlMessageOwned::ScmTimestampns(TimeSpec::from(ts)) } + #[cfg(any(target_os = "freebsd"))] + (libc::SOL_SOCKET, libc::SCM_REALTIME) => { + let ts: libc::timespec = ptr::read_unaligned(p as *const _); + ControlMessageOwned::ScmRealtime(TimeSpec::from(ts)) + } + #[cfg(any(target_os = "freebsd"))] + (libc::SOL_SOCKET, libc::SCM_MONOTONIC) => { + let ts: libc::timespec = ptr::read_unaligned(p as *const _); + ControlMessageOwned::ScmMonotonic(TimeSpec::from(ts)) + } #[cfg(any(target_os = "android", target_os = "linux"))] (libc::SOL_SOCKET, libc::SCM_TIMESTAMPING) => { let tp = p as *const libc::timespec; From 9ebb8f30a876f294c0b4c12ec733844f6b6105f4 Mon Sep 17 00:00:00 2001 From: recatek Date: Sun, 12 Nov 2023 23:09:30 -0500 Subject: [PATCH 02/15] Creating a SocketTimestamp enum for the SO_TS_CLOCK setsockopt for FreeBSD. --- src/sys/socket/mod.rs | 19 +++++++++++++++++++ src/sys/socket/sockopt.rs | 2 +- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index f333916526..351b2b6921 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -410,6 +410,25 @@ libc_bitflags! { } } +#[cfg(any(target_os = "freebsd"))] +libc_enum! { + /// A selector for which clock to use when generating packet timestamps. + /// Used when setting [`TsClock`](crate::sys::socket::sockopt::TsClock) on a socket. + /// (For more details, see [setsockopt(2)](https://man.freebsd.org/cgi/man.cgi?setsockopt)). + #[repr(i32)] + #[non_exhaustive] + pub enum SocketTimestamp { + /// Microsecond resolution, realtime. This is the default. + SO_TS_REALTIME_MICRO, + /// Sub-nanosecond resolution, realtime. + SO_TS_BINTIME, + /// Nanosecond resolution, realtime. + SO_TS_REALTIME, + /// Nanosecond resolution, monotonic. + SO_TS_MONOTONIC, + } +} + cfg_if! { if #[cfg(any(target_os = "android", target_os = "linux"))] { /// Unix credentials of the sending process. diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs index 07a0ac4ed5..c47cbb6ca9 100644 --- a/src/sys/socket/sockopt.rs +++ b/src/sys/socket/sockopt.rs @@ -721,7 +721,7 @@ sockopt_impl!( Both, libc::SOL_SOCKET, libc::SO_TS_CLOCK, - i32 + super::SocketTimestamp ); #[cfg(any(target_os = "android", target_os = "linux"))] #[cfg(feature = "net")] From f1252a374b7e6ae2efb9cdedf9b0190f581910fa Mon Sep 17 00:00:00 2001 From: recatek Date: Mon, 13 Nov 2023 02:00:48 -0500 Subject: [PATCH 03/15] Fixing whitespace --- src/sys/socket/mod.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 351b2b6921..8fb75dccd9 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -413,14 +413,14 @@ libc_bitflags! { #[cfg(any(target_os = "freebsd"))] libc_enum! { /// A selector for which clock to use when generating packet timestamps. - /// Used when setting [`TsClock`](crate::sys::socket::sockopt::TsClock) on a socket. - /// (For more details, see [setsockopt(2)](https://man.freebsd.org/cgi/man.cgi?setsockopt)). + /// Used when setting [`TsClock`](crate::sys::socket::sockopt::TsClock) on a socket. + /// (For more details, see [setsockopt(2)](https://man.freebsd.org/cgi/man.cgi?setsockopt)). #[repr(i32)] #[non_exhaustive] pub enum SocketTimestamp { /// Microsecond resolution, realtime. This is the default. SO_TS_REALTIME_MICRO, - /// Sub-nanosecond resolution, realtime. + /// Sub-nanosecond resolution, realtime. SO_TS_BINTIME, /// Nanosecond resolution, realtime. SO_TS_REALTIME, From dc7baed0fd445ab08ee51b036dfd5de6f6731fb2 Mon Sep 17 00:00:00 2001 From: recatek Date: Mon, 13 Nov 2023 20:02:21 -0500 Subject: [PATCH 04/15] Fixing CI error on cfg attributes --- src/sys/socket/mod.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 8fb75dccd9..e493c8d78c 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -410,7 +410,7 @@ libc_bitflags! { } } -#[cfg(any(target_os = "freebsd"))] +#[cfg(target_os = "freebsd")] libc_enum! { /// A selector for which clock to use when generating packet timestamps. /// Used when setting [`TsClock`](crate::sys::socket::sockopt::TsClock) on a socket. @@ -801,13 +801,13 @@ pub enum ControlMessageOwned { /// Realtime clock timestamp /// /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) - #[cfg(any(target_os = "freebsd"))] + #[cfg(target_os = "freebsd")] #[cfg_attr(docsrs, doc(cfg(all())))] ScmRealtime(TimeSpec), /// Monotonic clock timestamp /// /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) - #[cfg(any(target_os = "freebsd"))] + #[cfg(target_os = "freebsd")] #[cfg_attr(docsrs, doc(cfg(all())))] ScmMonotonic(TimeSpec), #[cfg(any( @@ -989,12 +989,12 @@ impl ControlMessageOwned { let ts: libc::timespec = ptr::read_unaligned(p as *const _); ControlMessageOwned::ScmTimestampns(TimeSpec::from(ts)) } - #[cfg(any(target_os = "freebsd"))] + #[cfg(target_os = "freebsd")] (libc::SOL_SOCKET, libc::SCM_REALTIME) => { let ts: libc::timespec = ptr::read_unaligned(p as *const _); ControlMessageOwned::ScmRealtime(TimeSpec::from(ts)) } - #[cfg(any(target_os = "freebsd"))] + #[cfg(target_os = "freebsd")] (libc::SOL_SOCKET, libc::SCM_MONOTONIC) => { let ts: libc::timespec = ptr::read_unaligned(p as *const _); ControlMessageOwned::ScmMonotonic(TimeSpec::from(ts)) From 25ed3750a694b8d407df9c02655a444fb3ba8d38 Mon Sep 17 00:00:00 2001 From: recatek Date: Tue, 14 Nov 2023 00:43:19 -0500 Subject: [PATCH 05/15] Removing legacy doc attributes --- src/sys/socket/mod.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index e493c8d78c..4d5924f082 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -802,13 +802,11 @@ pub enum ControlMessageOwned { /// /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) #[cfg(target_os = "freebsd")] - #[cfg_attr(docsrs, doc(cfg(all())))] ScmRealtime(TimeSpec), /// Monotonic clock timestamp /// /// [Further reading](https://man.freebsd.org/cgi/man.cgi?setsockopt) #[cfg(target_os = "freebsd")] - #[cfg_attr(docsrs, doc(cfg(all())))] ScmMonotonic(TimeSpec), #[cfg(any( target_os = "android", From 9664ea08956e23cb82069bf0bbaac38edfdddaf9 Mon Sep 17 00:00:00 2001 From: recatek Date: Tue, 14 Nov 2023 00:43:38 -0500 Subject: [PATCH 06/15] Formatting cleanup --- src/sys/socket/mod.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 4d5924f082..fd1f8f5d69 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -1,7 +1,11 @@ //! Socket interface functions //! //! [Further reading](https://man7.org/linux/man-pages/man7/socket.7.html) -#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))] +#[cfg(any( + target_os = "android", + target_os = "freebsd", + target_os = "linux" +))] #[cfg(feature = "uio")] use crate::sys::time::TimeSpec; #[cfg(not(target_os = "redox"))] From f795c4e8c1e51081ccfa765a6045f3b77ba13864 Mon Sep 17 00:00:00 2001 From: recatek Date: Tue, 14 Nov 2023 21:09:03 -0500 Subject: [PATCH 07/15] Updating changelog --- changelog/2187.added.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 changelog/2187.added.md diff --git a/changelog/2187.added.md b/changelog/2187.added.md new file mode 100644 index 0000000000..a13ef70990 --- /dev/null +++ b/changelog/2187.added.md @@ -0,0 +1,2 @@ +- Added the `::nix::sys::socket::SocketTimestamp` enum for configuring the `TsClock` (a.k.a `SO_TS_CLOCK`) sockopt +- Added FreeBSD's `ScmRealtime` and `ScmMonotonic` as new options in `::nix::sys::socket::ControlMessageOwned` \ No newline at end of file From 37c399848a2c88932fa77eb24fca91419674843e Mon Sep 17 00:00:00 2001 From: recatek Date: Sat, 18 Nov 2023 14:45:36 -0500 Subject: [PATCH 08/15] Adding tests for new TsClock setsockopt enum and the two new packet timestamp control messages for FreeBSD --- test/sys/test_socket.rs | 126 +++++++++++++++++++++++++++++++++++++++ test/sys/test_sockopt.rs | 113 +++++++++++++++++++++++++++++++++++ 2 files changed, 239 insertions(+) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index ddd4f7c730..71bfb5a36b 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -72,6 +72,132 @@ pub fn test_timestamping() { assert!(std::time::Duration::from(diff).as_secs() < 60); } +#[cfg(target_os = "freebsd")] +#[cfg_attr(qemu, ignore)] +#[test] +pub fn test_timestamping_realtime() { + use nix::sys::socket::{ + recvmsg, sendmsg, setsockopt, socket, sockopt::ReceiveTimestamp, + sockopt::TsClock, ControlMessageOwned, MsgFlags, SockFlag, SockType, + SockaddrIn, SocketTimestamp, + }; + use std::io::{IoSlice, IoSliceMut}; + + let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap(); + + let ssock = socket( + AddressFamily::Inet, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .expect("send socket failed"); + + let rsock = socket( + AddressFamily::Inet, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + nix::sys::socket::bind(rsock.as_raw_fd(), &sock_addr).unwrap(); + + setsockopt(&rsock, ReceiveTimestamp, &true).unwrap(); + setsockopt(&rsock, TsClock, &SocketTimestamp::SO_TS_REALTIME).unwrap(); + + let sbuf = [0u8; 2048]; + let mut rbuf = [0u8; 2048]; + let flags = MsgFlags::empty(); + let iov1 = [IoSlice::new(&sbuf)]; + let mut iov2 = [IoSliceMut::new(&mut rbuf)]; + + let mut cmsg = cmsg_space!(nix::sys::time::TimeVal); + sendmsg(ssock.as_raw_fd(), &iov1, &[], flags, Some(&sock_addr)).unwrap(); + let recv = + recvmsg::<()>(rsock.as_raw_fd(), &mut iov2, Some(&mut cmsg), flags) + .unwrap(); + + let mut ts = None; + for c in recv.cmsgs() { + if let ControlMessageOwned::ScmRealtime(timeval) = c { + ts = Some(timeval); + } + } + let ts = ts.expect("ScmRealtime is present"); + let sys_time = + ::nix::time::clock_gettime(::nix::time::ClockId::CLOCK_REALTIME) + .unwrap(); + let diff = if ts > sys_time { + ts - sys_time + } else { + sys_time - ts + }; + assert!(std::time::Duration::from(diff).as_secs() < 60); +} + +#[cfg(target_os = "freebsd")] +#[cfg_attr(qemu, ignore)] +#[test] +pub fn test_timestamping_monotonic() { + use nix::sys::socket::{ + recvmsg, sendmsg, setsockopt, socket, sockopt::ReceiveTimestamp, + sockopt::TsClock, ControlMessageOwned, MsgFlags, SockFlag, SockType, + SockaddrIn, SocketTimestamp, + }; + use std::io::{IoSlice, IoSliceMut}; + + let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap(); + + let ssock = socket( + AddressFamily::Inet, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .expect("send socket failed"); + + let rsock = socket( + AddressFamily::Inet, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + nix::sys::socket::bind(rsock.as_raw_fd(), &sock_addr).unwrap(); + + setsockopt(&rsock, ReceiveTimestamp, &true).unwrap(); + setsockopt(&rsock, TsClock, &SocketTimestamp::SO_TS_MONOTONIC).unwrap(); + + let sbuf = [0u8; 2048]; + let mut rbuf = [0u8; 2048]; + let flags = MsgFlags::empty(); + let iov1 = [IoSlice::new(&sbuf)]; + let mut iov2 = [IoSliceMut::new(&mut rbuf)]; + + let mut cmsg = cmsg_space!(nix::sys::time::TimeVal); + sendmsg(ssock.as_raw_fd(), &iov1, &[], flags, Some(&sock_addr)).unwrap(); + let recv = + recvmsg::<()>(rsock.as_raw_fd(), &mut iov2, Some(&mut cmsg), flags) + .unwrap(); + + let mut ts = None; + for c in recv.cmsgs() { + if let ControlMessageOwned::ScmMonotonic(timeval) = c { + ts = Some(timeval); + } + } + let ts = ts.expect("ScmMonotonic is present"); + let sys_time = + ::nix::time::clock_gettime(::nix::time::ClockId::CLOCK_MONOTONIC) + .unwrap(); + let diff = if ts > sys_time { + ts - sys_time + } else { + sys_time - ts + }; + assert!(std::time::Duration::from(diff).as_secs() < 60); +} + #[test] pub fn test_path_to_sock_addr() { let path = "/foo/bar"; diff --git a/test/sys/test_sockopt.rs b/test/sys/test_sockopt.rs index a3100c99a8..94481a0b4f 100644 --- a/test/sys/test_sockopt.rs +++ b/test/sys/test_sockopt.rs @@ -436,3 +436,116 @@ fn test_ipv6_tclass() { setsockopt(&fd, sockopt::Ipv6TClass, &class).unwrap(); assert_eq!(getsockopt(&fd, sockopt::Ipv6TClass).unwrap(), class); } + +#[test] +#[cfg(target_os = "freebsd")] +fn test_receive_timestamp() { + let fd = socket( + AddressFamily::Inet6, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); + assert_eq!(getsockopt(&fd, sockopt::ReceiveTimestamp).unwrap(), true); +} + +#[test] +#[cfg(target_os = "freebsd")] +fn test_ts_clock_realtime_micro() { + use nix::sys::socket::SocketTimestamp; + + let fd = socket( + AddressFamily::Inet6, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + + // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP. + setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); + + setsockopt( + &fd, + sockopt::TsClock, + &SocketTimestamp::SO_TS_REALTIME_MICRO, + ) + .unwrap(); + assert_eq!( + getsockopt(&fd, sockopt::TsClock).unwrap(), + SocketTimestamp::SO_TS_REALTIME_MICRO + ); +} + +#[test] +#[cfg(target_os = "freebsd")] +fn test_ts_clock_bintime() { + use nix::sys::socket::SocketTimestamp; + + let fd = socket( + AddressFamily::Inet6, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + + // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP. + setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); + + setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_BINTIME).unwrap(); + assert_eq!( + getsockopt(&fd, sockopt::TsClock).unwrap(), + SocketTimestamp::SO_TS_BINTIME + ); +} + +#[test] +#[cfg(target_os = "freebsd")] +fn test_ts_clock_realtime() { + use nix::sys::socket::SocketTimestamp; + + let fd = socket( + AddressFamily::Inet6, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + + // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP. + setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); + + setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_REALTIME) + .unwrap(); + assert_eq!( + getsockopt(&fd, sockopt::TsClock).unwrap(), + SocketTimestamp::SO_TS_REALTIME + ); +} + +#[test] +#[cfg(target_os = "freebsd")] +fn test_ts_clock_monotonic() { + use nix::sys::socket::SocketTimestamp; + + let fd = socket( + AddressFamily::Inet6, + SockType::Datagram, + SockFlag::empty(), + None, + ) + .unwrap(); + + // FreeBSD setsockopt docs say to set SO_TS_CLOCK after setting SO_TIMESTAMP. + setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); + + setsockopt(&fd, sockopt::TsClock, &SocketTimestamp::SO_TS_MONOTONIC) + .unwrap(); + assert_eq!( + getsockopt(&fd, sockopt::TsClock).unwrap(), + SocketTimestamp::SO_TS_MONOTONIC + ); +} From d30ea30f8dadd585cc18a106dc35636278bc5e96 Mon Sep 17 00:00:00 2001 From: recatek Date: Sat, 18 Nov 2023 15:03:39 -0500 Subject: [PATCH 09/15] Replacing an assert_eq with an assert in new tests. --- test/sys/test_sockopt.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/sys/test_sockopt.rs b/test/sys/test_sockopt.rs index 94481a0b4f..0107deec36 100644 --- a/test/sys/test_sockopt.rs +++ b/test/sys/test_sockopt.rs @@ -448,7 +448,7 @@ fn test_receive_timestamp() { ) .unwrap(); setsockopt(&fd, sockopt::ReceiveTimestamp, &true).unwrap(); - assert_eq!(getsockopt(&fd, sockopt::ReceiveTimestamp).unwrap(), true); + assert!(getsockopt(&fd, sockopt::ReceiveTimestamp).unwrap()); } #[test] From 333d81576e7f5dae7818343df68c852c42aad1f0 Mon Sep 17 00:00:00 2001 From: recatek Date: Mon, 20 Nov 2023 22:49:44 -0500 Subject: [PATCH 10/15] Removing qemu ignore for new FreeBSD tests --- test/sys/test_socket.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index 71bfb5a36b..7ae2639789 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -73,7 +73,6 @@ pub fn test_timestamping() { } #[cfg(target_os = "freebsd")] -#[cfg_attr(qemu, ignore)] #[test] pub fn test_timestamping_realtime() { use nix::sys::socket::{ @@ -136,7 +135,6 @@ pub fn test_timestamping_realtime() { } #[cfg(target_os = "freebsd")] -#[cfg_attr(qemu, ignore)] #[test] pub fn test_timestamping_monotonic() { use nix::sys::socket::{ From 668e7fb00bc33c97046e4e242805bf636f4908d2 Mon Sep 17 00:00:00 2001 From: recatek Date: Mon, 20 Nov 2023 22:50:10 -0500 Subject: [PATCH 11/15] Giving new FreeBSD timestamping tests each a unique socket --- test/sys/test_socket.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index 7ae2639789..8546ba52ce 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -82,7 +82,7 @@ pub fn test_timestamping_realtime() { }; use std::io::{IoSlice, IoSliceMut}; - let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap(); + let sock_addr = SockaddrIn::from_str("127.0.0.1:6791").unwrap(); let ssock = socket( AddressFamily::Inet, @@ -144,7 +144,7 @@ pub fn test_timestamping_monotonic() { }; use std::io::{IoSlice, IoSliceMut}; - let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap(); + let sock_addr = SockaddrIn::from_str("127.0.0.1:6792").unwrap(); let ssock = socket( AddressFamily::Inet, From e9098e23d1d230467101928b66f38581f242e0cb Mon Sep 17 00:00:00 2001 From: recatek Date: Mon, 20 Nov 2023 22:54:40 -0500 Subject: [PATCH 12/15] Updating monotonic packet timestamp test to account for monotonicity --- test/sys/test_socket.rs | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index 8546ba52ce..904e6718e4 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -188,11 +188,7 @@ pub fn test_timestamping_monotonic() { let sys_time = ::nix::time::clock_gettime(::nix::time::ClockId::CLOCK_MONOTONIC) .unwrap(); - let diff = if ts > sys_time { - ts - sys_time - } else { - sys_time - ts - }; + let diff = sys_time - ts; // Monotonic clock sys_time must be greater assert!(std::time::Duration::from(diff).as_secs() < 60); } From 9b384304662a8e7e427069b30801723cd435f3ae Mon Sep 17 00:00:00 2001 From: recatek Date: Tue, 21 Nov 2023 12:19:11 -0500 Subject: [PATCH 13/15] Moving test ports again to line up with changes in #2196 --- test/sys/test_socket.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index 904e6718e4..dccc666024 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -82,7 +82,7 @@ pub fn test_timestamping_realtime() { }; use std::io::{IoSlice, IoSliceMut}; - let sock_addr = SockaddrIn::from_str("127.0.0.1:6791").unwrap(); + let sock_addr = SockaddrIn::from_str("127.0.0.1:6792").unwrap(); let ssock = socket( AddressFamily::Inet, @@ -144,7 +144,7 @@ pub fn test_timestamping_monotonic() { }; use std::io::{IoSlice, IoSliceMut}; - let sock_addr = SockaddrIn::from_str("127.0.0.1:6792").unwrap(); + let sock_addr = SockaddrIn::from_str("127.0.0.1:6803").unwrap(); let ssock = socket( AddressFamily::Inet, From 71abb61dddc94b0c54ec6940d5bea11b070ab3ba Mon Sep 17 00:00:00 2001 From: recatek Date: Wed, 22 Nov 2023 20:32:30 -0500 Subject: [PATCH 14/15] Attempting checks again From ec8a1b67a42e366ab765a5e484459ec6a0bcc787 Mon Sep 17 00:00:00 2001 From: recatek Date: Fri, 24 Nov 2023 14:42:04 -0500 Subject: [PATCH 15/15] Wrapping ptr::read_unaligned calls in unsafe blocks --- src/sys/socket/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index fd1f8f5d69..0c9bac99c8 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -993,12 +993,12 @@ impl ControlMessageOwned { } #[cfg(target_os = "freebsd")] (libc::SOL_SOCKET, libc::SCM_REALTIME) => { - let ts: libc::timespec = ptr::read_unaligned(p as *const _); + let ts: libc::timespec = unsafe { ptr::read_unaligned(p as *const _) }; ControlMessageOwned::ScmRealtime(TimeSpec::from(ts)) } #[cfg(target_os = "freebsd")] (libc::SOL_SOCKET, libc::SCM_MONOTONIC) => { - let ts: libc::timespec = ptr::read_unaligned(p as *const _); + let ts: libc::timespec = unsafe { ptr::read_unaligned(p as *const _) }; ControlMessageOwned::ScmMonotonic(TimeSpec::from(ts)) } #[cfg(any(target_os = "android", target_os = "linux"))]