Skip to main content

ntpsec_rs_io/
lib.rs

1// ──── ntpsec-rs-io — Real OS I/O layer ──────────────────────────────────────
2//
3// Implements the SystemClock, NetworkIo, and StateStore traits from
4// ntpsec-rs-core using real libc syscalls and std::net sockets.
5//
6// ## Phase 2.3C
7//
8//   - RealNetworkIo::recv() uses SO_TIMESTAMPNS kernel receive timestamps
9//     via recvmsg() on socket2::Socket, replacing UdpSocket::recv_from()
10//   - Kernel timestamp extracted from SCM_TIMESTAMPNS ancillary data
11//   - Trace recording and replay support
12//
13// =============================================================================
14
15use ntpsec_rs_core::ntp_fp;
16use ntpsec_rs_core::ntp_io::*;
17use ntpsec_rs_core::ntp_packetstamp;
18use ntpsec_rs_core::ntp_types::*;
19use socket2::{Domain, Protocol, Socket, Type};
20
21// ──── SystemClock ─────────────────────────────────────────────────────
22
23#[derive(Debug)]
24pub struct RealSystemClock;
25
26#[allow(clippy::new_without_default)]
27impl RealSystemClock {
28    pub fn new() -> Self {
29        Self
30    }
31}
32
33impl SystemClock for RealSystemClock {
34    fn now(&self) -> NtpTs64 {
35        let mut ts = libc::timespec {
36            tv_sec: 0,
37            tv_nsec: 0,
38        };
39        if unsafe { libc::clock_gettime(libc::CLOCK_REALTIME, &mut ts) } != 0 {
40            return NtpTs64 {
41                seconds: 0,
42                fraction: 0,
43            };
44        }
45        ntp_fp::ts_to_ntp(ts.tv_sec, ts.tv_nsec)
46    }
47
48    fn step(&mut self, offset: f64) -> Result<(), IoError> {
49        let mut ts = libc::timespec {
50            tv_sec: 0,
51            tv_nsec: 0,
52        };
53        if unsafe { libc::clock_gettime(libc::CLOCK_REALTIME, &mut ts) } != 0 {
54            return Err(IoError::ClockFailed("clock_gettime failed".to_string()));
55        }
56        let new_secs = ts.tv_sec as f64 + ts.tv_nsec as f64 * 1e-9 + offset;
57        let tv_sec = new_secs.floor() as i64;
58        let tv_nsec = ((new_secs - tv_sec as f64) * 1e9) as i64;
59        let new_ts = libc::timespec {
60            tv_sec,
61            tv_nsec: tv_nsec.clamp(0, 999_999_999),
62        };
63        if unsafe { libc::clock_settime(libc::CLOCK_REALTIME, &new_ts) } != 0 {
64            Err(IoError::ClockFailed(
65                std::io::Error::last_os_error().to_string(),
66            ))
67        } else {
68            Ok(())
69        }
70    }
71
72    fn slew(&mut self, offset: f64, freq_ppm: f64) -> Result<(), IoError> {
73        let mut tmx: libc::timex = unsafe { std::mem::zeroed() };
74        let _ = unsafe { libc::adjtimex(&mut tmx) };
75        let nano = (tmx.status & libc::STA_NANO) != 0;
76        tmx.modes = libc::ADJ_OFFSET | libc::ADJ_FREQUENCY;
77        if nano {
78            tmx.offset = (offset * 1e9) as i64;
79        } else {
80            tmx.offset = (offset * 1e6) as i64;
81        }
82        tmx.freq = (freq_ppm * (1i64 << 16) as f64) as i64;
83        let ret = unsafe { libc::adjtimex(&mut tmx) };
84        if ret < 0 {
85            Err(IoError::ClockFailed(
86                std::io::Error::last_os_error().to_string(),
87            ))
88        } else {
89            Ok(())
90        }
91    }
92
93    fn read_frequency(&self) -> Result<f64, IoError> {
94        let mut tmx: libc::timex = unsafe { std::mem::zeroed() };
95        let ret = unsafe { libc::adjtimex(&mut tmx) };
96        if ret < 0 {
97            return Err(IoError::ClockFailed(
98                std::io::Error::last_os_error().to_string(),
99            ));
100        }
101        Ok(tmx.freq as f64 / (1i64 << 16) as f64)
102    }
103
104    fn set_frequency(&mut self, freq_ppm: f64) -> Result<(), IoError> {
105        self.slew(0.0, freq_ppm)
106    }
107}
108
109use std::os::unix::io::AsRawFd;
110
111// ──── NetworkIo with SO_TIMESTAMPNS ───────────────────────────────────
112
113#[derive(Debug)]
114pub struct RealNetworkIo {
115    sockets: Vec<Socket>,
116    /// epoll file descriptor (Linux only, -1 if not available).
117    epoll_fd: i32,
118    /// Mapping from socket index to raw file descriptor.
119    socket_fds: Vec<i32>,
120}
121
122#[allow(clippy::new_without_default)]
123impl RealNetworkIo {
124    pub fn new() -> Self {
125        let epoll_fd = Self::create_epoll();
126        Self {
127            sockets: Vec::new(),
128            epoll_fd,
129            socket_fds: Vec::new(),
130        }
131    }
132
133    /// Create an epoll instance. Falls back to -1 (poll-based) if unavailable.
134    fn create_epoll() -> i32 {
135        #[cfg(target_os = "linux")]
136        {
137            match unsafe { libc::epoll_create1(0) } {
138                -1 => -1,
139                fd => fd,
140            }
141        }
142        #[cfg(not(target_os = "linux"))]
143        {
144            -1
145        }
146    }
147
148    /// Return raw file descriptors of all managed sockets.
149    pub fn get_poll_fds(&self) -> Vec<i32> {
150        let mut fds = self.socket_fds.clone();
151        if self.epoll_fd >= 0 {
152            fds.push(self.epoll_fd);
153        }
154        fds
155    }
156
157    /// Wait for readability on any socket, with a timeout in milliseconds.
158    /// Returns ALL ready socket indices, not just the first one.
159    /// timeout_ms: -1 = infinite, 0 = poll (non-blocking), >0 = milliseconds.
160    pub fn poll_readable(&mut self, timeout_ms: i32) -> Result<Vec<usize>, IoError> {
161        if self.sockets.is_empty() {
162            return Ok(Vec::new());
163        }
164
165        #[cfg(target_os = "linux")]
166        {
167            if self.epoll_fd >= 0 {
168                return self.epoll_wait(timeout_ms);
169            }
170        }
171
172        self.poll_fallback(timeout_ms)
173    }
174
175    /// epoll_wait: returns ALL ready socket indices.
176    /// Uses level-triggered mode (not EPOLLET) so that any ready socket
177    /// that we cannot drain fully in one cycle will re-trigger on the
178    /// next poll call.  This avoids the edge-triggered starvation bug
179    /// where a non-drained socket stops generating readiness events.
180    #[cfg(target_os = "linux")]
181    fn epoll_wait(&mut self, timeout_ms: i32) -> Result<Vec<usize>, IoError> {
182        let mut events: [libc::epoll_event; 64] = unsafe { std::mem::zeroed() };
183        let nfds = unsafe {
184            libc::epoll_wait(
185                self.epoll_fd,
186                events.as_mut_ptr(),
187                events.len() as i32,
188                timeout_ms,
189            )
190        };
191        if nfds < 0 {
192            let err = std::io::Error::last_os_error();
193            if err.kind() == std::io::ErrorKind::Interrupted {
194                return Ok(Vec::new());
195            }
196            return Err(IoError::RecvFailed(format!("epoll_wait: {err}")));
197        }
198        if nfds == 0 {
199            return Ok(Vec::new());
200        }
201        // Collect ALL ready socket indices — not just the first one.
202        let mut ready = Vec::with_capacity(nfds as usize);
203        for event in &events[..nfds as usize] {
204            let fd = event.u64 as i32;
205            if let Some(idx) = self.socket_fds.iter().position(|&f| f == fd) {
206                if !ready.contains(&idx) {
207                    ready.push(idx);
208                }
209            }
210        }
211        Ok(ready)
212    }
213
214    /// poll(2) fallback — returns ALL ready socket indices.
215    fn poll_fallback(&mut self, timeout_ms: i32) -> Result<Vec<usize>, IoError> {
216        let nfds = self.sockets.len();
217        if nfds == 0 {
218            return Ok(Vec::new());
219        }
220        let mut fds: Vec<libc::pollfd> = self
221            .socket_fds
222            .iter()
223            .map(|&fd| libc::pollfd {
224                fd,
225                events: libc::POLLIN,
226                revents: 0,
227            })
228            .collect();
229
230        let ret = unsafe { libc::poll(fds.as_mut_ptr(), nfds as libc::nfds_t, timeout_ms) };
231        if ret < 0 {
232            let err = std::io::Error::last_os_error();
233            if err.kind() == std::io::ErrorKind::Interrupted {
234                return Ok(Vec::new());
235            }
236            return Err(IoError::RecvFailed(format!("poll: {err}")));
237        }
238        if ret == 0 {
239            return Ok(Vec::new());
240        }
241        let mut ready = Vec::new();
242        for (idx, pfd) in fds.iter().enumerate() {
243            if pfd.revents & libc::POLLIN != 0 {
244                ready.push(idx);
245            }
246        }
247        Ok(ready)
248    }
249
250    /// Receive a datagram from a specific socket by index.
251    pub fn recv_from(&mut self, socket_index: usize) -> Result<ReceivedDatagram, IoError> {
252        if socket_index >= self.sockets.len() {
253            return Err(IoError::RecvFailed(
254                "socket index out of bounds".to_string(),
255            ));
256        }
257        let socket = &self.sockets[socket_index];
258        let mut buf = [0u8; ntpsec_rs_core::NTP_MAX_PACKET_SIZE];
259
260        match recvmsg_with_timestamp(socket, &mut buf) {
261            Ok(Some((n, src, kernel_ts, ts_source))) => {
262                let dest_addr = socket_getsockname(socket);
263                let source_netaddr = socketaddr_to_netaddr2(&src);
264                let len = n.min(ntpsec_rs_core::NTP_MAX_PACKET_SIZE);
265                Ok(ReceivedDatagram {
266                    bytes: buf,
267                    len,
268                    source: source_netaddr,
269                    destination: socketaddr_to_netaddr2(&dest_addr),
270                    rx_timestamp: kernel_ts,
271                    interface_index: None,
272                    timestamp_source: ts_source,
273                })
274            }
275            Ok(None) => Err(IoError::RecvFailed("timeout".to_string())),
276            Err(e) => Err(e),
277        }
278    }
279}
280
281impl Drop for RealNetworkIo {
282    fn drop(&mut self) {
283        #[cfg(target_os = "linux")]
284        {
285            if self.epoll_fd >= 0 {
286                unsafe {
287                    libc::close(self.epoll_fd);
288                }
289            }
290        }
291    }
292}
293
294impl NetworkIo for RealNetworkIo {
295    fn bind(&mut self, addr: &str) -> Result<(), IoError> {
296        let sockaddr: std::net::SocketAddr = addr
297            .parse()
298            .map_err(|e| IoError::BindFailed(format!("parse addr: {e}")))?;
299
300        let domain = match sockaddr {
301            std::net::SocketAddr::V4(_) => Domain::IPV4,
302            std::net::SocketAddr::V6(_) => Domain::IPV6,
303        };
304
305        let socket = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))
306            .map_err(|e| IoError::BindFailed(format!("socket: {e}")))?;
307
308        // Enable software timestamps via SO_TIMESTAMPNS (widely supported).
309        let _ = ntp_packetstamp::enable_software_timestamps(socket.as_raw_fd());
310
311        // Enable hardware timestamps via SO_TIMESTAMPING (Linux NIC-dependent).
312        let _ = ntp_packetstamp::enable_hardware_timestamps(socket.as_raw_fd());
313
314        socket
315            .bind(&sockaddr.into())
316            .map_err(|e| IoError::BindFailed(format!("bind: {e}")))?;
317
318        // Track the socket and register with epoll if available
319        let fd = socket.as_raw_fd();
320        self.sockets.push(socket);
321        self.socket_fds.push(fd);
322
323        #[cfg(target_os = "linux")]
324        if self.epoll_fd >= 0 {
325            let mut event = libc::epoll_event {
326                events: libc::EPOLLIN as u32, // level-triggered — safe under partial drain
327                u64: fd as u64,
328            };
329            let ret =
330                unsafe { libc::epoll_ctl(self.epoll_fd, libc::EPOLL_CTL_ADD, fd, &mut event) };
331            if ret != 0 {
332                // epoll_ctl failure: disable epoll entirely, fall back to poll(2)
333                let _ = std::io::Error::last_os_error();
334                unsafe { libc::close(self.epoll_fd) };
335                self.epoll_fd = -1;
336            }
337        }
338
339        Ok(())
340    }
341
342    fn recv(&mut self) -> Result<ReceivedDatagram, IoError> {
343        let mut buf = [0u8; ntpsec_rs_core::NTP_MAX_PACKET_SIZE];
344
345        for socket in &self.sockets {
346            match recvmsg_with_timestamp(socket, &mut buf) {
347                Ok(Some((n, src, kernel_ts, ts_source))) => {
348                    // Get local address from getsockname
349                    let dest_addr = socket_getsockname(socket);
350
351                    let source_netaddr = socketaddr_to_netaddr2(&src);
352                    let len = n.min(ntpsec_rs_core::NTP_MAX_PACKET_SIZE);
353
354                    return Ok(ReceivedDatagram {
355                        bytes: buf,
356                        len,
357                        source: source_netaddr,
358                        destination: socketaddr_to_netaddr2(&dest_addr),
359                        rx_timestamp: kernel_ts,
360                        interface_index: None,
361                        timestamp_source: ts_source,
362                    });
363                }
364                Ok(None) => continue, // Timed out, try next socket
365                Err(e) => return Err(e),
366            }
367        }
368        Err(IoError::RecvFailed("no data available".to_string()))
369    }
370
371    fn send(&mut self, buf: &[u8], dest: &NetAddr) -> Result<usize, IoError> {
372        let dest_sa = netaddr_to_socketaddr(dest);
373        for socket in &self.sockets {
374            match socket.send_to(buf, &dest_sa.into()) {
375                Ok(n) => return Ok(n),
376                Err(_) => continue,
377            }
378        }
379        if let Some(socket) = self.sockets.first() {
380            socket
381                .send_to(buf, &dest_sa.into())
382                .map_err(|e| IoError::SendFailed(e.to_string()))
383        } else {
384            Err(IoError::SendFailed("no sockets available".to_string()))
385        }
386    }
387}
388
389/// Receive a datagram with a kernel timestamp using `recvmsg()` + `SO_TIMESTAMPNS`.
390///
391/// Returns `(bytes_received, source_address, kernel_timestamp, timestamp_source)` on success.
392/// Returns `Ok(None)` on timeout (no data available).
393fn recvmsg_with_timestamp(
394    socket: &Socket,
395    buf: &mut [u8],
396) -> Result<Option<(usize, std::net::SocketAddr, NtpTs64, TimestampSource)>, IoError> {
397    // Prepare the message header for recvmsg
398    let mut iov = libc::iovec {
399        iov_base: buf.as_mut_ptr() as *mut libc::c_void,
400        iov_len: buf.len(),
401    };
402
403    // Ancillary buffer with 16-byte alignment for cmsghdr + timespec.
404    // POSIX requires CMSG_DATA pointers to be suitably aligned for any data type.
405    // A 16-byte aligned 256-byte buffer satisfies this on all common architectures.
406    #[repr(C, align(16))]
407    struct AlignedBuf([u8; 256]);
408    let mut aligned = AlignedBuf([0u8; 256]);
409    let cmsg_ptr = aligned.0.as_mut_ptr() as *mut libc::c_void;
410
411    // Source address storage
412    let mut src_addr: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
413    let mut msg: libc::msghdr = unsafe { std::mem::zeroed() };
414    msg.msg_name = &mut src_addr as *mut _ as *mut libc::c_void;
415    msg.msg_namelen = std::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
416    msg.msg_iov = &mut iov;
417    msg.msg_iovlen = 1;
418    msg.msg_control = cmsg_ptr;
419    msg.msg_controllen = 256;
420
421    // Use the raw file descriptor from socket2
422    let fd = socket.as_raw_fd();
423
424    // Non-blocking receive (timeout is handled by the caller's polling loop).
425    // Retry on EINTR.
426    let ret = loop {
427        let r = unsafe { libc::recvmsg(fd, &mut msg, libc::MSG_DONTWAIT) };
428        if r < 0 {
429            let err = std::io::Error::last_os_error();
430            if err.raw_os_error() == Some(libc::EINTR) {
431                continue;
432            }
433            if err.kind() == std::io::ErrorKind::WouldBlock {
434                return Ok(None);
435            }
436            return Err(IoError::RecvFailed(err.to_string()));
437        }
438        break r;
439    };
440
441    // Check for truncated data
442    if (msg.msg_flags & libc::MSG_TRUNC) != 0 {
443        return Err(IoError::RecvFailed("packet truncated".to_string()));
444    }
445    let cmsg_truncated = (msg.msg_flags & libc::MSG_CTRUNC) != 0;
446
447    let n = ret as usize;
448
449    // Extract kernel timestamp from ancillary data with provenance.
450    // If ancillary data was truncated, record that in the source.
451    let (kernel_ts, ts_source) = match extract_scm_timestampns_with_source(&msg) {
452        Some((ts, source)) => (ts, source),
453        None => {
454            // Fallback to userspace clock
455            let mut ts = libc::timespec {
456                tv_sec: 0,
457                tv_nsec: 0,
458            };
459            unsafe {
460                libc::clock_gettime(libc::CLOCK_REALTIME, &mut ts);
461            }
462            let source = if cmsg_truncated {
463                TimestampSource::AncillaryTruncated
464            } else {
465                TimestampSource::UserspaceFallback
466            };
467            (ntp_fp::ts_to_ntp(ts.tv_sec, ts.tv_nsec), source)
468        }
469    };
470
471    // Convert source address
472    let src = match src_addr.ss_family as libc::c_int {
473        libc::AF_INET => {
474            let sin: &libc::sockaddr_in =
475                unsafe { &*(&src_addr as *const _ as *const libc::sockaddr_in) };
476            // s_addr is in host byte order as returned by the kernel.
477            // to_ne_bytes() extracts octets in the correct (host) order.
478            let ip =
479                std::net::IpAddr::V4(std::net::Ipv4Addr::from(sin.sin_addr.s_addr.to_ne_bytes()));
480            std::net::SocketAddr::new(ip, u16::from_be(sin.sin_port))
481        }
482        libc::AF_INET6 => {
483            let sin6: &libc::sockaddr_in6 =
484                unsafe { &*(&src_addr as *const _ as *const libc::sockaddr_in6) };
485            let ip = std::net::IpAddr::V6(std::net::Ipv6Addr::from(sin6.sin6_addr.s6_addr));
486            std::net::SocketAddr::new(ip, u16::from_be(sin6.sin6_port))
487        }
488        _ => {
489            return Err(IoError::RecvFailed("unknown address family".to_string()));
490        }
491    };
492
493    Ok(Some((n, src, kernel_ts, ts_source)))
494}
495
496/// Walk the control message header chain to find SCM_TIMESTAMPNS and extract the timespec
497/// and its provenance (KernelNanoseconds, KernelMicroseconds, or None).
498fn extract_scm_timestampns_with_source(msg: &libc::msghdr) -> Option<(NtpTs64, TimestampSource)> {
499    let mut cmsg_ptr: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(msg) };
500    while !cmsg_ptr.is_null() {
501        let cmsg = unsafe { &*cmsg_ptr };
502        if cmsg.cmsg_level == libc::SOL_SOCKET
503            && cmsg.cmsg_type == libc::SO_TIMESTAMPNS as libc::c_int
504        {
505            // Validate cmsg_len before reading a timespec
506            let required =
507                unsafe { libc::CMSG_LEN(std::mem::size_of::<libc::timespec>() as _) as usize };
508            if (cmsg.cmsg_len as usize) < required {
509                return None;
510            }
511            let ts: libc::timespec = unsafe {
512                let data_ptr = libc::CMSG_DATA(cmsg_ptr);
513                std::ptr::read(data_ptr as *const libc::timespec)
514            };
515            return Some((
516                ntp_fp::ts_to_ntp(ts.tv_sec, ts.tv_nsec),
517                TimestampSource::KernelNanoseconds,
518            ));
519        }
520        if cmsg.cmsg_level == libc::SOL_SOCKET
521            && cmsg.cmsg_type == libc::SO_TIMESTAMP as libc::c_int
522        {
523            let required =
524                unsafe { libc::CMSG_LEN(std::mem::size_of::<libc::timeval>() as _) as usize };
525            if (cmsg.cmsg_len as usize) < required {
526                return None;
527            }
528            let tv: libc::timeval = unsafe {
529                let data_ptr = libc::CMSG_DATA(cmsg_ptr);
530                std::ptr::read(data_ptr as *const libc::timeval)
531            };
532            let ntp = ntp_fp::tv_to_ntp(tv.tv_sec as i64, tv.tv_usec as i64);
533            return Some((ntp, TimestampSource::KernelMicroseconds));
534        }
535        // Handle SCM_TIMESTAMPING (SO_TIMESTAMPING ancillary data).
536        // The SCM_TIMESTAMPING cmsg_type on Linux is 0x2C.
537        const SCM_TIMESTAMPING_LINUX: libc::c_int = 0x2C;
538        #[cfg(target_os = "linux")]
539        {
540            if cmsg.cmsg_level == libc::SOL_SOCKET && cmsg.cmsg_type == SCM_TIMESTAMPING_LINUX {
541                // SCM_TIMESTAMPING carries three struct timespec values:
542                // [0] = hardware timestamp (preferred)
543                // [1] = software-converted timestamp
544                // [2] = software skb timestamp
545                let required = unsafe {
546                    libc::CMSG_LEN((3 * std::mem::size_of::<libc::timespec>()) as _) as usize
547                };
548                if (cmsg.cmsg_len as usize) < required {
549                    return None;
550                }
551                let ts_array: &[libc::timespec; 3] = unsafe {
552                    let data_ptr = libc::CMSG_DATA(cmsg_ptr);
553                    &*(data_ptr as *const [libc::timespec; 3])
554                };
555                // Prefer hardware timestamp (index 0), fall back to software (index 2).
556                let (ts, _is_hardware) = if ts_array[0].tv_sec != 0 || ts_array[0].tv_nsec != 0 {
557                    (&ts_array[0], true)
558                } else if ts_array[2].tv_sec != 0 || ts_array[2].tv_nsec != 0 {
559                    (&ts_array[2], false)
560                } else if ts_array[1].tv_sec != 0 || ts_array[1].tv_nsec != 0 {
561                    (&ts_array[1], false)
562                } else {
563                    return None;
564                };
565                let source = TimestampSource::KernelNanoseconds;
566                return Some((ntp_fp::ts_to_ntp(ts.tv_sec, ts.tv_nsec), source));
567            }
568        }
569        cmsg_ptr =
570            unsafe { libc::CMSG_NXTHDR(msg as *const libc::msghdr as *mut libc::msghdr, cmsg_ptr) };
571    }
572    None
573}
574
575/// Get the local socket address using getsockname(2).
576fn socket_getsockname(socket: &Socket) -> std::net::SocketAddr {
577    let mut addr: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
578    let mut len = std::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
579    let ret = unsafe {
580        libc::getsockname(
581            socket.as_raw_fd(),
582            &mut addr as *mut _ as *mut libc::sockaddr,
583            &mut len,
584        )
585    };
586    if ret != 0 {
587        return std::net::SocketAddr::new(
588            std::net::IpAddr::V4(std::net::Ipv4Addr::new(0, 0, 0, 0)),
589            123,
590        );
591    }
592    match addr.ss_family as libc::c_int {
593        libc::AF_INET => {
594            let sin: &libc::sockaddr_in =
595                unsafe { &*(&addr as *const _ as *const libc::sockaddr_in) };
596            // s_addr is in host byte order as returned by the kernel.
597            // to_ne_bytes() extracts octets in the correct (host) order.
598            let ip =
599                std::net::IpAddr::V4(std::net::Ipv4Addr::from(sin.sin_addr.s_addr.to_ne_bytes()));
600            std::net::SocketAddr::new(ip, u16::from_be(sin.sin_port))
601        }
602        libc::AF_INET6 => {
603            let sin6: &libc::sockaddr_in6 =
604                unsafe { &*(&addr as *const _ as *const libc::sockaddr_in6) };
605            let ip = std::net::IpAddr::V6(std::net::Ipv6Addr::from(sin6.sin6_addr.s6_addr));
606            std::net::SocketAddr::new(ip, u16::from_be(sin6.sin6_port))
607        }
608        _ => std::net::SocketAddr::new(
609            std::net::IpAddr::V4(std::net::Ipv4Addr::new(0, 0, 0, 0)),
610            123,
611        ),
612    }
613}
614
615// ──── Address conversion helpers ──────────────────────────────────────
616
617fn socketaddr_to_netaddr2(sa: &std::net::SocketAddr) -> NetAddr {
618    match sa {
619        std::net::SocketAddr::V4(v4) => {
620            let mut addr = [0u8; 16];
621            addr[..4].copy_from_slice(&v4.ip().octets());
622            NetAddr {
623                family: 4,
624                addr,
625                port: v4.port(),
626            }
627        }
628        std::net::SocketAddr::V6(v6) => NetAddr {
629            family: 6,
630            addr: v6.ip().octets(),
631            port: v6.port(),
632        },
633    }
634}
635
636fn netaddr_to_socketaddr(na: &NetAddr) -> std::net::SocketAddr {
637    match na.family {
638        4 => {
639            let octets = [na.addr[0], na.addr[1], na.addr[2], na.addr[3]];
640            std::net::SocketAddr::new(
641                std::net::IpAddr::V4(std::net::Ipv4Addr::from(octets)),
642                na.port,
643            )
644        }
645        _ => std::net::SocketAddr::new(
646            std::net::IpAddr::V6(std::net::Ipv6Addr::from(na.addr)),
647            na.port,
648        ),
649    }
650}
651
652// ──── StateStore ──────────────────────────────────────────────────────
653
654#[derive(Debug)]
655pub struct FileStateStore {
656    drift_path: std::path::PathBuf,
657    stats_dir: std::path::PathBuf,
658}
659
660impl FileStateStore {
661    pub fn new(base_path: &std::path::Path) -> Self {
662        Self {
663            drift_path: base_path.join("ntp.drift"),
664            stats_dir: base_path.to_path_buf(),
665        }
666    }
667
668    /// Create a FileStateStore with a custom drift file path.
669    pub fn with_drift_path(base_path: &std::path::Path, drift_file: &std::path::Path) -> Self {
670        Self {
671            drift_path: drift_file.to_path_buf(),
672            stats_dir: base_path.to_path_buf(),
673        }
674    }
675}
676
677impl StateStore for FileStateStore {
678    fn load_drift(&self) -> Result<f64, IoError> {
679        let content = std::fs::read_to_string(&self.drift_path)
680            .map_err(|e| IoError::FileFailed(format!("read drift: {e}")))?;
681        content
682            .trim()
683            .parse::<f64>()
684            .map_err(|e| IoError::FileFailed(format!("parse drift: {e}")))
685    }
686
687    fn save_drift(&mut self, freq_ppm: f64) -> Result<(), IoError> {
688        let tmp_path = self.drift_path.with_extension("drift.tmp");
689        std::fs::write(&tmp_path, format!("{:.3}\n", freq_ppm))
690            .map_err(|e| IoError::FileFailed(format!("write drift: {e}")))?;
691        std::fs::rename(&tmp_path, &self.drift_path)
692            .map_err(|e| IoError::FileFailed(format!("rename drift: {e}")))?;
693        Ok(())
694    }
695
696    fn load_leap(&self) -> Result<String, IoError> {
697        let path = self.stats_dir.join("leap-seconds");
698        std::fs::read_to_string(&path).map_err(|e| IoError::FileFailed(format!("read leap: {e}")))
699    }
700
701    fn append_stats(&mut self, stream: &str, line: &str) -> Result<(), IoError> {
702        let path = self.stats_dir.join(stream);
703        use std::io::Write;
704        let mut file = std::fs::OpenOptions::new()
705            .create(true)
706            .append(true)
707            .open(&path)
708            .map_err(|e| IoError::FileFailed(format!("open stats: {e}")))?;
709        writeln!(file, "{}", line).map_err(|e| IoError::FileFailed(format!("write stats: {e}")))?;
710        Ok(())
711    }
712}
713
714#[test]
715fn test_real_loopback_kernel_timestamp() {
716    // Real loopback test: bind, send a packet, receive through RealNetworkIo,
717    // and verify the kernel timestamp provenance with nanosecond bounds.
718    use std::net::UdpSocket;
719    let mut net = RealNetworkIo::new();
720    net.bind("127.0.0.1:0").expect("bind loopback");
721    let local_addr = net.sockets[0].local_addr().unwrap().as_socket().unwrap();
722
723    // Capture before with nanosecond precision
724    let mut ts_before = libc::timespec {
725        tv_sec: 0,
726        tv_nsec: 0,
727    };
728    unsafe {
729        libc::clock_gettime(libc::CLOCK_REALTIME, &mut ts_before);
730    }
731    let before = ntp_fp::ts_to_ntp(ts_before.tv_sec, ts_before.tv_nsec);
732
733    let sender = UdpSocket::bind("127.0.0.1:0").expect("bind sender");
734    sender.send_to(&[0u8; 48], local_addr).expect("send");
735
736    let dgram = net.recv().expect("recv");
737
738    let mut ts_after = libc::timespec {
739        tv_sec: 0,
740        tv_nsec: 0,
741    };
742    unsafe {
743        libc::clock_gettime(libc::CLOCK_REALTIME, &mut ts_after);
744    }
745    let after = ntp_fp::ts_to_ntp(ts_after.tv_sec, ts_after.tv_nsec);
746
747    // Packet integrity — compare only the valid bytes in the fixed-size buffer
748    assert_eq!(dgram.data(), &[0u8; 48]);
749    assert_eq!(dgram.source.addr[..4], [127, 0, 0, 1], "source loopback");
750
751    // Timestamp provenance: on Linux with SO_TIMESTAMPNS, this must be
752    // KernelNanoseconds for a loopback test. On platforms without
753    // SO_TIMESTAMPNS (macOS, BSD), it will be UserspaceFallback.
754    #[cfg(target_os = "linux")]
755    assert_eq!(
756        dgram.timestamp_source,
757        TimestampSource::KernelNanoseconds,
758        "On Linux, loopback should produce SCM_TIMESTAMPNS"
759    );
760
761    // Verify timestamp is bounded by before/after with nanosecond precision.
762    // The kernel timestamp may be captured slightly before `before` if the
763    // packet arrived between send_to() and clock_gettime(). Allow 1ms slop.
764    let t_rx = ntp_fp::ntp_ts64_to_double(dgram.rx_timestamp);
765    let t_before = ntp_fp::ntp_ts64_to_double(before) - 0.001;
766    let t_after = ntp_fp::ntp_ts64_to_double(after) + 0.001;
767    assert!(
768        t_rx >= t_before,
769        "rx {:.6}s should be >= before-1ms {:.6}s",
770        t_rx,
771        t_before
772    );
773    assert!(
774        t_rx <= t_after,
775        "rx {:.6}s should be <= after+1ms {:.6}s",
776        t_rx,
777        t_after
778    );
779}
780
781#[cfg(test)]
782mod tests {
783    use super::*;
784
785    #[test]
786    fn test_system_clock_now() {
787        let clock = RealSystemClock::new();
788        let now = clock.now();
789        assert!(
790            now.seconds > 2_208_988_800,
791            "NTP time should be > 1900 epoch"
792        );
793    }
794
795    #[test]
796    fn test_system_clock_frequency() {
797        let mut clock = RealSystemClock::new();
798        let freq = clock.read_frequency().unwrap();
799        assert!(freq.is_finite());
800        assert!(
801            freq.abs() < 500_000.0,
802            "frequency {freq} ppm should be reasonable"
803        );
804        clock.set_frequency(freq).ok();
805    }
806
807    #[test]
808    fn test_state_store() {
809        let tmp = std::env::temp_dir().join("ntpsec-rs-test-io");
810        let _ = std::fs::create_dir_all(&tmp);
811        let mut store = FileStateStore::new(&tmp);
812
813        assert!(store.save_drift(42.5).is_ok());
814        let loaded = store.load_drift().unwrap();
815        assert!((loaded - 42.5).abs() < 0.001);
816
817        assert!(store.append_stats("loopstats", "test line").is_ok());
818        let content = std::fs::read_to_string(tmp.join("loopstats")).unwrap();
819        assert!(content.contains("test line"));
820
821        let _ = std::fs::remove_file(tmp.join("ntp.drift"));
822        let _ = std::fs::remove_file(tmp.join("ntp.drift.tmp"));
823        let _ = std::fs::remove_file(tmp.join("loopstats"));
824        let _ = std::fs::remove_dir(&tmp);
825    }
826
827    #[test]
828    fn test_netaddr_conversion_roundtrip() {
829        let addr = netaddr_to_socketaddr(&NetAddr::ipv4(0x7f000001, 123));
830        assert_eq!(
831            addr,
832            std::net::SocketAddr::new(
833                std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1)),
834                123
835            )
836        );
837
838        let na = socketaddr_to_netaddr2(&addr);
839        assert_eq!(na.port, 123);
840        assert_eq!(na.addr[..4], [127, 0, 0, 1]);
841    }
842}