1use rusty_time_core::ntp::{self, HEADER_LEN, LeapIndicator, Mode, NtpPacket, NtpTimestamp};
20use rusty_time_core::{Sample, SampleRegister, VirtualClock};
21
22#[cfg(target_arch = "wasm32")]
23use wasm_bindgen::prelude::*;
24
25const BROWSER_ERROR_FLOOR_MS: f64 = 1.0;
29
30const REGISTER_CAPACITY: usize = 16;
33
34#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
36pub struct TimeClient {
37 register: SampleRegister,
38 vclock: VirtualClock,
39 pending_t1_ms: Option<f64>,
41 pending_nonce: NtpTimestamp,
44 last_mono_ms: f64,
46 accepted: u32,
47 rejected: u32,
48}
49
50impl Default for TimeClient {
51 fn default() -> Self {
52 Self::new_inner()
53 }
54}
55
56impl TimeClient {
57 fn new_inner() -> Self {
58 TimeClient {
59 register: SampleRegister::new(REGISTER_CAPACITY),
60 vclock: VirtualClock::new(),
61 pending_t1_ms: None,
62 pending_nonce: NtpTimestamp::ZERO,
63 last_mono_ms: 0.0,
64 accepted: 0,
65 rejected: 0,
66 }
67 }
68
69 pub fn build_request_with_nonce(&mut self, date_now_ms: f64, nonce: u64) -> Vec<u8> {
73 let nonce = NtpTimestamp(nonce);
74 self.pending_nonce = nonce;
75 self.pending_t1_ms = Some(date_now_ms);
76 NtpPacket::client_request(4, nonce).to_bytes().to_vec()
77 }
78
79 pub fn process_response_inner(
85 &mut self,
86 bytes: &[u8],
87 date_now_ms: f64,
88 perf_now_ms: f64,
89 ) -> bool {
90 let Some(t1_ms) = self.pending_t1_ms else {
91 self.rejected += 1;
92 return false;
93 };
94 if bytes.len() < HEADER_LEN {
95 self.rejected += 1;
96 return false;
97 }
98 let Ok(packet) = NtpPacket::parse(bytes) else {
99 self.rejected += 1;
100 return false;
101 };
102
103 let usable = packet.mode == Mode::Server
106 && packet.origin_ts == self.pending_nonce
107 && packet.stratum != 0
108 && packet.stratum <= 15
109 && packet.leap != LeapIndicator::Unsynchronized
110 && !packet.receive_ts.is_zero()
111 && !packet.transmit_ts.is_zero();
112 if !usable {
113 self.rejected += 1;
114 return false;
115 }
116 self.pending_t1_ms = None;
117
118 let t1 = t1_ms / 1e3;
121 let t4 = date_now_ms / 1e3;
122 let t2 = ntp_to_unix_near(packet.receive_ts, t1);
123 let t3 = ntp_to_unix_near(packet.transmit_ts, t4);
124 let (offset, delay) = ntp::offset_delay(t1, t2, t3, t4);
125 if delay < 0.0 {
126 self.rejected += 1;
128 return false;
129 }
130
131 let mono_s = perf_now_ms / 1e3;
132 self.register.push(Sample {
133 t: mono_s,
134 offset,
135 delay,
136 dispersion: packet.root_dispersion.to_seconds(),
137 });
138 self.last_mono_ms = perf_now_ms;
139 self.accepted += 1;
140
141 let (best_offset, error_s) = match self.register.regress(mono_s) {
144 Some(est) => (
145 est.offset,
146 est.offset_sd.max(delay / 2.0) + BROWSER_ERROR_FLOOR_MS / 1e3,
147 ),
148 None => (offset, delay / 2.0 + BROWSER_ERROR_FLOOR_MS / 1e3),
149 };
150 self.vclock.update(mono_s, best_offset, None, error_s);
151 true
152 }
153}
154
155fn ntp_to_unix_near(ts: NtpTimestamp, pivot_unix_s: f64) -> f64 {
157 const ERA: f64 = 4_294_967_296.0;
158 let base = ts.seconds() as f64 - ntp::UNIX_EPOCH_OFFSET as f64 + ts.fraction() as f64 / ERA;
159 let mut best = base;
160 let mut best_dist = (base - pivot_unix_s).abs();
161 for k in [-1.0f64, 1.0] {
162 let candidate = base + k * ERA;
163 let distance = (candidate - pivot_unix_s).abs();
164 if distance < best_dist {
165 best = candidate;
166 best_dist = distance;
167 }
168 }
169 best
170}
171
172#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
173impl TimeClient {
174 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
175 pub fn new() -> TimeClient {
176 TimeClient::new_inner()
177 }
178
179 pub fn build_request(&mut self, date_now_ms: f64, nonce_hi: u32, nonce_lo: u32) -> Vec<u8> {
184 let nonce = ((nonce_hi as u64) << 32) | nonce_lo as u64;
185 self.build_request_with_nonce(date_now_ms, nonce)
186 }
187
188 pub fn process_response(&mut self, bytes: &[u8], date_now_ms: f64, perf_now_ms: f64) -> bool {
190 self.process_response_inner(bytes, date_now_ms, perf_now_ms)
191 }
192
193 pub fn now_ms(&mut self, date_now_ms: f64, perf_now_ms: f64) -> f64 {
195 self.vclock.now(perf_now_ms / 1e3, date_now_ms / 1e3) * 1e3
196 }
197
198 pub fn confidence_ms(&self, perf_now_ms: f64) -> f64 {
202 self.vclock.confidence(perf_now_ms / 1e3) * 1e3
203 }
204
205 pub fn offset_ms(&mut self, perf_now_ms: f64) -> f64 {
207 let mono_s = perf_now_ms / 1e3;
208 self.register
209 .regress(mono_s)
210 .map(|e| e.offset * 1e3)
211 .or_else(|| self.register.best().map(|b| b.offset * 1e3))
212 .unwrap_or(0.0)
213 }
214
215 pub fn is_synchronized(&self) -> bool {
216 self.vclock.is_synchronized()
217 }
218
219 pub fn accepted(&self) -> u32 {
220 self.accepted
221 }
222
223 pub fn rejected(&self) -> u32 {
224 self.rejected
225 }
226}
227
228#[cfg(test)]
229mod tests;