Replace system::time::Duration

Author: joriskleiber

src/pam/converse.rs

@@ -1,7 +1,6 @@
-use std::io;
+use std::{io, time::Duration};
 
 use crate::cutils::string_from_ptr;
-use crate::system::time::Duration;
 
 use super::sys::*;
 

src/pam/mod.rs

@@ -4,10 +4,9 @@ use std::{
     os::raw::c_char,
     os::unix::prelude::OsStrExt,
     ptr::NonNull,
+    time::Duration,
 };
 
-use crate::system::time::Duration;
-
 use converse::ConverserData;
 use error::pam_err;
 pub use error::{PamError, PamErrorType, PamResult};

src/pam/rpassword.rs

@@ -15,13 +15,12 @@
 ///
 use std::io::{self, Error, ErrorKind, Read};
 use std::os::fd::{AsFd, AsRawFd, BorrowedFd};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 use std::{fs, mem};
 
 use libc::{tcsetattr, termios, ECHO, ECHONL, ICANON, TCSANOW, VEOF, VERASE, VKILL};
 
 use crate::cutils::cerr;
-use crate::system::time::Duration;
 
 use super::securemem::PamBuffer;
 
@@ -187,7 +186,7 @@ struct TimeoutRead<'a> {
 impl<'a> TimeoutRead<'a> {
     fn new(fd: BorrowedFd<'a>, timeout: Option<Duration>) -> TimeoutRead<'a> {
         TimeoutRead {
-            timeout_at: timeout.map(|timeout| Instant::now() + timeout.into()),
+            timeout_at: timeout.map(|timeout| Instant::now() + timeout),
             fd,
         }
     }

src/sudo/mod.rs

@@ -6,12 +6,12 @@ use crate::log::dev_info;
 use crate::system::interface::UserId;
 use crate::system::timestamp::RecordScope;
 use crate::system::User;
-use crate::system::{time::Duration, timestamp::SessionRecordFile, Process};
+use crate::system::{timestamp::SessionRecordFile, Process};
 #[cfg(test)]
 pub(crate) use cli::SudoAction;
 #[cfg(not(test))]
 use cli::SudoAction;
-use std::path::PathBuf;
+use std::{path::PathBuf, time::Duration};
 
 mod cli;
 pub(crate) use cli::{SudoEditOptions, SudoListOptions, SudoRunOptions, SudoValidateOptions};
@@ -91,16 +91,15 @@ fn sudo_process() -> Result<(), Error> {
             }
             SudoAction::RemoveTimestamp(_) => {
                 let user = CurrentUser::resolve()?;
-                let mut record_file =
-                    SessionRecordFile::open_for_user(&user, Duration::seconds(0))?;
+                let mut record_file = SessionRecordFile::open_for_user(&user, Duration::default())?;
                 record_file.reset()?;
                 Ok(())
             }
             SudoAction::ResetTimestamp(_) => {
                 if let Some(scope) = RecordScope::for_process(&Process::new()) {
                     let user = CurrentUser::resolve()?;
                     let mut record_file =
-                        SessionRecordFile::open_for_user(&user, Duration::seconds(0))?;
+                        SessionRecordFile::open_for_user(&user, Duration::default())?;
                     record_file.disable(scope, None)?;
                 }
                 Ok(())

src/sudo/pam.rs

@@ -1,10 +1,10 @@
-use std::ffi::OsString;
+use std::{ffi::OsString, time::Duration};
 
 use crate::common::context::LaunchType;
 use crate::common::error::Error;
 use crate::log::{dev_info, user_warn};
 use crate::pam::{PamContext, PamError, PamErrorType, PamResult};
-use crate::system::{term::current_tty_name, time::Duration};
+use crate::system::term::current_tty_name;
 
 pub(super) struct InitPamArgs<'a> {
     pub(super) launch: LaunchType,

src/sudo/pipeline.rs

@@ -1,5 +1,6 @@
 use std::ffi::OsStr;
 use std::process::exit;
+use std::time::Duration;
 
 use super::cli::{SudoRunOptions, SudoValidateOptions};
 use super::diagnostic;
@@ -10,7 +11,6 @@ use crate::log::{auth_info, auth_warn};
 use crate::pam::PamContext;
 use crate::sudo::env::environment;
 use crate::sudo::pam::{attempt_authenticate, init_pam, pre_exec, InitPamArgs};
-use crate::sudo::Duration;
 use crate::sudoers::{
     AuthenticatingUser, Authentication, Authorization, DirChange, Judgement, Restrictions, Sudoers,
 };

src/sudoers/policy.rs

@@ -6,13 +6,13 @@ use crate::common::{
 };
 use crate::exec::Umask;
 use crate::sudoers::ast::{ExecControl, Tag};
-use crate::system::{time::Duration, Hostname, User};
+use crate::system::{Hostname, User};
 /// Data types and traits that represent what the "terms and conditions" are after a successful
 /// permission check.
 ///
 /// The trait definitions can be part of some global crate in the future, if we support more
 /// than just the sudoers file.
-use std::collections::HashSet;
+use std::{collections::HashSet, time::Duration};
 
 #[must_use]
 #[cfg_attr(test, derive(Debug, PartialEq))]
@@ -35,14 +35,25 @@ pub struct Authentication {
 
 impl super::Settings {
     pub(super) fn to_auth(&self, tag: &Tag) -> Authentication {
+        let default_passwd_timeout = |_| -> u64 {
+            super::Settings::default()
+                .passwd_timeout()
+                .try_into()
+                .unwrap()
+        };
+
         Authentication {
             must_authenticate: tag.needs_passwd(),
             allowed_attempts: self.passwd_tries().try_into().unwrap(),
-            prior_validity: Duration::seconds(self.timestamp_timeout()),
+            prior_validity: Duration::from_secs(self.timestamp_timeout().try_into().unwrap()),
             pwfeedback: self.pwfeedback(),
-            password_timeout: match self.passwd_timeout() {
+            password_timeout: match self
+                .passwd_timeout()
+                .try_into()
+                .unwrap_or_else(default_passwd_timeout)
+            {
                 0 => None,
-                timeout => Some(Duration::seconds(timeout)),
+                timeout => Some(Duration::from_secs(timeout)),
             },
             credential: if self.rootpw() {
                 AuthenticatingUser::Root
@@ -190,10 +201,10 @@ mod test {
             Authentication {
                 must_authenticate: true,
                 allowed_attempts: 3,
-                prior_validity: Duration::minutes(15),
+                prior_validity: Duration::from_secs(15 * 60),
                 credential: AuthenticatingUser::InvokingUser,
                 pwfeedback: false,
-                password_timeout: Some(Duration::seconds(300)),
+                password_timeout: Some(Duration::from_secs(300)),
             },
         );
 
@@ -207,10 +218,10 @@ mod test {
             Authentication {
                 must_authenticate: false,
                 allowed_attempts: 3,
-                prior_validity: Duration::minutes(15),
+                prior_validity: Duration::from_secs(15 * 60),
                 credential: AuthenticatingUser::InvokingUser,
                 pwfeedback: false,
-                password_timeout: Some(Duration::seconds(300)),
+                password_timeout: Some(Duration::from_secs(300)),
             },
         );
         assert_eq!(restrictions, restrictions2);

src/system/time.rs

@@ -2,6 +2,7 @@ use std::{
     io::{Read, Write},
     mem::MaybeUninit,
     ops::{Add, Sub},
+    time::Duration,
 };
 
 /// A timestamp relative to `CLOCK_BOOTTIME`.
@@ -51,85 +52,47 @@ impl SystemTime {
             i64::from_ne_bytes(nsec_bytes),
         ))
     }
-}
-
-impl Sub<SystemTime> for SystemTime {
-    type Output = Duration;
-
-    fn sub(self, rhs: SystemTime) -> Self::Output {
-        Duration::new(self.secs - rhs.secs, self.nsecs - rhs.nsecs)
-    }
-}
-
-impl Add<Duration> for SystemTime {
-    type Output = SystemTime;
-
-    fn add(self, rhs: Duration) -> Self::Output {
-        SystemTime::new(self.secs + rhs.secs, self.nsecs + rhs.nsecs)
-    }
-}
-
-impl Sub<Duration> for SystemTime {
-    type Output = SystemTime;
 
-    fn sub(self, rhs: Duration) -> Self::Output {
-        SystemTime::new(self.secs - rhs.secs, self.nsecs - rhs.nsecs)
-    }
-}
+    #[inline]
+    pub fn checked_add(self, rhs: Duration) -> Option<SystemTime> {
+        let rhs_secs = rhs.as_nanos().div_euclid(1_000_000_000).try_into().ok()?;
+        let rhs_nsecs = rhs.as_nanos().rem_euclid(1_000_000_000).try_into().ok()?;
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
-pub struct Duration {
-    secs: i64,
-    nsecs: i64,
-}
+        let secs = self.secs.checked_add(rhs_secs)?;
+        let nsecs = self.nsecs.checked_add(rhs_nsecs)?;
 
-impl Duration {
-    pub fn new(secs: i64, nsecs: i64) -> Duration {
-        Duration {
-            secs: secs + nsecs.div_euclid(1_000_000_000),
-            nsecs: nsecs.rem_euclid(1_000_000_000),
-        }
+        Some(SystemTime::new(secs, nsecs))
     }
 
-    pub fn seconds(secs: i64) -> Duration {
-        Duration::new(secs, 0)
-    }
+    #[inline]
+    pub fn checked_sub(self, rhs: Duration) -> Option<SystemTime> {
+        let rhs_secs = rhs.as_nanos().div_euclid(1_000_000_000).try_into().ok()?;
+        let rhs_nsecs = rhs.as_nanos().rem_euclid(1_000_000_000).try_into().ok()?;
 
-    #[cfg(test)]
-    pub fn minutes(minutes: i64) -> Duration {
-        Duration::seconds(minutes * 60)
-    }
+        let secs = self.secs.checked_sub(rhs_secs)?;
+        let nsecs = self.nsecs.checked_sub(rhs_nsecs)?;
 
-    #[cfg(test)]
-    pub fn milliseconds(ms: i64) -> Duration {
-        let secs = ms / 1000;
-        let ms = ms % 1000;
-        Duration::new(secs, ms * 1_000_000)
+        Some(SystemTime::new(secs, nsecs))
     }
 }
 
-impl Add<Duration> for Duration {
-    type Output = Duration;
+impl Add<Duration> for SystemTime {
+    type Output = SystemTime;
 
+    #[inline]
     fn add(self, rhs: Duration) -> Self::Output {
-        Duration::new(self.secs + rhs.secs, self.nsecs + rhs.nsecs)
+        self.checked_add(rhs)
+            .expect("overflow when adding duration")
     }
 }
 
-impl Sub<Duration> for Duration {
-    type Output = Duration;
+impl Sub<Duration> for SystemTime {
+    type Output = SystemTime;
 
+    #[inline]
     fn sub(self, rhs: Duration) -> Self::Output {
-        Duration::new(self.secs - rhs.secs, self.nsecs - rhs.nsecs)
-    }
-}
-
-impl From<Duration> for std::time::Duration {
-    fn from(dur: Duration) -> std::time::Duration {
-        std::time::Duration::new(
-            dur.secs.try_into().unwrap_or(0),
-            dur.nsecs.try_into().unwrap_or(0),
-        )
+        self.checked_sub(rhs)
+            .expect("overflow when subtracting duration")
     }
 }
 
@@ -213,13 +176,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_new_durations_and_times() {
-        assert_eq!(Duration::new(1, 1_000_000_000), Duration::seconds(2));
-        assert_eq!(
-            Duration::new(-2, 500_000_000),
-            Duration::seconds(-1) + Duration::milliseconds(-500)
-        );
-
+    fn test_new_system_time() {
         assert_eq!(SystemTime::new(-1, 2_000_000_000), SystemTime::new(1, 0));
         assert_eq!(
             SystemTime::new(2, -500_000_000),
@@ -230,37 +187,20 @@ mod tests {
     #[test]
     fn test_time_ops() {
         assert_eq!(
-            Duration::seconds(2) + Duration::seconds(3),
-            Duration::seconds(5)
-        );
-        assert_eq!(
-            Duration::seconds(3) - Duration::seconds(1),
-            Duration::seconds(2)
-        );
-        assert_eq!(
-            Duration::seconds(-10) + Duration::seconds(-5),
-            Duration::seconds(-15)
-        );
-        assert_eq!(
-            Duration::milliseconds(5555) + Duration::milliseconds(5555),
-            Duration::seconds(11) + Duration::milliseconds(110)
-        );
-        assert_eq!(
-            Duration::milliseconds(-5555) + Duration::milliseconds(-1111),
-            Duration::milliseconds(-6666)
-        );
-        assert_eq!(
-            Duration::seconds(10) - Duration::seconds(-5),
-            Duration::seconds(15)
+            SystemTime::new(0, 0) + Duration::from_secs(3),
+            SystemTime::new(3, 0)
         );
-
         assert_eq!(
-            SystemTime::new(0, 0) + Duration::seconds(3),
+            SystemTime::new(0, 500_000_000) + Duration::from_nanos(2_500_000_000),
             SystemTime::new(3, 0)
         );
         assert_eq!(
-            SystemTime::new(10, 0) - Duration::seconds(4),
+            SystemTime::new(10, 0) - Duration::from_secs(4),
             SystemTime::new(6, 0)
         );
+        assert_eq!(
+            SystemTime::new(10, 0) - Duration::from_nanos(3_500_000_000),
+            SystemTime::new(6, 500_000_000)
+        );
     }
 }