1use crate::ClockError;
17use std::net::UdpSocket;
18use std::time::Duration;
19
20#[cfg(unix)]
23pub fn wait_readable(socket: &UdpSocket, timeout: Duration) -> Result<bool, ClockError> {
24 use std::os::fd::AsRawFd;
25
26 let mut pfd = libc::pollfd {
27 fd: socket.as_raw_fd(),
28 events: libc::POLLIN,
29 revents: 0,
30 };
31 let timeout_ms = timeout.as_millis().min(i32::MAX as u128) as libc::c_int;
32 loop {
33 let rc = unsafe { libc::poll(&mut pfd, 1, timeout_ms) };
36 if rc > 0 {
37 return Ok(pfd.revents & (libc::POLLIN | libc::POLLERR | libc::POLLHUP) != 0);
38 }
39 if rc == 0 {
40 return Ok(false);
41 }
42 let err = std::io::Error::last_os_error();
43 if err.kind() == std::io::ErrorKind::Interrupted {
44 continue;
45 }
46 return Err(ClockError {
47 op: "poll",
48 detail: err.to_string(),
49 });
50 }
51}
52
53#[cfg(windows)]
54pub fn wait_readable(_socket: &UdpSocket, _timeout: Duration) -> Result<bool, ClockError> {
55 Ok(true)
57}
58
59#[derive(Clone, Copy, Debug)]
62pub struct Received {
63 pub len: usize,
64 pub peer: std::net::SocketAddr,
65 pub kernel_rx_s: Option<f64>,
74}
75
76#[cfg(target_os = "linux")]
83pub fn enable_rx_timestamps(socket: &UdpSocket) -> Result<(), ClockError> {
84 use std::os::fd::AsRawFd;
85
86 const RX_HARDWARE: libc::c_int = 1 << 0;
89 const RX_SOFTWARE: libc::c_int = 1 << 3;
90 const SOFTWARE: libc::c_int = 1 << 4;
91 const RAW_HARDWARE: libc::c_int = 1 << 6;
92
93 let flags: libc::c_int = RX_SOFTWARE | SOFTWARE | RX_HARDWARE | RAW_HARDWARE;
94 let rc = unsafe {
97 libc::setsockopt(
98 socket.as_raw_fd(),
99 libc::SOL_SOCKET,
100 libc::SO_TIMESTAMPING,
101 (&raw const flags).cast::<libc::c_void>(),
102 core::mem::size_of::<libc::c_int>() as libc::socklen_t,
103 )
104 };
105 if rc != 0 {
106 return Err(ClockError {
107 op: "setsockopt(SO_TIMESTAMPING)",
108 detail: std::io::Error::last_os_error().to_string(),
109 });
110 }
111 Ok(())
112}
113
114#[cfg(not(target_os = "linux"))]
115pub fn enable_rx_timestamps(_socket: &UdpSocket) -> Result<(), ClockError> {
116 Err(ClockError {
119 op: "enable_rx_timestamps",
120 detail: "kernel receive timestamps are not implemented on this platform".into(),
121 })
122}
123
124pub fn activated_udp_socket() -> Option<UdpSocket> {
134 #[cfg(target_os = "linux")]
135 {
136 use std::os::fd::FromRawFd;
137
138 if !should_adopt_activated(
139 std::env::var("LISTEN_PID").ok().as_deref(),
140 std::env::var("LISTEN_FDS").ok().as_deref(),
141 std::process::id(),
142 ) {
143 return None;
144 }
145 Some(unsafe { UdpSocket::from_raw_fd(3) })
149 }
150 #[cfg(not(target_os = "linux"))]
151 {
152 None
153 }
154}
155
156pub fn should_adopt_activated(
166 listen_pid: Option<&str>,
167 listen_fds: Option<&str>,
168 our_pid: u32,
169) -> bool {
170 let for_us = listen_pid
171 .and_then(|p| p.parse::<u32>().ok())
172 .map(|pid| pid == our_pid)
173 .unwrap_or(false);
174 let count = listen_fds.and_then(|n| n.parse::<i32>().ok()).unwrap_or(0);
175 for_us && count >= 1
176}
177
178pub const BATCH_SIZE: usize = 32;
181
182#[cfg(target_os = "linux")]
190#[derive(Default)]
191pub struct BatchScratch {
192 want_control: bool,
198 iovecs: Vec<libc::iovec>,
199 addrs: Vec<libc::sockaddr_storage>,
200 msgs: Vec<libc::mmsghdr>,
201 controls: Vec<[u8; CONTROL_LEN]>,
202}
203
204#[cfg(target_os = "linux")]
205impl BatchScratch {
206 pub fn new() -> Self {
208 let mut scratch = BatchScratch {
209 want_control: true,
210 ..BatchScratch::default()
211 };
212 scratch.ensure(BATCH_SIZE);
213 scratch
214 }
215
216 pub fn without_timestamps() -> Self {
218 let mut scratch = BatchScratch::default();
219 scratch.ensure(BATCH_SIZE);
220 scratch
221 }
222
223 fn ensure(&mut self, count: usize) {
225 if self.msgs.len() >= count {
226 return;
227 }
228 self.iovecs
232 .resize(count, unsafe { core::mem::zeroed::<libc::iovec>() });
233 self.addrs.resize(count, unsafe {
234 core::mem::zeroed::<libc::sockaddr_storage>()
235 });
236 self.msgs
237 .resize(count, unsafe { core::mem::zeroed::<libc::mmsghdr>() });
238 self.controls.resize(count, [0u8; CONTROL_LEN]);
239 }
240}
241
242#[cfg(not(target_os = "linux"))]
244#[derive(Default)]
245pub struct BatchScratch;
246
247#[cfg(not(target_os = "linux"))]
248impl BatchScratch {
249 pub fn new() -> Self {
250 BatchScratch
251 }
252
253 pub fn without_timestamps() -> Self {
257 BatchScratch
258 }
259}
260
261#[cfg(target_os = "linux")]
269pub fn recv_batch(
270 socket: &UdpSocket,
271 bufs: &mut [[u8; 1024]],
272 scratch: &mut BatchScratch,
273 out: &mut Vec<Received>,
274) -> Result<usize, ClockError> {
275 use std::os::fd::AsRawFd;
276
277 out.clear();
278 let count = bufs.len().min(BATCH_SIZE);
279 if count == 0 {
280 return Ok(0);
281 }
282 scratch.ensure(count);
283
284 let BatchScratch {
294 want_control,
295 iovecs,
296 addrs,
297 msgs,
298 controls,
299 } = scratch;
300 for i in 0..count {
301 iovecs[i] = libc::iovec {
302 iov_base: bufs[i].as_mut_ptr().cast::<libc::c_void>(),
303 iov_len: bufs[i].len(),
304 };
305 }
306 for i in 0..count {
307 let hdr = &mut msgs[i].msg_hdr;
308 hdr.msg_name = (&mut addrs[i] as *mut libc::sockaddr_storage).cast::<libc::c_void>();
309 hdr.msg_namelen = core::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
310 hdr.msg_iov = (&mut iovecs[i]) as *mut libc::iovec;
311 hdr.msg_iovlen = 1;
312 if *want_control {
313 hdr.msg_control = controls[i].as_mut_ptr().cast::<libc::c_void>();
314 hdr.msg_controllen = CONTROL_LEN as _;
315 } else {
316 hdr.msg_control = core::ptr::null_mut();
317 hdr.msg_controllen = 0;
318 }
319 msgs[i].msg_len = 0;
320 }
321
322 let received = unsafe {
327 libc::recvmmsg(
328 socket.as_raw_fd(),
329 msgs.as_mut_ptr(),
330 count as libc::c_uint,
331 libc::MSG_DONTWAIT as _,
334 core::ptr::null_mut(),
335 )
336 };
337 if received < 0 {
338 let err = std::io::Error::last_os_error();
339 if matches!(
340 err.kind(),
341 std::io::ErrorKind::WouldBlock | std::io::ErrorKind::Interrupted
342 ) {
343 return Ok(0);
344 }
345 return Err(ClockError {
346 op: "recvmmsg",
347 detail: err.to_string(),
348 });
349 }
350
351 for msg in msgs.iter().take(received as usize) {
352 let len = msg.msg_len as usize;
353 let peer =
356 unsafe { sockaddr_to_rust(&*(msg.msg_hdr.msg_name as *const libc::sockaddr_storage)) };
357 if let Some(peer) = peer {
358 let kernel_rx_s = unsafe { kernel_timestamp(&msg.msg_hdr) };
361 out.push(Received {
362 len,
363 peer,
364 kernel_rx_s,
365 });
366 }
367 }
368 Ok(out.len())
369}
370
371#[cfg(target_os = "linux")]
374const CONTROL_LEN: usize = 128;
375
376#[cfg(target_os = "linux")]
388unsafe fn kernel_timestamp(hdr: &libc::msghdr) -> Option<f64> {
389 if hdr.msg_controllen == 0 || hdr.msg_control.is_null() {
390 return None;
391 }
392 let mut cmsg = unsafe { libc::CMSG_FIRSTHDR(hdr) };
394 while !cmsg.is_null() {
395 let header = unsafe { &*cmsg };
397 if header.cmsg_level == libc::SOL_SOCKET && header.cmsg_type == libc::SCM_TIMESTAMPING {
398 let stamps = unsafe { libc::CMSG_DATA(cmsg).cast::<libc::timespec>() };
400 for index in [0usize, 2] {
401 let ts = unsafe { *stamps.add(index) };
403 if ts.tv_sec != 0 || ts.tv_nsec != 0 {
404 return Some(ts.tv_sec as f64 + ts.tv_nsec as f64 * 1e-9);
405 }
406 }
407 }
408 cmsg = unsafe { libc::CMSG_NXTHDR(hdr, cmsg) };
410 }
411 None
412}
413
414#[cfg(target_os = "linux")]
415#[cfg(target_os = "linux")]
417fn rust_to_sockaddr(
418 addr: &std::net::SocketAddr,
419 out: &mut libc::sockaddr_storage,
420) -> libc::socklen_t {
421 match addr {
422 std::net::SocketAddr::V4(v4) => {
423 let sin = unsafe { &mut *(out as *mut _ as *mut libc::sockaddr_in) };
426 sin.sin_family = libc::AF_INET as libc::sa_family_t;
427 sin.sin_port = v4.port().to_be();
428 sin.sin_addr.s_addr = u32::from(*v4.ip()).to_be();
429 core::mem::size_of::<libc::sockaddr_in>() as libc::socklen_t
430 }
431 std::net::SocketAddr::V6(v6) => {
432 let sin6 = unsafe { &mut *(out as *mut _ as *mut libc::sockaddr_in6) };
434 sin6.sin6_family = libc::AF_INET6 as libc::sa_family_t;
435 sin6.sin6_port = v6.port().to_be();
436 sin6.sin6_addr.s6_addr = v6.ip().octets();
437 sin6.sin6_flowinfo = v6.flowinfo();
438 sin6.sin6_scope_id = v6.scope_id();
439 core::mem::size_of::<libc::sockaddr_in6>() as libc::socklen_t
440 }
441 }
442}
443
444#[cfg(target_os = "linux")]
459pub fn send_batch(
460 socket: &UdpSocket,
461 messages: &[(&[u8], std::net::SocketAddr)],
462 scratch: &mut BatchScratch,
463) -> Result<usize, ClockError> {
464 send_batch_by(socket, messages, |m| m.0, |m| m.1, scratch)
465}
466
467#[cfg(target_os = "linux")]
474pub fn send_batch_by<T>(
475 socket: &UdpSocket,
476 items: &[T],
477 payload: impl Fn(&T) -> &[u8],
478 peer: impl Fn(&T) -> std::net::SocketAddr,
479 scratch: &mut BatchScratch,
480) -> Result<usize, ClockError> {
481 use std::os::fd::AsRawFd;
482
483 let count = items.len().min(BATCH_SIZE);
484 if count == 0 {
485 return Ok(0);
486 }
487 scratch.ensure(count);
488 let BatchScratch {
489 iovecs,
490 addrs,
491 msgs,
492 ..
493 } = scratch;
494
495 for (i, item) in items.iter().enumerate().take(count) {
496 let bytes = payload(item);
497 iovecs[i] = libc::iovec {
498 iov_base: bytes.as_ptr() as *mut libc::c_void,
499 iov_len: bytes.len(),
500 };
501 let namelen = rust_to_sockaddr(&peer(item), &mut addrs[i]);
502 let hdr = &mut msgs[i].msg_hdr;
503 hdr.msg_name = (&mut addrs[i] as *mut libc::sockaddr_storage).cast::<libc::c_void>();
504 hdr.msg_namelen = namelen;
505 hdr.msg_iov = (&mut iovecs[i]) as *mut libc::iovec;
506 hdr.msg_iovlen = 1;
507 hdr.msg_control = core::ptr::null_mut();
508 hdr.msg_controllen = 0;
509 msgs[i].msg_len = 0;
510 }
511
512 let sent = unsafe {
516 libc::sendmmsg(
517 socket.as_raw_fd(),
518 msgs.as_mut_ptr(),
519 count as libc::c_uint,
520 libc::MSG_DONTWAIT as _,
521 )
522 };
523 if sent < 0 {
524 let err = std::io::Error::last_os_error();
525 if matches!(
526 err.kind(),
527 std::io::ErrorKind::WouldBlock | std::io::ErrorKind::Interrupted
528 ) {
529 return Ok(0);
530 }
531 return Err(ClockError {
532 op: "sendmmsg",
533 detail: err.to_string(),
534 });
535 }
536 Ok(sent as usize)
537}
538
539#[cfg(not(target_os = "linux"))]
541pub fn send_batch(
542 socket: &UdpSocket,
543 messages: &[(&[u8], std::net::SocketAddr)],
544 scratch: &mut BatchScratch,
545) -> Result<usize, ClockError> {
546 send_batch_by(socket, messages, |m| m.0, |m| m.1, scratch)
547}
548
549#[cfg(not(target_os = "linux"))]
551pub fn send_batch_by<T>(
552 socket: &UdpSocket,
553 items: &[T],
554 payload: impl Fn(&T) -> &[u8],
555 peer: impl Fn(&T) -> std::net::SocketAddr,
556 _scratch: &mut BatchScratch,
557) -> Result<usize, ClockError> {
558 let mut sent = 0;
559 for item in items {
560 match socket.send_to(payload(item), peer(item)) {
561 Ok(_) => sent += 1,
562 Err(e)
563 if matches!(
564 e.kind(),
565 std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
566 ) =>
567 {
568 break;
569 }
570 Err(e) => {
571 return Err(ClockError {
572 op: "send_to",
573 detail: e.to_string(),
574 });
575 }
576 }
577 }
578 Ok(sent)
579}
580
581#[cfg(target_os = "linux")]
582fn sockaddr_to_rust(storage: &libc::sockaddr_storage) -> Option<std::net::SocketAddr> {
583 use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
584 match storage.ss_family as libc::c_int {
585 libc::AF_INET => {
586 let sin = unsafe { &*(storage as *const _ as *const libc::sockaddr_in) };
588 let ip = Ipv4Addr::from(u32::from_be(sin.sin_addr.s_addr));
589 Some(std::net::SocketAddr::V4(SocketAddrV4::new(
590 ip,
591 u16::from_be(sin.sin_port),
592 )))
593 }
594 libc::AF_INET6 => {
595 let sin6 = unsafe { &*(storage as *const _ as *const libc::sockaddr_in6) };
597 let ip = Ipv6Addr::from(sin6.sin6_addr.s6_addr);
598 Some(std::net::SocketAddr::V6(SocketAddrV6::new(
599 ip,
600 u16::from_be(sin6.sin6_port),
601 sin6.sin6_flowinfo,
602 sin6.sin6_scope_id,
603 )))
604 }
605 _ => None,
606 }
607}
608
609#[cfg(not(target_os = "linux"))]
612pub fn recv_batch(
613 socket: &UdpSocket,
614 bufs: &mut [[u8; 1024]],
615 _scratch: &mut BatchScratch,
616 out: &mut Vec<Received>,
617) -> Result<usize, ClockError> {
618 out.clear();
619 let Some(buf) = bufs.first_mut() else {
620 return Ok(0);
621 };
622 match socket.recv_from(buf) {
623 Ok((len, peer)) => {
624 out.push(Received {
625 len,
626 peer,
627 kernel_rx_s: None,
628 });
629 Ok(1)
630 }
631 Err(e)
632 if matches!(
633 e.kind(),
634 std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
635 ) =>
636 {
637 Ok(0)
638 }
639 Err(e) => Err(ClockError {
640 op: "recv_from",
641 detail: e.to_string(),
642 }),
643 }
644}
645
646#[cfg(test)]
647mod tests {
648 use super::*;
649
650 #[test]
651 fn timeout_and_readable_paths() {
652 let a = UdpSocket::bind("127.0.0.1:0").expect("bind a");
653 let b = UdpSocket::bind("127.0.0.1:0").expect("bind b");
654 let quick = wait_readable(&a, Duration::from_millis(50)).expect("wait");
657 if cfg!(unix) {
658 assert!(!quick, "empty socket reported readable");
659 } else {
660 assert!(quick);
661 }
662 b.send_to(b"x", a.local_addr().expect("addr"))
663 .expect("send");
664 let ready = wait_readable(&a, Duration::from_millis(2000)).expect("wait");
665 assert!(ready, "pending datagram not reported readable");
666 }
667
668 #[test]
669 fn batch_receive_returns_every_datagram_with_its_sender() {
670 let server = UdpSocket::bind("127.0.0.1:0").expect("bind server");
671 let server_addr = server.local_addr().expect("addr");
672 server
673 .set_read_timeout(Some(Duration::from_millis(500)))
674 .expect("timeout");
675
676 let client = UdpSocket::bind("127.0.0.1:0").expect("bind client");
677 let client_addr = client.local_addr().expect("client addr");
678 let sent = 5usize;
679 for i in 0..sent {
680 client.send_to(&[i as u8; 16], server_addr).expect("send");
681 }
682
683 let mut bufs = [[0u8; 1024]; BATCH_SIZE];
686 let mut out = Vec::new();
687 let mut total = 0usize;
688 let mut idle = 0;
689 while total < sent && idle < 20 {
690 if !wait_readable(&server, Duration::from_millis(200)).expect("wait") {
691 idle += 1;
692 continue;
693 }
694 let n =
695 recv_batch(&server, &mut bufs, &mut BatchScratch::new(), &mut out).expect("batch");
696 if n == 0 {
697 idle += 1;
698 continue;
699 }
700 for received in out.iter().take(n) {
701 assert_eq!(received.len, 16, "wrong length reported");
702 assert_eq!(
703 received.peer, client_addr,
704 "batch reported the wrong sender"
705 );
706 }
707 total += n;
708 }
709 assert_eq!(total, sent, "batch receive lost datagrams");
710 }
711
712 #[test]
713 fn activation_is_refused_unless_the_descriptors_are_ours() {
714 assert!(should_adopt_activated(Some("42"), Some("1"), 42));
716 assert!(!should_adopt_activated(Some("41"), Some("1"), 42));
719 assert!(!should_adopt_activated(None, None, 42));
721 assert!(!should_adopt_activated(Some("42"), Some("0"), 42));
723 assert!(!should_adopt_activated(Some("not-a-pid"), Some("1"), 42));
725 assert!(!should_adopt_activated(Some("42"), Some("many"), 42));
726 }
727
728 #[test]
729 fn batch_receive_on_an_empty_socket_returns_zero_not_an_error() {
730 let s = UdpSocket::bind("127.0.0.1:0").expect("bind");
731 s.set_read_timeout(Some(Duration::from_millis(50)))
732 .expect("timeout");
733 let mut bufs = [[0u8; 1024]; 4];
734 let mut out = Vec::new();
735 assert_eq!(
736 recv_batch(&s, &mut bufs, &mut BatchScratch::new(), &mut out).expect("batch"),
737 0
738 );
739 assert!(out.is_empty());
740 }
741}