use crate::{ClockDrive, ClockError, ClockRead};
use rusty_time_core::ClockCommand;
use windows_sys::Win32::Foundation::{FILETIME, SYSTEMTIME};
use windows_sys::Win32::System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency};
use windows_sys::Win32::System::SystemInformation::SetSystemTime;
use windows_sys::Win32::System::SystemInformation::{
GetSystemTimeAdjustmentPrecise, GetSystemTimePreciseAsFileTime, SetSystemTimeAdjustmentPrecise,
};
use windows_sys::Win32::System::Time::FileTimeToSystemTime;
const EPOCH_DIFF_100NS: i128 = 116_444_736_000_000_000;
const MAX_SLEW_PPM: f64 = 100_000.0;
pub struct SystemClock;
pub fn has_system_time_privilege() -> bool {
use windows_sys::Win32::Foundation::{CloseHandle, HANDLE, LUID};
use windows_sys::Win32::Security::{
LUID_AND_ATTRIBUTES, LookupPrivilegeValueW, PRIVILEGE_SET, PrivilegeCheck,
SE_PRIVILEGE_ENABLED, TOKEN_QUERY,
};
use windows_sys::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};
let name: Vec<u16> = "SeSystemtimePrivilege"
.encode_utf16()
.chain(core::iter::once(0))
.collect();
let mut luid = LUID {
LowPart: 0,
HighPart: 0,
};
if unsafe { LookupPrivilegeValueW(core::ptr::null(), name.as_ptr(), &mut luid) } == 0 {
return false;
}
let mut token: HANDLE = core::ptr::null_mut();
if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) } == 0 {
return false;
}
let mut set = PRIVILEGE_SET {
PrivilegeCount: 1,
Control: 1, Privilege: [LUID_AND_ATTRIBUTES {
Luid: luid,
Attributes: SE_PRIVILEGE_ENABLED,
}],
};
let mut result: i32 = 0;
let ok = unsafe { PrivilegeCheck(token, &mut set, &mut result) } != 0;
unsafe { CloseHandle(token) };
ok && result != 0
}
pub(crate) fn platform_capabilities() -> crate::ClockCapabilities {
let resolution = system_time_adjustment()
.ok()
.map(|(_, increment, _)| 1e6 / increment as f64);
crate::ClockCapabilities {
os: "windows",
arch: std::env::consts::ARCH,
can_read: true,
can_discipline: has_system_time_privilege(),
discipline_requirement: "SeSystemtimePrivilege (run elevated or as a service), \
and the Windows Time service must not be disciplining too",
slew_resolution_ppm: resolution,
max_slew_ppm: MAX_SLEW_PPM,
batch_receive: false,
mono_resolution_ns: None,
}
}
fn system_time_adjustment() -> Result<(u64, u64, bool), ClockError> {
let mut adjustment = 0u64;
let mut increment = 0u64;
let mut disabled = 0i32;
if unsafe { GetSystemTimeAdjustmentPrecise(&mut adjustment, &mut increment, &mut disabled) }
== 0
{
return Err(last_error("GetSystemTimeAdjustmentPrecise"));
}
Ok((adjustment, increment, disabled != 0))
}
fn last_error(op: &'static str) -> ClockError {
ClockError {
op,
detail: std::io::Error::last_os_error().to_string(),
}
}
impl ClockRead for SystemClock {
fn wall_ns(&self) -> Result<i128, ClockError> {
let mut ft = FILETIME {
dwLowDateTime: 0,
dwHighDateTime: 0,
};
unsafe { GetSystemTimePreciseAsFileTime(&mut ft) };
let ticks = ((ft.dwHighDateTime as i128) << 32) | ft.dwLowDateTime as i128;
Ok((ticks - EPOCH_DIFF_100NS) * 100)
}
fn mono_s(&self) -> Result<f64, ClockError> {
let mut count = 0i64;
let mut freq = 0i64;
let ok1 = unsafe { QueryPerformanceCounter(&mut count) };
let ok2 = unsafe { QueryPerformanceFrequency(&mut freq) };
if ok1 == 0 || ok2 == 0 || freq == 0 {
return Err(last_error("QueryPerformanceCounter"));
}
Ok(count as f64 / freq as f64)
}
}
impl ClockDrive for SystemClock {
fn apply(&mut self, cmd: &ClockCommand) -> Result<(), ClockError> {
match *cmd {
ClockCommand::Step { add_seconds } => {
let target_ns = self.wall_ns()? + (add_seconds * 1e9) as i128;
let ticks = target_ns / 100 + EPOCH_DIFF_100NS;
let ft = FILETIME {
dwLowDateTime: ticks as u32,
dwHighDateTime: (ticks >> 32) as u32,
};
let mut st = SYSTEMTIME {
wYear: 0,
wMonth: 0,
wDayOfWeek: 0,
wDay: 0,
wHour: 0,
wMinute: 0,
wSecond: 0,
wMilliseconds: 0,
};
if unsafe { FileTimeToSystemTime(&ft, &mut st) } == 0 {
return Err(last_error("FileTimeToSystemTime"));
}
if unsafe { SetSystemTime(&st) } == 0 {
return Err(last_error("SetSystemTime"));
}
Ok(())
}
ClockCommand::Slew {
freq_ppm,
drain_offset,
drain_rate_ppm,
} => {
let (_, increment, _) = system_time_adjustment()?;
let total_ppm =
crate::slew::total_ppm(freq_ppm, drain_offset, drain_rate_ppm, MAX_SLEW_PPM);
let new_adjustment = crate::slew::windows_adjustment(increment, total_ppm);
if unsafe { SetSystemTimeAdjustmentPrecise(new_adjustment, 0) } == 0 {
return Err(last_error("SetSystemTimeAdjustmentPrecise"));
}
Ok(())
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn privilege_probe_does_not_disturb_the_clock() {
let clock = SystemClock;
let before = clock.wall_ns().expect("wall");
let privileged = has_system_time_privilege();
let after = clock.wall_ns().expect("wall");
let elapsed_ms = (after - before) as f64 / 1e6;
assert!(
(0.0..500.0).contains(&elapsed_ms),
"probe moved the clock by {elapsed_ms} ms"
);
assert_eq!(platform_capabilities().can_discipline, privileged);
}
#[test]
fn reads_work_without_privilege() {
let c = SystemClock;
let w = c.wall_ns().expect("wall");
assert!(w > 1_577_836_800_000_000_000 && w < 4_102_444_800_000_000_000i128);
let m1 = c.mono_s().expect("mono");
let m2 = c.mono_s().expect("mono");
assert!(m2 >= m1);
}
}