libstd: win: Don't use GetFileInformationByHandle on UWP

This function isn't supported on UWP.
Use a combination of GetFileInformationByHandleEx & GetFileSizeEx
instead.

Author: chouquette

src/libstd/sys/windows/c.rs

@@ -40,6 +40,7 @@ pub type DWORDLONG = ULONGLONG;
 
 pub type LPBOOL = *mut BOOL;
 pub type LPBYTE = *mut BYTE;
+#[cfg(not(target_os = "uwp"))]
 pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 pub type LPCSTR = *const CHAR;
 #[cfg(not(target_os = "uwp"))]
@@ -381,6 +382,7 @@ pub struct WIN32_FILE_ATTRIBUTE_DATA {
     pub nFileSizeLow: DWORD,
 }
 
+#[cfg(not(target_os = "uwp"))]
 #[repr(C)]
 pub struct BY_HANDLE_FILE_INFORMATION {
     pub dwFileAttributes: DWORD,
@@ -1062,10 +1064,17 @@ extern "system" {
     pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
     pub fn SetFileAttributesW(lpFileName: LPCWSTR,
                               dwFileAttributes: DWORD) -> BOOL;
+    #[cfg(not(target_os = "uwp"))]
     pub fn GetFileInformationByHandle(hFile: HANDLE,
-                            lpFileInformation: LPBY_HANDLE_FILE_INFORMATION)
-                            -> BOOL;
-
+                        lpFileInformation: LPBY_HANDLE_FILE_INFORMATION)
+                        -> BOOL;
+    #[cfg(target_os = "uwp")]
+    pub fn GetFileInformationByHandleEx(hFile: HANDLE,
+                                        fileInfoClass: FILE_INFO_BY_HANDLE_CLASS,
+                                        lpFileInformation: LPVOID,
+                                        dwBufferSize: DWORD) -> BOOL;
+    #[cfg(target_os = "uwp")]
+    pub fn GetFileSizeEx(hFile: HANDLE, lpFileSize: PLARGE_INTEGER) -> BOOL;
     pub fn SetLastError(dwErrCode: DWORD);
     pub fn GetCommandLineW() -> *mut LPCWSTR;
     pub fn GetTempPathW(nBufferLength: DWORD,

src/libstd/sys/windows/fs.rs

@@ -12,6 +12,8 @@ use crate::sys::handle::Handle;
 use crate::sys::time::SystemTime;
 use crate::sys::{c, cvt};
 use crate::sys_common::FromInner;
+#[cfg(target_os = "uwp")]
+use libc::c_void;
 
 use super::to_u16s;
 
@@ -287,6 +289,7 @@ impl File {
         Ok(())
     }
 
+    #[cfg(not(target_os = "uwp"))]
     pub fn file_attr(&self) -> io::Result<FileAttr> {
         unsafe {
             let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed();
@@ -310,6 +313,43 @@ impl File {
         }
     }
 
+    #[cfg(target_os = "uwp")]
+    pub fn file_attr(&self) -> io::Result<FileAttr> {
+        unsafe {
+            let mut info: c::FILE_BASIC_INFO = mem::zeroed();
+            let size = mem::size_of_val(&info);
+            cvt(c::GetFileInformationByHandleEx(self.handle.raw(),
+                                              c::FileBasicInfo,
+                                              &mut info as *mut _ as *mut c_void,
+                                              size as c::DWORD))?;
+            let mut attr = FileAttr {
+                attributes: info.FileAttributes,
+                creation_time: c::FILETIME {
+                    dwLowDateTime: info.CreationTime as c::DWORD,
+                    dwHighDateTime: (info.CreationTime >> 32) as c::DWORD,
+                },
+                last_access_time: c::FILETIME {
+                    dwLowDateTime: info.LastAccessTime as c::DWORD,
+                    dwHighDateTime: (info.LastAccessTime >> 32) as c::DWORD,
+                },
+                last_write_time: c::FILETIME {
+                    dwLowDateTime: info.LastWriteTime as c::DWORD,
+                    dwHighDateTime: (info.LastWriteTime >> 32) as c::DWORD,
+                },
+                file_size: 0,
+                reparse_tag: 0,
+            };
+            cvt(c::GetFileSizeEx(self.handle.raw(), &mut attr.file_size as *mut _ as *mut i64))?;
+            if attr.is_reparse_point() {
+                let mut b = [0; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
+                if let Ok((_, buf)) = self.reparse_point(&mut b) {
+                    attr.reparse_tag = buf.ReparseTag;
+                }
+            }
+            Ok(attr)
+        }
+    }
+
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
         self.handle.read(buf)
     }