.github/workflows/build.yaml

+name: Build
+
+on: [push, pull_request]
+
+jobs:
+  check:
+    name: Type checking
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust: [1.21.0, stable]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v1
+        with:
+          fetch-depth: 1
+
+      - name: Install toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      # default features
+      - name: Run `cargo check`
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+
+      # everything
+      - name: Run `cargo check --all-features`
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all-features
+
+  test:
+    name: Test suite
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust: [1.21.0, stable]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v1
+        with:
+          fetch-depth: 1
+
+      - name: Install toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      # Generate Cargo.lock before attempting to downgrade
+      - name: Generate lock file
+        uses: actions-rs/cargo@v1
+        with:
+          command: generate-lockfile
+
+      # downgrade dev-dependencies for compatibility
+      - name: Downgrade dependencies
+        uses: actions-rs/cargo@v1
+        with:
+          command: update
+          args: -p cfg-if --precise 0.1.9
+        if: matrix.rust == '1.21.0'
+
+      # default features
+      - name: Run `cargo test`
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+
+      # everything
+      - name: Run `cargo test --all-features`
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features

.travis.yml

-language: rust
-sudo: false
-
-matrix:
-  include:
-    - rust: 1.21.0
-    - rust: stable
-    - os: osx
-    - rust: beta
-    - rust: nightly
-
-    - rust: nightly
-      before_script:
-        - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-      script:
-        - cargo doc --no-deps --all-features
-      after_success:
-        - travis-cargo --only nightly doc-upload
-
-script:
-  - cargo build
-  - cargo test
-  - cargo test --features rustc-serialize
-
-env:
-  global:
-    secure: "NlXnNaUBf2MgV2gPJyIQU+JM814e29itvvb8o5BvN4YB60rseu16yLbzKpO4FzuOFBc/Uc+1veDcKyzZYsdV6FIwQk4jfdUkNZ3i56InVCzXcaaHCe78cpg/IxK+/48fGy/EIJkWYdtQsoVCGunaf5NdF360Lzb6G/B1vheC34E="
-
-notifications:
-  email:
-    on_success: never

Cargo.toml

@@ -11,17 +11,10 @@ description = """
 Utilities for working with time-related functions in Rust.
 """
 
-[badges]
-travis-ci = { repository = "rust-lang-deprecated/time" }
-appveyor = { repository = "alexcrichton/time" }
-
 [dependencies]
 libc = "0.2.1"
 rustc-serialize = { version = "0.3", optional = true }
 
-[target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = "0.1"
-
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.0", features = ["std", "minwinbase", "minwindef", "ntdef", "profileapi", "sysinfoapi", "timezoneapi"] }
 

README.md

@@ -3,16 +3,16 @@ time
 
 Utilities for working with time-related functions in Rust
 
-[![Build Status](https://travis-ci.org/rust-lang-deprecated/time.svg?branch=master)](https://travis-ci.org/rust-lang-deprecated/time)
-[![Build status](https://ci.appveyor.com/api/projects/status/55m7rbaj9a5v3ad7?svg=true)](https://ci.appveyor.com/project/alexcrichton/time)
-
-[Documentation](https://doc.rust-lang.org/time)
+![build status](https://github.com/time-rs/time/workflows/Build/badge.svg?branch=v0.1)
+[Documentation](https://docs.rs/time/0.1)
+![rustc 1.21.0](https://img.shields.io/badge/rustc-1.21.0-blue)
 
 ## Notes
 
-This library is no longer actively maintained, but bugfixes will be added ([details](https://github.com/rust-lang-deprecated/time/issues/136)).
+Version 0.1 of this library is no longer actively maintained.
+A 0.2 version will be released in the future, which will contain a number of breaking changes.
 
-In case you're looking for something a little fresher and more actively maintained have a look at the [`chrono`](https://github.com/lifthrasiir/rust-chrono) crate.
+If you need additional functionality that this crate does not provide, check out the [`chrono`](https://github.com/chronotope/chrono) crate.
 
 ## Usage
 

appveyor.yml

-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-  - TARGET: i686-pc-windows-msvc
-  - TARGET: i686-pc-windows-gnu
-install:
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe"
-  - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
-  - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin
-  - SET PATH=%PATH%;C:\MinGW\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --verbose

src/display.rs

@@ -11,9 +11,9 @@ impl<'a> fmt::Display for TmFmt<'a> {
                     if ch == '%' {
                         // we've already validated that % always precedes
                         // another char
-                        try!(parse_type(fmt, chars.next().unwrap(), self.tm));
+                        parse_type(fmt, chars.next().unwrap(), self.tm)?;
                     } else {
-                        try!(fmt.write_char(ch));
+                        fmt.write_char(ch)?;
                     }
                 }
 
@@ -148,31 +148,31 @@ fn parse_type(fmt: &mut fmt::Formatter, ch: char, tm: &Tm) -> fmt::Result {
         }),
         'C' => write!(fmt, "{:02}", (tm.tm_year + 1900) / 100),
         'c' => {
-            try!(parse_type(fmt, 'a', tm));
-            try!(fmt.write_str(" "));
-            try!(parse_type(fmt, 'b', tm));
-            try!(fmt.write_str(" "));
-            try!(parse_type(fmt, 'e', tm));
-            try!(fmt.write_str(" "));
-            try!(parse_type(fmt, 'T', tm));
-            try!(fmt.write_str(" "));
+            parse_type(fmt, 'a', tm)?;
+            fmt.write_str(" ")?;
+            parse_type(fmt, 'b', tm)?;
+            fmt.write_str(" ")?;
+            parse_type(fmt, 'e', tm)?;
+            fmt.write_str(" ")?;
+            parse_type(fmt, 'T', tm)?;
+            fmt.write_str(" ")?;
             parse_type(fmt, 'Y', tm)
         }
         'D' | 'x' => {
-            try!(parse_type(fmt, 'm', tm));
-            try!(fmt.write_str("/"));
-            try!(parse_type(fmt, 'd', tm));
-            try!(fmt.write_str("/"));
+            parse_type(fmt, 'm', tm)?;
+            fmt.write_str("/")?;
+            parse_type(fmt, 'd', tm)?;
+            fmt.write_str("/")?;
             parse_type(fmt, 'y', tm)
         }
         'd' => write!(fmt, "{:02}", tm.tm_mday),
         'e' => write!(fmt, "{:2}", tm.tm_mday),
         'f' => write!(fmt, "{:09}", tm.tm_nsec),
         'F' => {
-            try!(parse_type(fmt, 'Y', tm));
-            try!(fmt.write_str("-"));
-            try!(parse_type(fmt, 'm', tm));
-            try!(fmt.write_str("-"));
+            parse_type(fmt, 'Y', tm)?;
+            fmt.write_str("-")?;
+            parse_type(fmt, 'm', tm)?;
+            fmt.write_str("-")?;
             parse_type(fmt, 'd', tm)
         }
         'G' => iso_week(fmt, 'G', tm),
@@ -198,26 +198,26 @@ fn parse_type(fmt: &mut fmt::Formatter, ch: char, tm: &Tm) -> fmt::Result {
         'P' => fmt.write_str(if tm.tm_hour < 12 { "am" } else { "pm" }),
         'p' => fmt.write_str(if (tm.tm_hour) < 12 { "AM" } else { "PM" }),
         'R' => {
-            try!(parse_type(fmt, 'H', tm));
-            try!(fmt.write_str(":"));
+            parse_type(fmt, 'H', tm)?;
+            fmt.write_str(":")?;
             parse_type(fmt, 'M', tm)
         }
         'r' => {
-            try!(parse_type(fmt, 'I', tm));
-            try!(fmt.write_str(":"));
-            try!(parse_type(fmt, 'M', tm));
-            try!(fmt.write_str(":"));
-            try!(parse_type(fmt, 'S', tm));
-            try!(fmt.write_str(" "));
+            parse_type(fmt, 'I', tm)?;
+            fmt.write_str(":")?;
+            parse_type(fmt, 'M', tm)?;
+            fmt.write_str(":")?;
+            parse_type(fmt, 'S', tm)?;
+            fmt.write_str(" ")?;
             parse_type(fmt, 'p', tm)
         }
         'S' => write!(fmt, "{:02}", tm.tm_sec),
         's' => write!(fmt, "{}", tm.to_timespec().sec),
         'T' | 'X' => {
-            try!(parse_type(fmt, 'H', tm));
-            try!(fmt.write_str(":"));
-            try!(parse_type(fmt, 'M', tm));
-            try!(fmt.write_str(":"));
+            parse_type(fmt, 'H', tm)?;
+            fmt.write_str(":")?;
+            parse_type(fmt, 'M', tm)?;
+            fmt.write_str(":")?;
             parse_type(fmt, 'S', tm)
         }
         't' => fmt.write_str("\t"),
@@ -228,10 +228,10 @@ fn parse_type(fmt: &mut fmt::Formatter, ch: char, tm: &Tm) -> fmt::Result {
         }
         'V' => iso_week(fmt, 'V', tm),
         'v' => {
-            try!(parse_type(fmt, 'e', tm));
-            try!(fmt.write_str("-"));
-            try!(parse_type(fmt, 'b', tm));
-            try!(fmt.write_str("-"));
+            parse_type(fmt, 'e', tm)?;
+            fmt.write_str("-")?;
+            parse_type(fmt, 'b', tm)?;
+            fmt.write_str("-")?;
             parse_type(fmt, 'Y', tm)
         }
         'W' => {

src/duration.rs

@@ -377,20 +377,20 @@ impl fmt::Display for Duration {
         let hasdate = days != 0;
         let hastime = (secs != 0 || abs.nanos != 0) || !hasdate;
 
-        try!(write!(f, "{}P", sign));
+        write!(f, "{}P", sign)?;
 
         if hasdate {
-            try!(write!(f, "{}D", days));
+            write!(f, "{}D", days)?;
         }
         if hastime {
             if abs.nanos == 0 {
-                try!(write!(f, "T{}S", secs));
+                write!(f, "T{}S", secs)?;
             } else if abs.nanos % NANOS_PER_MILLI == 0 {
-                try!(write!(f, "T{}.{:03}S", secs, abs.nanos / NANOS_PER_MILLI));
+                write!(f, "T{}.{:03}S", secs, abs.nanos / NANOS_PER_MILLI)?;
             } else if abs.nanos % NANOS_PER_MICRO == 0 {
-                try!(write!(f, "T{}.{:06}S", secs, abs.nanos / NANOS_PER_MICRO));
+                write!(f, "T{}.{:06}S", secs, abs.nanos / NANOS_PER_MICRO)?;
             } else {
-                try!(write!(f, "T{}.{:09}S", secs, abs.nanos));
+                write!(f, "T{}.{:09}S", secs, abs.nanos)?;
             }
         }
         Ok(())
@@ -407,6 +407,7 @@ impl fmt::Display for Duration {
 pub struct OutOfRangeError(());
 
 impl fmt::Display for OutOfRangeError {
+    #[allow(deprecated)]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.description())
     }

src/lib.rs

@@ -33,10 +33,11 @@
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "https://www.rust-lang.org/favicon.ico",
        html_root_url = "https://doc.rust-lang.org/time/")]
+#![allow(unknown_lints)]
+#![allow(ellipsis_inclusive_range_patterns)] // `..=` requires Rust 1.26
 #![allow(trivial_numeric_casts)]
 #![cfg_attr(test, deny(warnings))]
 
-#[cfg(target_os = "redox")] extern crate syscall;
 #[cfg(unix)] extern crate libc;
 #[cfg(windows)] extern crate winapi;
 #[cfg(feature = "rustc-serialize")] extern crate rustc_serialize;
@@ -551,6 +552,7 @@ pub enum ParseError {
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        #[allow(deprecated)]
         match *self {
             InvalidFormatSpecifier(ch) => {
                 write!(f, "{}: %{}", self.description(), ch)
@@ -652,7 +654,10 @@ mod tests {
     use super::ParseError::{InvalidTime, InvalidYear, MissingFormatConverter,
                             InvalidFormatSpecifier};
 
-    use std::sync::{Once, ONCE_INIT, Mutex, MutexGuard, LockResult};
+    #[allow(deprecated)] // `Once::new` is const starting in Rust 1.32
+    use std::sync::ONCE_INIT;
+    use std::sync::{Once, Mutex, MutexGuard, LockResult};
+    use std::i32;
     use std::mem;
 
     struct TzReset {
@@ -664,6 +669,7 @@ mod tests {
         // Lock manages current timezone because some tests require LA some
         // London
         static mut LOCK: *mut Mutex<()> = 0 as *mut _;
+        #[allow(deprecated)] // `Once::new` is const starting in Rust 1.32
         static INIT: Once = ONCE_INIT;
 
         unsafe {
@@ -694,8 +700,8 @@ mod tests {
 
     #[test]
     fn test_get_time() {
-        static SOME_RECENT_DATE: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
-        static SOME_FUTURE_DATE: i64 = 1577836800i64; // 2020-01-01T00:00:00Z
+        static SOME_RECENT_DATE: i64 = 1577836800i64; // 2020-01-01T00:00:00Z
+        static SOME_FUTURE_DATE: i64 = i32::MAX as i64; // Y2038
 
         let tv1 = get_time();
         debug!("tv1={} sec + {} nsec", tv1.sec, tv1.nsec);

src/parse.rs

@@ -20,10 +20,10 @@ pub fn strptime(mut s: &str, format: &str) -> Result<Tm, ParseError> {
     while let Some(ch) = chars.next() {
         if ch == '%' {
             if let Some(ch) = chars.next() {
-                try!(parse_type(&mut s, ch, &mut tm));
+                parse_type(&mut s, ch, &mut tm)?;
             }
         } else {
-            try!(parse_char(&mut s, ch));
+            parse_char(&mut s, ch)?;
         }
     }
 
@@ -326,6 +326,7 @@ fn match_digits_i64(ss: &mut &str, min_digits : usize, max_digits: usize, ws: bo
     let mut value : i64 = 0;
     let mut n = 0;
     if ws {
+        #[allow(deprecated)] // use `trim_start_matches` starting in 1.30
         let s2 = ss.trim_left_matches(" ");
         n = ss.len() - s2.len();
         if n > max_digits { return None }

src/sys.rs

@@ -4,7 +4,6 @@ pub use self::inner::*;
 
 #[cfg(any(
     all(target_arch = "wasm32", not(target_os = "emscripten")),
-    target_os = "redox",
     target_env = "sgx"
 ))]
 mod common {
@@ -134,143 +133,6 @@ mod inner {
     }
 }
 
-#[cfg(target_os = "redox")]
-mod inner {
-    use std::fmt;
-    use std::cmp::Ordering;
-    use std::ops::{Add, Sub};
-    use syscall;
-    use super::common::{time_to_tm, tm_to_time};
-
-    use Duration;
-    use Tm;
-
-    pub fn time_to_utc_tm(sec: i64, tm: &mut Tm) {
-        time_to_tm(sec, tm);
-    }
-
-    pub fn time_to_local_tm(sec: i64, tm: &mut Tm) {
-        // FIXME: Add timezone logic
-        time_to_tm(sec, tm);
-    }
-
-    pub fn utc_tm_to_time(tm: &Tm) -> i64 {
-        tm_to_time(tm)
-    }
-
-    pub fn local_tm_to_time(tm: &Tm) -> i64 {
-        // FIXME: Add timezone logic
-        tm_to_time(tm)
-    }
-
-    pub fn get_time() -> (i64, i32) {
-        let mut tv = syscall::TimeSpec { tv_sec: 0, tv_nsec: 0 };
-        syscall::clock_gettime(syscall::CLOCK_REALTIME, &mut tv).unwrap();
-        (tv.tv_sec as i64, tv.tv_nsec as i32)
-    }
-
-    pub fn get_precise_ns() -> u64 {
-        let mut ts = syscall::TimeSpec { tv_sec: 0, tv_nsec: 0 };
-        syscall::clock_gettime(syscall::CLOCK_MONOTONIC, &mut ts).unwrap();
-        (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64)
-    }
-
-    #[derive(Copy)]
-    pub struct SteadyTime {
-        t: syscall::TimeSpec,
-    }
-
-    impl fmt::Debug for SteadyTime {
-        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-            write!(fmt, "SteadyTime {{ tv_sec: {:?}, tv_nsec: {:?} }}",
-                   self.t.tv_sec, self.t.tv_nsec)
-        }
-    }
-
-    impl Clone for SteadyTime {
-        fn clone(&self) -> SteadyTime {
-            SteadyTime { t: self.t }
-        }
-    }
-
-    impl SteadyTime {
-        pub fn now() -> SteadyTime {
-            let mut t = SteadyTime {
-                t: syscall::TimeSpec {
-                    tv_sec: 0,
-                    tv_nsec: 0,
-                }
-            };
-            syscall::clock_gettime(syscall::CLOCK_MONOTONIC, &mut t.t).unwrap();
-            t
-        }
-    }
-
-    impl Sub for SteadyTime {
-        type Output = Duration;
-        fn sub(self, other: SteadyTime) -> Duration {
-            if self.t.tv_nsec >= other.t.tv_nsec {
-                Duration::seconds(self.t.tv_sec as i64 - other.t.tv_sec as i64) +
-                    Duration::nanoseconds(self.t.tv_nsec as i64 - other.t.tv_nsec as i64)
-            } else {
-                Duration::seconds(self.t.tv_sec as i64 - 1 - other.t.tv_sec as i64) +
-                    Duration::nanoseconds(self.t.tv_nsec as i64 + ::NSEC_PER_SEC as i64 -
-                                          other.t.tv_nsec as i64)
-            }
-        }
-    }
-
-    impl Sub<Duration> for SteadyTime {
-        type Output = SteadyTime;
-        fn sub(self, other: Duration) -> SteadyTime {
-            self + -other
-        }
-    }
-
-    impl Add<Duration> for SteadyTime {
-        type Output = SteadyTime;
-        fn add(mut self, other: Duration) -> SteadyTime {
-            let seconds = other.num_seconds();
-            let nanoseconds = other - Duration::seconds(seconds);
-            let nanoseconds = nanoseconds.num_nanoseconds().unwrap();
-            self.t.tv_sec += seconds;
-            self.t.tv_nsec += nanoseconds as i32;
-            if self.t.tv_nsec >= ::NSEC_PER_SEC {
-                self.t.tv_nsec -= ::NSEC_PER_SEC;
-                self.t.tv_sec += 1;
-            } else if self.t.tv_nsec < 0 {
-                self.t.tv_sec -= 1;
-                self.t.tv_nsec += ::NSEC_PER_SEC;
-            }
-            self
-        }
-    }
-
-    impl PartialOrd for SteadyTime {
-        fn partial_cmp(&self, other: &SteadyTime) -> Option<Ordering> {
-            Some(self.cmp(other))
-        }
-    }
-
-    impl Ord for SteadyTime {
-        fn cmp(&self, other: &SteadyTime) -> Ordering {
-            match self.t.tv_sec.cmp(&other.t.tv_sec) {
-                Ordering::Equal => self.t.tv_nsec.cmp(&other.t.tv_nsec),
-                ord => ord
-            }
-        }
-    }
-
-    impl PartialEq for SteadyTime {
-        fn eq(&self, other: &SteadyTime) -> bool {
-            self.t.tv_sec == other.t.tv_sec &&
-                self.t.tv_nsec == other.t.tv_nsec
-        }
-    }
-
-    impl Eq for SteadyTime {}
-}
-
 #[cfg(target_env = "sgx")]
 mod inner {
     use std::ops::{Add, Sub};
@@ -471,11 +333,14 @@ mod inner {
 
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     mod mac {
+        #[allow(deprecated)]
         use libc::{self, timeval, mach_timebase_info};
+        #[allow(deprecated)]
         use std::sync::{Once, ONCE_INIT};
         use std::ops::{Add, Sub};
         use Duration;
 
+        #[allow(deprecated)]
         fn info() -> &'static mach_timebase_info {
             static mut INFO: mach_timebase_info = mach_timebase_info {
                 numer: 0,
@@ -498,6 +363,7 @@ mod inner {
             (tv.tv_sec as i64, tv.tv_usec * 1000)
         }
 
+        #[allow(deprecated)]
         #[inline]
         pub fn get_precise_ns() -> u64 {
             unsafe {
@@ -692,6 +558,7 @@ mod inner {
 mod inner {
     use std::io;
     use std::mem;
+    #[allow(deprecated)]
     use std::sync::{Once, ONCE_INIT};
     use std::ops::{Add, Sub};
     use {Tm, Duration};
@@ -705,6 +572,7 @@ mod inner {
 
     fn frequency() -> i64 {
         static mut FREQUENCY: i64 = 0;
+        #[allow(deprecated)]
         static ONCE: Once = ONCE_INIT;
 
         unsafe {
@@ -980,10 +848,10 @@ mod inner {
     // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724944%28v=vs.85%29.aspx
     #[cfg(test)]
     fn acquire_privileges() {
-        use std::sync::{ONCE_INIT, Once};
         use winapi::um::processthreadsapi::*;
         use winapi::um::winbase::LookupPrivilegeValueA;
         const SE_PRIVILEGE_ENABLED: DWORD = 2;
+        #[allow(deprecated)]
         static INIT: Once = ONCE_INIT;
 
         // TODO: FIXME
@@ -994,26 +862,20 @@ mod inner {
             ) -> BOOL;
         }
 
-        #[repr(C)]
-        struct TKP {
-            tkp: TOKEN_PRIVILEGES,
-            laa: LUID_AND_ATTRIBUTES,
-        }
-
         INIT.call_once(|| unsafe {
             let mut hToken = 0 as *mut _;
             call!(OpenProcessToken(GetCurrentProcess(),
                                    TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                                    &mut hToken));
 
-            let mut tkp = mem::zeroed::<TKP>();
-            assert_eq!(tkp.tkp.Privileges.len(), 0);
+            let mut tkp = mem::zeroed::<TOKEN_PRIVILEGES>();
+            assert_eq!(tkp.Privileges.len(), 1);
             let c = ::std::ffi::CString::new("SeTimeZonePrivilege").unwrap();
             call!(LookupPrivilegeValueA(0 as *const _, c.as_ptr(),
-                                        &mut tkp.laa.Luid));
-            tkp.tkp.PrivilegeCount = 1;
-            tkp.laa.Attributes = SE_PRIVILEGE_ENABLED;
-            call!(AdjustTokenPrivileges(hToken, FALSE, &mut tkp.tkp, 0,
+                                        &mut tkp.Privileges[0].Luid));
+            tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+            tkp.PrivilegeCount = 1;
+            call!(AdjustTokenPrivileges(hToken, FALSE, &mut tkp, 0,
                                         0 as *mut _, 0 as *mut _));
         });
     }