Support TIMESTAMPNS

Author: WiSaGaN

CHANGELOG.md

@@ -5,6 +5,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased] - ReleaseDate
 ### Added
+- Added linux TIMESTAMPNS support for x86/x64 gnu
+  (#[1402](https://github.com/nix-rust/nix/pull/1402))
 
 ### Changed
 - Made `forkpty` unsafe, like `fork`

Cargo.toml

@@ -76,3 +76,7 @@ harness = false
 [[test]]
 name = "test-ptymaster-drop"
 path = "test/test_ptymaster_drop.rs"
+
+[[test]]
+name = "test-receive-timestampns"
+path = "test/test_receive_timestampns.rs"

src/sys/socket/mod.rs

@@ -7,6 +7,8 @@ use libc::{self, c_void, c_int, iovec, socklen_t, size_t,
         CMSG_FIRSTHDR, CMSG_NXTHDR, CMSG_DATA, CMSG_LEN};
 use std::{mem, ptr, slice};
 use std::os::unix::io::RawFd;
+#[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+use crate::sys::time::TimeSpec;
 use crate::sys::time::TimeVal;
 use crate::sys::uio::IoVec;
 
@@ -556,6 +558,11 @@ pub enum ControlMessageOwned {
     /// # }
     /// ```
     ScmTimestamp(TimeVal),
+    /// Nanoseconds resolution timestamp
+    ///
+    /// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)
+    #[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+    ScmTimestampNs(TimeSpec),
     #[cfg(any(
         target_os = "android",
         target_os = "ios",
@@ -647,6 +654,11 @@ impl ControlMessageOwned {
                 let tv: libc::timeval = ptr::read_unaligned(p as *const _);
                 ControlMessageOwned::ScmTimestamp(TimeVal::from(tv))
             },
+            #[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+            (libc::SOL_SOCKET, libc::SCM_TIMESTAMPNS) => {
+                let ts: libc::timespec = ptr::read_unaligned(p as *const _);
+                ControlMessageOwned::ScmTimestampNs(TimeSpec::from(ts))
+            }
             #[cfg(any(
                 target_os = "android",
                 target_os = "freebsd",

src/sys/socket/sockopt.rs

@@ -272,6 +272,8 @@ sockopt_impl!(Both, BindToDevice, libc::SOL_SOCKET, libc::SO_BINDTODEVICE, OsStr
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(GetOnly, OriginalDst, libc::SOL_IP, libc::SO_ORIGINAL_DST, libc::sockaddr_in);
 sockopt_impl!(Both, ReceiveTimestamp, libc::SOL_SOCKET, libc::SO_TIMESTAMP, bool);
+#[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+sockopt_impl!(Both, ReceiveTimestampNs, libc::SOL_SOCKET, libc::SO_TIMESTAMPNS, bool);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(Both, IpTransparent, libc::SOL_IP, libc::IP_TRANSPARENT, bool);
 #[cfg(target_os = "openbsd")]

test/test_receive_timestampns.rs

@@ -0,0 +1,97 @@
+use nix::sys::socket::*;
+use nix::sys::uio::IoVec;
+use nix::sys::time::*;
+use std::time::*;
+
+// TODO: move this to unit test once we may use `cmsg_space!` there
+#[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+#[test]
+fn recvmsg_timestampns() {
+    // Set up
+    let message = "Ohayō!".as_bytes();
+    let in_socket = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None).unwrap();
+    setsockopt(in_socket, sockopt::ReceiveTimestampNs, &true).unwrap();
+    let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
+    bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
+    let address = getsockname(in_socket).unwrap();
+    // Get initial time
+    let time0 = SystemTime::now();
+    // Send the message
+    let iov = [IoVec::from_slice(message)];
+    let flags = MsgFlags::empty();
+    let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();
+    assert_eq!(message.len(), l);
+    // Receive the message
+    let mut buffer = vec![0u8; message.len()];
+    let mut cmsgspace = nix::cmsg_space!(TimeSpec);
+    let iov = [IoVec::from_mut_slice(&mut buffer)];
+    let r = recvmsg(in_socket, &iov, Some(&mut cmsgspace), flags).unwrap();
+    let rtime = match r.cmsgs().next() {
+        Some(ControlMessageOwned::ScmTimestampNs(rtime)) => rtime,
+        Some(_) => panic!("Unexpected control message"),
+        None => panic!("No control message")
+    };
+    // Check the final time
+    let time1 = SystemTime::now();
+    // the packet's received timestamp should lie in-between the two system
+    // times, unless the system clock was adjusted in the meantime.
+    let rduration = Duration::new(rtime.tv_sec() as u64,
+    rtime.tv_nsec() as u32);
+    assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);
+    assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());
+    // Close socket
+    nix::unistd::close(in_socket).unwrap();
+}
+
+#[cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "x86"), target_env = "gnu"))]
+#[test]
+fn recvmmsg_timestampns() {
+    // Set up
+    let message = "Ohayō!".as_bytes();
+    let in_socket = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None).unwrap();
+    setsockopt(in_socket, sockopt::ReceiveTimestampNs, &true).unwrap();
+    let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
+    bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
+    let address = getsockname(in_socket).unwrap();
+    // Get initial time
+    let time0 = SystemTime::now();
+    // Send the message
+    let iov = [IoVec::from_slice(message)];
+    let flags = MsgFlags::empty();
+    let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();
+    assert_eq!(message.len(), l);
+    // Receive the message
+    let mut buffer = vec![0u8; message.len()];
+    let mut cmsgspace = nix::cmsg_space!(TimeSpec);
+    let iov = [IoVec::from_mut_slice(&mut buffer)];
+    let mut data = vec![
+        RecvMmsgData {
+            iov,
+            cmsg_buffer: Some(&mut cmsgspace),
+        },
+    ];
+    let r = recvmmsg(in_socket, &mut data, flags, None).unwrap();
+    let rtime = match r[0].cmsgs().next() {
+        Some(ControlMessageOwned::ScmTimestampNs(rtime)) => rtime,
+        Some(_) => panic!("Unexpected control message"),
+        None => panic!("No control message")
+    };
+    // Check the final time
+    let time1 = SystemTime::now();
+    // the packet's received timestamp should lie in-between the two system
+    // times, unless the system clock was adjusted in the meantime.
+    let rduration = Duration::new(rtime.tv_sec() as u64,
+    rtime.tv_nsec() as u32);
+    assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);
+    assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());
+    // Close socket
+    nix::unistd::close(in_socket).unwrap();
+}