migrate to winapi 0.3

Author: steffengy

Cargo.toml

@@ -57,12 +57,9 @@ url = "1.1.0"
 wait-timeout = "0.1.5"
 
 [target."cfg(windows)".dependencies]
-winapi = "0.2.8"
+winapi = { version = "0.3", features = ["jobapi", "jobapi2", "processthreadsapi", "psapi", "synchapi", "winuser"] }
 winreg = "0.4.0"
-user32-sys = "0.2.0"
-kernel32-sys = "0.2.1"
 gcc = "0.3.50"
-psapi-sys = "0.1"
 
 [dev-dependencies]
 rustup-mock = { path = "src/rustup-mock", version = "1.1.0" }

src/rustup-cli/job.rs

@@ -34,21 +34,21 @@ mod imp {
 
 #[cfg(windows)]
 mod imp {
-    extern crate kernel32;
     extern crate winapi;
-    extern crate psapi;
 
     use std::ffi::OsString;
     use std::io;
     use std::mem;
     use std::os::windows::prelude::*;
+    use winapi::shared::*;
+    use winapi::um::*;
 
     pub struct Setup {
         job: Handle,
     }
 
     pub struct Handle {
-        inner: winapi::HANDLE,
+        inner: ntdef::HANDLE,
     }
 
     fn last_err() -> io::Error {
@@ -65,7 +65,7 @@ mod imp {
         // use job objects, so we instead just ignore errors and assume that
         // we're otherwise part of someone else's job object in this case.
 
-        let job = kernel32::CreateJobObjectW(0 as *mut _, 0 as *const _);
+        let job = jobapi2::CreateJobObjectW(0 as *mut _, 0 as *const _);
         if job.is_null() {
             return None
         }
@@ -75,22 +75,22 @@ mod imp {
         // process in the object should be killed. Note that this includes our
         // entire process tree by default because we've added ourselves and and
         // our children will reside in the job once we spawn a process.
-        let mut info: winapi::JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
+        let mut info: winnt::JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
         info = mem::zeroed();
         info.BasicLimitInformation.LimitFlags =
-            winapi::JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
-        let r = kernel32::SetInformationJobObject(job.inner,
-                        winapi::JobObjectExtendedLimitInformation,
-                        &mut info as *mut _ as winapi::LPVOID,
-                        mem::size_of_val(&info) as winapi::DWORD);
+            winnt::JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        let r = jobapi2::SetInformationJobObject(job.inner,
+                        winnt::JobObjectExtendedLimitInformation,
+                        &mut info as *mut _ as minwindef::LPVOID,
+                        mem::size_of_val(&info) as minwindef::DWORD);
         if r == 0 {
             return None
         }
 
         // Assign our process to this job object, meaning that our children will
         // now live or die based on our existence.
-        let me = kernel32::GetCurrentProcess();
-        let r = kernel32::AssignProcessToJobObject(job.inner, me);
+        let me = processthreadsapi::GetCurrentProcess();
+        let r = jobapi2::AssignProcessToJobObject(job.inner, me);
         if r == 0 {
             return None
         }
@@ -118,13 +118,13 @@ mod imp {
                     info!("killed some, going for more");
                 }
 
-                let mut info: winapi::JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
+                let mut info: winnt::JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
                 info = mem::zeroed();
-                let r = kernel32::SetInformationJobObject(
+                let r = jobapi2::SetInformationJobObject(
                             self.job.inner,
-                            winapi::JobObjectExtendedLimitInformation,
-                            &mut info as *mut _ as winapi::LPVOID,
-                            mem::size_of_val(&info) as winapi::DWORD);
+                            winnt::JobObjectExtendedLimitInformation,
+                            &mut info as *mut _ as minwindef::LPVOID,
+                            mem::size_of_val(&info) as minwindef::DWORD);
                 if r == 0 {
                     info!("failed to configure job object to defaults: {}",
                           last_err());
@@ -137,16 +137,16 @@ mod imp {
         unsafe fn kill_remaining(&mut self) -> bool {
             #[repr(C)]
             struct Jobs {
-                header: winapi::JOBOBJECT_BASIC_PROCESS_ID_LIST,
-                list: [winapi::ULONG_PTR; 1024],
+                header: winnt::JOBOBJECT_BASIC_PROCESS_ID_LIST,
+                list: [basetsd::ULONG_PTR; 1024],
             }
 
             let mut jobs: Jobs = mem::zeroed();
-            let r = kernel32::QueryInformationJobObject(
+            let r = jobapi2::QueryInformationJobObject(
                             self.job.inner,
-                            winapi::JobObjectBasicProcessIdList,
-                            &mut jobs as *mut _ as winapi::LPVOID,
-                            mem::size_of_val(&jobs) as winapi::DWORD,
+                            winnt::JobObjectBasicProcessIdList,
+                            &mut jobs as *mut _ as minwindef::LPVOID,
+                            mem::size_of_val(&jobs) as minwindef::DWORD,
                             0 as *mut _);
             if r == 0 {
                 info!("failed to query job object: {}", last_err());
@@ -159,17 +159,17 @@ mod imp {
 
             let list = list.iter().filter(|&&id| {
                 // let's not kill ourselves
-                id as winapi::DWORD != kernel32::GetCurrentProcessId()
+                id as minwindef::DWORD != processthreadsapi::GetCurrentProcessId()
             }).filter_map(|&id| {
                 // Open the process with the necessary rights, and if this
                 // fails then we probably raced with the process exiting so we
                 // ignore the problem.
-                let flags = winapi::PROCESS_QUERY_INFORMATION |
-                            winapi::PROCESS_TERMINATE |
-                            winapi::SYNCHRONIZE;
-                let p = kernel32::OpenProcess(flags,
-                                              winapi::FALSE,
-                                              id as winapi::DWORD);
+                let flags = winnt::PROCESS_QUERY_INFORMATION |
+                            winnt::PROCESS_TERMINATE |
+                            winnt::SYNCHRONIZE;
+                let p = processthreadsapi::OpenProcess(flags,
+                                                       minwindef::FALSE,
+                                                       id as minwindef::DWORD);
                 if p.is_null() {
                     None
                 } else {
@@ -180,12 +180,12 @@ mod imp {
                 // If it's not then we likely raced with something else
                 // recycling this PID, so we just skip this step.
                 let mut res = 0;
-                let r = kernel32::IsProcessInJob(p.inner, self.job.inner, &mut res);
+                let r = jobapi::IsProcessInJob(p.inner, self.job.inner, &mut res);
                 if r == 0 {
                     info!("failed to test is process in job: {}", last_err());
                     return false
                 }
-                res == winapi::TRUE
+                res == minwindef::TRUE
             });
 
 
@@ -195,7 +195,7 @@ mod imp {
                 let mut buf = [0; 1024];
                 let r = psapi::GetProcessImageFileNameW(p.inner,
                                                         buf.as_mut_ptr(),
-                                                        buf.len() as winapi::DWORD);
+                                                        buf.len() as minwindef::DWORD);
                 if r == 0 {
                     info!("failed to get image name: {}", last_err());
                     continue
@@ -224,14 +224,14 @@ mod imp {
                 // Ok, this isn't mspdbsrv, let's kill the process. After we
                 // kill it we wait on it to ensure that the next time around in
                 // this function we're not going to see it again.
-                let r = kernel32::TerminateProcess(p.inner, 1);
+                let r = processthreadsapi::TerminateProcess(p.inner, 1);
                 if r == 0 {
                     info!("\tfailed to kill subprocess: {}", last_err());
                     info!("\tassuming subprocess is dead...");
                 } else {
                     info!("\tterminated subprocess");
                 }
-                let r = kernel32::WaitForSingleObject(p.inner, winapi::INFINITE);
+                let r = synchapi::WaitForSingleObject(p.inner, winbase::INFINITE);
                 if r != 0 {
                     info!("failed to wait for process to die: {}", last_err());
                     return false
@@ -245,7 +245,7 @@ mod imp {
 
     impl Drop for Handle {
         fn drop(&mut self) {
-            unsafe { kernel32::CloseHandle(self.inner); }
+            unsafe { handleapi::CloseHandle(self.inner); }
         }
     }
 }

src/rustup-cli/main.rs

@@ -40,10 +40,6 @@ extern crate gcc;
 extern crate winapi;
 #[cfg(windows)]
 extern crate winreg;
-#[cfg(windows)]
-extern crate user32;
-#[cfg(windows)]
-extern crate kernel32;
 extern crate libc;
 
 #[macro_use]
@@ -172,8 +168,7 @@ fn make_environment_compatible() {
 #[cfg(windows)]
 fn fix_windows_reg_key() {
     use winreg::RegKey;
-    use winreg::enums::RegType;
-    use winapi::*;
+    use winreg::enums::{RegType, HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
 
     let root = RegKey::predef(HKEY_CURRENT_USER);
     let env = root.open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE);

src/rustup-cli/self_update.rs

@@ -944,11 +944,12 @@ fn delete_rustup_and_cargo_home() -> Result<()> {
     let numbah: u32 = rand::random();
     let gc_exe = work_path.join(&format!("rustup-gc-{:x}.exe", numbah));
 
-    use winapi::{FILE_SHARE_DELETE, FILE_SHARE_READ,
-                 INVALID_HANDLE_VALUE, FILE_FLAG_DELETE_ON_CLOSE,
-                 DWORD, SECURITY_ATTRIBUTES, OPEN_EXISTING,
-                 GENERIC_READ};
-    use kernel32::{CreateFileW, CloseHandle};
+    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
+    use winapi::um::handleapi::{CloseHandle, INVALID_HANDLE_VALUE};
+    use winapi::um::minwinbase::SECURITY_ATTRIBUTES;
+    use winapi::um::winbase::FILE_FLAG_DELETE_ON_CLOSE;
+    use winapi::um::winnt::{FILE_SHARE_DELETE, FILE_SHARE_READ, GENERIC_READ};
+    use winapi::shared::minwindef::DWORD;
     use std::os::windows::ffi::OsStrExt;
     use std::ptr;
     use std::io;
@@ -1028,11 +1029,13 @@ pub fn complete_windows_uninstall() -> Result<()> {
 
 #[cfg(windows)]
 fn wait_for_parent() -> Result<()> {
-    use kernel32::{Process32First, Process32Next,
-                   CreateToolhelp32Snapshot, CloseHandle, OpenProcess,
-                   GetCurrentProcessId, WaitForSingleObject};
-    use winapi::{PROCESSENTRY32, INVALID_HANDLE_VALUE, DWORD, INFINITE,
-                 TH32CS_SNAPPROCESS, SYNCHRONIZE, WAIT_OBJECT_0};
+    use winapi::shared::minwindef::DWORD;
+    use winapi::um::handleapi::{CloseHandle, INVALID_HANDLE_VALUE};
+    use winapi::um::processthreadsapi::{OpenProcess, GetCurrentProcessId};
+    use winapi::um::synchapi::WaitForSingleObject;
+    use winapi::um::tlhelp32::{CreateToolhelp32Snapshot, Process32First, Process32Next, PROCESSENTRY32, TH32CS_SNAPPROCESS};
+    use winapi::um::winbase::{INFINITE, WAIT_OBJECT_0};
+    use winapi::um::winnt::SYNCHRONIZE;
     use std::io;
     use std::mem;
     use std::ptr;
@@ -1172,9 +1175,9 @@ fn do_add_to_path(methods: &[PathUpdateMethod]) -> Result<()> {
     assert!(methods.len() == 1 && methods[0] == PathUpdateMethod::Windows);
 
     use winreg::{RegKey, RegValue};
-    use winreg::enums::RegType;
-    use winapi::*;
-    use user32::*;
+    use winreg::enums::{RegType, HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
+    use winapi::shared::minwindef::*;
+    use winapi::um::winuser::{SendMessageTimeoutA, HWND_BROADCAST, WM_SETTINGCHANGE, SMTO_ABORTIFHUNG};
     use std::ptr;
 
     let old_path = if let Some(s) = try!(get_windows_path_var()) {
@@ -1224,7 +1227,7 @@ fn do_add_to_path(methods: &[PathUpdateMethod]) -> Result<()> {
 #[cfg(windows)]
 fn get_windows_path_var() -> Result<Option<String>> {
     use winreg::RegKey;
-    use winapi::*;
+    use winreg::enums::{HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
     use std::io;
 
     let root = RegKey::predef(HKEY_CURRENT_USER);
@@ -1281,10 +1284,10 @@ fn get_remove_path_methods() -> Result<Vec<PathUpdateMethod>> {
 fn do_remove_from_path(methods: &[PathUpdateMethod]) -> Result<()> {
     assert!(methods.len() == 1 && methods[0] == PathUpdateMethod::Windows);
 
+    use winapi::shared::minwindef::*;
+    use winapi::um::winuser::{SendMessageTimeoutA, SMTO_ABORTIFHUNG, HWND_BROADCAST, WM_SETTINGCHANGE};
     use winreg::{RegKey, RegValue};
-    use winreg::enums::RegType;
-    use winapi::*;
-    use user32::*;
+    use winreg::enums::{RegType, HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
     use std::ptr;
 
     let old_path = if let Some(s) = try!(get_windows_path_var()) {

src/rustup-dist/Cargo.toml

@@ -32,10 +32,8 @@ rustup-mock = { path = "../rustup-mock" }
 tempdir = "0.3.4"
 
 [target."cfg(windows)".dependencies]
-winapi = "0.2.8"
+winapi = { version = "0.3", features = ["handleapi", "sysinfoapi", "tlhelp32", "winnt"] }
 winreg = "0.4"
-user32-sys = "0.2.0"
-kernel32-sys = "0.2.1"
 
 [target."cfg(not(windows))".dependencies]
 libc = "0.2.0"

src/rustup-dist/src/dist.rs

@@ -116,7 +116,7 @@ impl TargetTriple {
     pub fn from_host() -> Option<Self> {
         #[cfg(windows)]
         fn inner() -> Option<TargetTriple> {
-            use kernel32::GetNativeSystemInfo;
+            use winapi::um::sysinfoapi::GetNativeSystemInfo;
             use std::mem;
 
             // First detect architecture
@@ -129,7 +129,7 @@ impl TargetTriple {
                 GetNativeSystemInfo(&mut sys_info);
             }
 
-            let arch = match sys_info.wProcessorArchitecture {
+            let arch = match unsafe { sys_info.u.s() }.wProcessorArchitecture {
                 PROCESSOR_ARCHITECTURE_AMD64 => "x86_64",
                 PROCESSOR_ARCHITECTURE_INTEL => "i686",
                 _ => return None,

src/rustup-dist/src/lib.rs

@@ -16,10 +16,6 @@ extern crate sha2;
 extern crate winapi;
 #[cfg(windows)]
 extern crate winreg;
-#[cfg(windows)]
-extern crate user32;
-#[cfg(windows)]
-extern crate kernel32;
 #[cfg(not(windows))]
 extern crate libc;
 

src/rustup-mock/Cargo.toml

@@ -22,6 +22,6 @@ sha2 = "0.6.0"
 wait-timeout = "0.1.3"
 
 [target."cfg(windows)".dependencies]
-winapi = "0.2.8"
+winapi = "0.3"
 winreg = "0.4.0"
 

src/rustup-mock/src/lib.rs

@@ -165,7 +165,7 @@ impl MockContents {
 #[cfg(windows)]
 pub fn get_path() -> Option<String> {
     use winreg::RegKey;
-    use winapi::*;
+    use winreg::enums::{HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
 
     let root = RegKey::predef(HKEY_CURRENT_USER);
     let environment = root.open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE).unwrap();
@@ -176,8 +176,7 @@ pub fn get_path() -> Option<String> {
 #[cfg(windows)]
 pub fn restore_path(p: &Option<String>) {
     use winreg::{RegKey, RegValue};
-    use winreg::enums::RegType;
-    use winapi::*;
+    use winreg::enums::{RegType, HKEY_CURRENT_USER, KEY_READ, KEY_WRITE};
 
     let root = RegKey::predef(HKEY_CURRENT_USER);
     let environment = root.open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE).unwrap();

src/rustup-utils/Cargo.toml

@@ -24,10 +24,6 @@ toml = "0.4"
 url = "1.1"
 
 [target."cfg(windows)".dependencies]
-advapi32-sys = "0.2.0"
-kernel32-sys = "0.2.1"
-ole32-sys = "0.2.0"
-shell32-sys = "0.1.1"
-userenv-sys = "0.2.0"
-winapi = "0.2.8"
+winapi = { version = "0.3", features = ["combaseapi", "errhandlingapi", "fileapi", "handleapi", 
+    "ioapiset", "minwindef", "processthreadsapi", "shlobj", "shtypes", "userenv", "winbase", "winerror", "winnt", "winioctl"] }
 winreg = "0.4.0"

src/rustup-utils/src/lib.rs

@@ -14,16 +14,6 @@ extern crate semver;
 extern crate winapi;
 #[cfg(windows)]
 extern crate winreg;
-#[cfg(windows)]
-extern crate shell32;
-#[cfg(windows)]
-extern crate ole32;
-#[cfg(windows)]
-extern crate kernel32;
-#[cfg(windows)]
-extern crate advapi32;
-#[cfg(windows)]
-extern crate userenv;
 
 #[cfg(unix)]
 extern crate libc;