1use 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#[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#[derive(Debug)]
114pub struct RealNetworkIo {
115 sockets: Vec<Socket>,
116 epoll_fd: i32,
118 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 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 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 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 #[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 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 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 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 let _ = ntp_packetstamp::enable_software_timestamps(socket.as_raw_fd());
310
311 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 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, 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 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 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, 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
389fn recvmsg_with_timestamp(
394 socket: &Socket,
395 buf: &mut [u8],
396) -> Result<Option<(usize, std::net::SocketAddr, NtpTs64, TimestampSource)>, IoError> {
397 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 #[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 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 let fd = socket.as_raw_fd();
423
424 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 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 let (kernel_ts, ts_source) = match extract_scm_timestampns_with_source(&msg) {
452 Some((ts, source)) => (ts, source),
453 None => {
454 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 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 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
496fn 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 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 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 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 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
575fn 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 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
615fn 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#[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 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 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 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 assert_eq!(dgram.data(), &[0u8; 48]);
749 assert_eq!(dgram.source.addr[..4], [127, 0, 0, 1], "source loopback");
750
751 #[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 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}