library/std/src/sys/windows/fs.rs

   1 use crate::os::windows::prelude::*;
   2
   3 use crate::ffi::OsString;
   4 use crate::fmt;
   5 use crate::io::{self, Error, IoSlice, IoSliceMut, ReadBuf, SeekFrom};
   6 use crate::mem;
   7 use crate::os::windows::io::{AsHandle, BorrowedHandle};
   8 use crate::path::{Path, PathBuf};
   9 use crate::ptr;
  10 use crate::slice;
  11 use crate::sync::Arc;
  12 use crate::sys::handle::Handle;
  13 use crate::sys::time::SystemTime;
  14 use crate::sys::{c, cvt};
  15 use crate::sys_common::{AsInner, FromInner, IntoInner};
  16
  17 use super::path::maybe_verbatim;
  18 use super::to_u16s;
  19
  20 pub struct File {
  21     handle: Handle,
  22 }
  23
  24 #[derive(Clone)]
  25 pub struct FileAttr {
  26     attributes: c::DWORD,
  27     creation_time: c::FILETIME,
  28     last_access_time: c::FILETIME,
  29     last_write_time: c::FILETIME,
  30     file_size: u64,
  31     reparse_tag: c::DWORD,
  32     volume_serial_number: Option<u32>,
  33     number_of_links: Option<u32>,
  34     file_index: Option<u64>,
  35 }
  36
  37 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
  38 pub struct FileType {
  39     attributes: c::DWORD,
  40     reparse_tag: c::DWORD,
  41 }
  42
  43 pub struct ReadDir {
  44     handle: FindNextFileHandle,
  45     root: Arc<PathBuf>,
  46     first: Option<c::WIN32_FIND_DATAW>,
  47 }
  48
  49 struct FindNextFileHandle(c::HANDLE);
  50
  51 unsafe impl Send for FindNextFileHandle {}
  52 unsafe impl Sync for FindNextFileHandle {}
  53
  54 pub struct DirEntry {
  55     root: Arc<PathBuf>,
  56     data: c::WIN32_FIND_DATAW,
  57 }
  58
  59 #[derive(Clone, Debug)]
  60 pub struct OpenOptions {
  61     // generic
  62     read: bool,
  63     write: bool,
  64     append: bool,
  65     truncate: bool,
  66     create: bool,
  67     create_new: bool,
  68     // system-specific
  69     custom_flags: u32,
  70     access_mode: Option<c::DWORD>,
  71     attributes: c::DWORD,
  72     share_mode: c::DWORD,
  73     security_qos_flags: c::DWORD,
  74     security_attributes: usize, // FIXME: should be a reference
  75 }
  76
  77 #[derive(Clone, PartialEq, Eq, Debug)]
  78 pub struct FilePermissions {
  79     attrs: c::DWORD,
  80 }
  81
  82 #[derive(Debug)]
  83 pub struct DirBuilder;
  84
  85 impl fmt::Debug for ReadDir {
  86     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  87         // This will only be called from std::fs::ReadDir, which will add a "ReadDir()" frame.
  88         // Thus the result will be e g 'ReadDir("C:\")'
  89         fmt::Debug::fmt(&*self.root, f)
  90     }
  91 }
  92
  93 impl Iterator for ReadDir {
  94     type Item = io::Result<DirEntry>;
  95     fn next(&mut self) -> Option<io::Result<DirEntry>> {
  96         if let Some(first) = self.first.take() {
  97             if let Some(e) = DirEntry::new(&self.root, &first) {
  98                 return Some(Ok(e));
  99             }
 100         }
 101         unsafe {
 102             let mut wfd = mem::zeroed();
 103             loop {
 104                 if c::FindNextFileW(self.handle.0, &mut wfd) == 0 {
 105                     if c::GetLastError() == c::ERROR_NO_MORE_FILES {
 106                         return None;
 107                     } else {
 108                         return Some(Err(Error::last_os_error()));
 109                     }
 110                 }
 111                 if let Some(e) = DirEntry::new(&self.root, &wfd) {
 112                     return Some(Ok(e));
 113                 }
 114             }
 115         }
 116     }
 117 }
 118
 119 impl Drop for FindNextFileHandle {
 120     fn drop(&mut self) {
 121         let r = unsafe { c::FindClose(self.0) };
 122         debug_assert!(r != 0);
 123     }
 124 }
 125
 126 impl DirEntry {
 127     fn new(root: &Arc<PathBuf>, wfd: &c::WIN32_FIND_DATAW) -> Option<DirEntry> {
 128         match &wfd.cFileName[0..3] {
 129             // check for '.' and '..'
 130             &[46, 0, ..] | &[46, 46, 0, ..] => return None,
 131             _ => {}
 132         }
 133
 134         Some(DirEntry { root: root.clone(), data: *wfd })
 135     }
 136
 137     pub fn path(&self) -> PathBuf {
 138         self.root.join(&self.file_name())
 139     }
 140
 141     pub fn file_name(&self) -> OsString {
 142         let filename = super::truncate_utf16_at_nul(&self.data.cFileName);
 143         OsString::from_wide(filename)
 144     }
 145
 146     pub fn file_type(&self) -> io::Result<FileType> {
 147         Ok(FileType::new(
 148             self.data.dwFileAttributes,
 149             /* reparse_tag = */ self.data.dwReserved0,
 150         ))
 151     }
 152
 153     pub fn metadata(&self) -> io::Result<FileAttr> {
 154         Ok(FileAttr {
 155             attributes: self.data.dwFileAttributes,
 156             creation_time: self.data.ftCreationTime,
 157             last_access_time: self.data.ftLastAccessTime,
 158             last_write_time: self.data.ftLastWriteTime,
 159             file_size: ((self.data.nFileSizeHigh as u64) << 32) | (self.data.nFileSizeLow as u64),
 160             reparse_tag: if self.data.dwFileAttributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 {
 161                 // reserved unless this is a reparse point
 162                 self.data.dwReserved0
 163             } else {
 164                 0
 165             },
 166             volume_serial_number: None,
 167             number_of_links: None,
 168             file_index: None,
 169         })
 170     }
 171 }
 172
 173 impl OpenOptions {
 174     pub fn new() -> OpenOptions {
 175         OpenOptions {
 176             // generic
 177             read: false,
 178             write: false,
 179             append: false,
 180             truncate: false,
 181             create: false,
 182             create_new: false,
 183             // system-specific
 184             custom_flags: 0,
 185             access_mode: None,
 186             share_mode: c::FILE_SHARE_READ | c::FILE_SHARE_WRITE | c::FILE_SHARE_DELETE,
 187             attributes: 0,
 188             security_qos_flags: 0,
 189             security_attributes: 0,
 190         }
 191     }
 192
 193     pub fn read(&mut self, read: bool) {
 194         self.read = read;
 195     }
 196     pub fn write(&mut self, write: bool) {
 197         self.write = write;
 198     }
 199     pub fn append(&mut self, append: bool) {
 200         self.append = append;
 201     }
 202     pub fn truncate(&mut self, truncate: bool) {
 203         self.truncate = truncate;
 204     }
 205     pub fn create(&mut self, create: bool) {
 206         self.create = create;
 207     }
 208     pub fn create_new(&mut self, create_new: bool) {
 209         self.create_new = create_new;
 210     }
 211
 212     pub fn custom_flags(&mut self, flags: u32) {
 213         self.custom_flags = flags;
 214     }
 215     pub fn access_mode(&mut self, access_mode: u32) {
 216         self.access_mode = Some(access_mode);
 217     }
 218     pub fn share_mode(&mut self, share_mode: u32) {
 219         self.share_mode = share_mode;
 220     }
 221     pub fn attributes(&mut self, attrs: u32) {
 222         self.attributes = attrs;
 223     }
 224     pub fn security_qos_flags(&mut self, flags: u32) {
 225         // We have to set `SECURITY_SQOS_PRESENT` here, because one of the valid flags we can
 226         // receive is `SECURITY_ANONYMOUS = 0x0`, which we can't check for later on.
 227         self.security_qos_flags = flags | c::SECURITY_SQOS_PRESENT;
 228     }
 229     pub fn security_attributes(&mut self, attrs: c::LPSECURITY_ATTRIBUTES) {
 230         self.security_attributes = attrs as usize;
 231     }
 232
 233     fn get_access_mode(&self) -> io::Result<c::DWORD> {
 234         const ERROR_INVALID_PARAMETER: i32 = 87;
 235
 236         match (self.read, self.write, self.append, self.access_mode) {
 237             (.., Some(mode)) => Ok(mode),
 238             (true, false, false, None) => Ok(c::GENERIC_READ),
 239             (false, true, false, None) => Ok(c::GENERIC_WRITE),
 240             (true, true, false, None) => Ok(c::GENERIC_READ | c::GENERIC_WRITE),
 241             (false, _, true, None) => Ok(c::FILE_GENERIC_WRITE & !c::FILE_WRITE_DATA),
 242             (true, _, true, None) => {
 243                 Ok(c::GENERIC_READ | (c::FILE_GENERIC_WRITE & !c::FILE_WRITE_DATA))
 244             }
 245             (false, false, false, None) => Err(Error::from_raw_os_error(ERROR_INVALID_PARAMETER)),
 246         }
 247     }
 248
 249     fn get_creation_mode(&self) -> io::Result<c::DWORD> {
 250         const ERROR_INVALID_PARAMETER: i32 = 87;
 251
 252         match (self.write, self.append) {
 253             (true, false) => {}
 254             (false, false) => {
 255                 if self.truncate || self.create || self.create_new {
 256                     return Err(Error::from_raw_os_error(ERROR_INVALID_PARAMETER));
 257                 }
 258             }
 259             (_, true) => {
 260                 if self.truncate && !self.create_new {
 261                     return Err(Error::from_raw_os_error(ERROR_INVALID_PARAMETER));
 262                 }
 263             }
 264         }
 265
 266         Ok(match (self.create, self.truncate, self.create_new) {
 267             (false, false, false) => c::OPEN_EXISTING,
 268             (true, false, false) => c::OPEN_ALWAYS,
 269             (false, true, false) => c::TRUNCATE_EXISTING,
 270             (true, true, false) => c::CREATE_ALWAYS,
 271             (_, _, true) => c::CREATE_NEW,
 272         })
 273     }
 274
 275     fn get_flags_and_attributes(&self) -> c::DWORD {
 276         self.custom_flags
 277             | self.attributes
 278             | self.security_qos_flags
 279             | if self.create_new { c::FILE_FLAG_OPEN_REPARSE_POINT } else { 0 }
 280     }
 281 }
 282
 283 impl File {
 284     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
 285         let path = maybe_verbatim(path)?;
 286         let handle = unsafe {
 287             c::CreateFileW(
 288                 path.as_ptr(),
 289                 opts.get_access_mode()?,
 290                 opts.share_mode,
 291                 opts.security_attributes as *mut _,
 292                 opts.get_creation_mode()?,
 293                 opts.get_flags_and_attributes(),
 294                 ptr::null_mut(),
 295             )
 296         };
 297         if handle == c::INVALID_HANDLE_VALUE {
 298             Err(Error::last_os_error())
 299         } else {
 300             unsafe { Ok(File { handle: Handle::from_raw_handle(handle) }) }
 301         }
 302     }
 303
 304     pub fn fsync(&self) -> io::Result<()> {
 305         cvt(unsafe { c::FlushFileBuffers(self.handle.as_raw_handle()) })?;
 306         Ok(())
 307     }
 308
 309     pub fn datasync(&self) -> io::Result<()> {
 310         self.fsync()
 311     }
 312
 313     pub fn truncate(&self, size: u64) -> io::Result<()> {
 314         let mut info = c::FILE_END_OF_FILE_INFO { EndOfFile: size as c::LARGE_INTEGER };
 315         let size = mem::size_of_val(&info);
 316         cvt(unsafe {
 317             c::SetFileInformationByHandle(
 318                 self.handle.as_raw_handle(),
 319                 c::FileEndOfFileInfo,
 320                 &mut info as *mut _ as *mut _,
 321                 size as c::DWORD,
 322             )
 323         })?;
 324         Ok(())
 325     }
 326
 327     #[cfg(not(target_vendor = "uwp"))]
 328     pub fn file_attr(&self) -> io::Result<FileAttr> {
 329         unsafe {
 330             let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed();
 331             cvt(c::GetFileInformationByHandle(self.handle.as_raw_handle(), &mut info))?;
 332             let mut reparse_tag = 0;
 333             if info.dwFileAttributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 {
 334                 let mut b = [0; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 335                 if let Ok((_, buf)) = self.reparse_point(&mut b) {
 336                     reparse_tag = buf.ReparseTag;
 337                 }
 338             }
 339             Ok(FileAttr {
 340                 attributes: info.dwFileAttributes,
 341                 creation_time: info.ftCreationTime,
 342                 last_access_time: info.ftLastAccessTime,
 343                 last_write_time: info.ftLastWriteTime,
 344                 file_size: (info.nFileSizeLow as u64) | ((info.nFileSizeHigh as u64) << 32),
 345                 reparse_tag,
 346                 volume_serial_number: Some(info.dwVolumeSerialNumber),
 347                 number_of_links: Some(info.nNumberOfLinks),
 348                 file_index: Some(
 349                     (info.nFileIndexLow as u64) | ((info.nFileIndexHigh as u64) << 32),
 350                 ),
 351             })
 352         }
 353     }
 354
 355     #[cfg(target_vendor = "uwp")]
 356     pub fn file_attr(&self) -> io::Result<FileAttr> {
 357         unsafe {
 358             let mut info: c::FILE_BASIC_INFO = mem::zeroed();
 359             let size = mem::size_of_val(&info);
 360             cvt(c::GetFileInformationByHandleEx(
 361                 self.handle.as_raw_handle(),
 362                 c::FileBasicInfo,
 363                 &mut info as *mut _ as *mut libc::c_void,
 364                 size as c::DWORD,
 365             ))?;
 366             let mut attr = FileAttr {
 367                 attributes: info.FileAttributes,
 368                 creation_time: c::FILETIME {
 369                     dwLowDateTime: info.CreationTime as c::DWORD,
 370                     dwHighDateTime: (info.CreationTime >> 32) as c::DWORD,
 371                 },
 372                 last_access_time: c::FILETIME {
 373                     dwLowDateTime: info.LastAccessTime as c::DWORD,
 374                     dwHighDateTime: (info.LastAccessTime >> 32) as c::DWORD,
 375                 },
 376                 last_write_time: c::FILETIME {
 377                     dwLowDateTime: info.LastWriteTime as c::DWORD,
 378                     dwHighDateTime: (info.LastWriteTime >> 32) as c::DWORD,
 379                 },
 380                 file_size: 0,
 381                 reparse_tag: 0,
 382                 volume_serial_number: None,
 383                 number_of_links: None,
 384                 file_index: None,
 385             };
 386             let mut info: c::FILE_STANDARD_INFO = mem::zeroed();
 387             let size = mem::size_of_val(&info);
 388             cvt(c::GetFileInformationByHandleEx(
 389                 self.handle.as_raw_handle(),
 390                 c::FileStandardInfo,
 391                 &mut info as *mut _ as *mut libc::c_void,
 392                 size as c::DWORD,
 393             ))?;
 394             attr.file_size = info.AllocationSize as u64;
 395             attr.number_of_links = Some(info.NumberOfLinks);
 396             if attr.file_type().is_reparse_point() {
 397                 let mut b = [0; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 398                 if let Ok((_, buf)) = self.reparse_point(&mut b) {
 399                     attr.reparse_tag = buf.ReparseTag;
 400                 }
 401             }
 402             Ok(attr)
 403         }
 404     }
 405
 406     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
 407         self.handle.read(buf)
 408     }
 409
 410     pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
 411         self.handle.read_vectored(bufs)
 412     }
 413
 414     #[inline]
 415     pub fn is_read_vectored(&self) -> bool {
 416         self.handle.is_read_vectored()
 417     }
 418
 419     pub fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
 420         self.handle.read_at(buf, offset)
 421     }
 422
 423     pub fn read_buf(&self, buf: &mut ReadBuf<'_>) -> io::Result<()> {
 424         self.handle.read_buf(buf)
 425     }
 426
 427     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
 428         self.handle.write(buf)
 429     }
 430
 431     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 432         self.handle.write_vectored(bufs)
 433     }
 434
 435     #[inline]
 436     pub fn is_write_vectored(&self) -> bool {
 437         self.handle.is_write_vectored()
 438     }
 439
 440     pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
 441         self.handle.write_at(buf, offset)
 442     }
 443
 444     pub fn flush(&self) -> io::Result<()> {
 445         Ok(())
 446     }
 447
 448     pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
 449         let (whence, pos) = match pos {
 450             // Casting to `i64` is fine, `SetFilePointerEx` reinterprets this
 451             // integer as `u64`.
 452             SeekFrom::Start(n) => (c::FILE_BEGIN, n as i64),
 453             SeekFrom::End(n) => (c::FILE_END, n),
 454             SeekFrom::Current(n) => (c::FILE_CURRENT, n),
 455         };
 456         let pos = pos as c::LARGE_INTEGER;
 457         let mut newpos = 0;
 458         cvt(unsafe { c::SetFilePointerEx(self.handle.as_raw_handle(), pos, &mut newpos, whence) })?;
 459         Ok(newpos as u64)
 460     }
 461
 462     pub fn duplicate(&self) -> io::Result<File> {
 463         Ok(Self { handle: self.handle.try_clone()? })
 464     }
 465
 466     fn reparse_point<'a>(
 467         &self,
 468         space: &'a mut [u8; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE],
 469     ) -> io::Result<(c::DWORD, &'a c::REPARSE_DATA_BUFFER)> {
 470         unsafe {
 471             let mut bytes = 0;
 472             cvt({
 473                 c::DeviceIoControl(
 474                     self.handle.as_raw_handle(),
 475                     c::FSCTL_GET_REPARSE_POINT,
 476                     ptr::null_mut(),
 477                     0,
 478                     space.as_mut_ptr() as *mut _,
 479                     space.len() as c::DWORD,
 480                     &mut bytes,
 481                     ptr::null_mut(),
 482                 )
 483             })?;
 484             Ok((bytes, &*(space.as_ptr() as *const c::REPARSE_DATA_BUFFER)))
 485         }
 486     }
 487
 488     fn readlink(&self) -> io::Result<PathBuf> {
 489         let mut space = [0u8; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 490         let (_bytes, buf) = self.reparse_point(&mut space)?;
 491         unsafe {
 492             let (path_buffer, subst_off, subst_len, relative) = match buf.ReparseTag {
 493                 c::IO_REPARSE_TAG_SYMLINK => {
 494                     let info: *const c::SYMBOLIC_LINK_REPARSE_BUFFER =
 495                         &buf.rest as *const _ as *const _;
 496                     (
 497                         &(*info).PathBuffer as *const _ as *const u16,
 498                         (*info).SubstituteNameOffset / 2,
 499                         (*info).SubstituteNameLength / 2,
 500                         (*info).Flags & c::SYMLINK_FLAG_RELATIVE != 0,
 501                     )
 502                 }
 503                 c::IO_REPARSE_TAG_MOUNT_POINT => {
 504                     let info: *const c::MOUNT_POINT_REPARSE_BUFFER =
 505                         &buf.rest as *const _ as *const _;
 506                     (
 507                         &(*info).PathBuffer as *const _ as *const u16,
 508                         (*info).SubstituteNameOffset / 2,
 509                         (*info).SubstituteNameLength / 2,
 510                         false,
 511                     )
 512                 }
 513                 _ => {
 514                     return Err(io::Error::new_const(
 515                         io::ErrorKind::Uncategorized,
 516                         &"Unsupported reparse point type",
 517                     ));
 518                 }
 519             };
 520             let subst_ptr = path_buffer.offset(subst_off as isize);
 521             let mut subst = slice::from_raw_parts(subst_ptr, subst_len as usize);
 522             // Absolute paths start with an NT internal namespace prefix `\??\`
 523             // We should not let it leak through.
 524             if !relative && subst.starts_with(&[92u16, 63u16, 63u16, 92u16]) {
 525                 subst = &subst[4..];
 526             }
 527             Ok(PathBuf::from(OsString::from_wide(subst)))
 528         }
 529     }
 530
 531     pub fn set_permissions(&self, perm: FilePermissions) -> io::Result<()> {
 532         let mut info = c::FILE_BASIC_INFO {
 533             CreationTime: 0,
 534             LastAccessTime: 0,
 535             LastWriteTime: 0,
 536             ChangeTime: 0,
 537             FileAttributes: perm.attrs,
 538         };
 539         let size = mem::size_of_val(&info);
 540         cvt(unsafe {
 541             c::SetFileInformationByHandle(
 542                 self.handle.as_raw_handle(),
 543                 c::FileBasicInfo,
 544                 &mut info as *mut _ as *mut _,
 545                 size as c::DWORD,
 546             )
 547         })?;
 548         Ok(())
 549     }
 550     /// Get only basic file information such as attributes and file times.
 551     fn basic_info(&self) -> io::Result<c::FILE_BASIC_INFO> {
 552         unsafe {
 553             let mut info: c::FILE_BASIC_INFO = mem::zeroed();
 554             let size = mem::size_of_val(&info);
 555             cvt(c::GetFileInformationByHandleEx(
 556                 self.handle.as_raw_handle(),
 557                 c::FileBasicInfo,
 558                 &mut info as *mut _ as *mut libc::c_void,
 559                 size as c::DWORD,
 560             ))?;
 561             Ok(info)
 562         }
 563     }
 564     /// Delete using POSIX semantics.
 565     ///
 566     /// Files will be deleted as soon as the handle is closed. This is supported
 567     /// for Windows 10 1607 (aka RS1) and later. However some filesystem
 568     /// drivers will not support it even then, e.g. FAT32.
 569     ///
 570     /// If the operation is not supported for this filesystem or OS version
 571     /// then errors will be `ERROR_NOT_SUPPORTED` or `ERROR_INVALID_PARAMETER`.
 572     fn posix_delete(&self) -> io::Result<()> {
 573         let mut info = c::FILE_DISPOSITION_INFO_EX {
 574             Flags: c::FILE_DISPOSITION_DELETE
 575                 | c::FILE_DISPOSITION_POSIX_SEMANTICS
 576                 | c::FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE,
 577         };
 578         let size = mem::size_of_val(&info);
 579         cvt(unsafe {
 580             c::SetFileInformationByHandle(
 581                 self.handle.as_raw_handle(),
 582                 c::FileDispositionInfoEx,
 583                 &mut info as *mut _ as *mut _,
 584                 size as c::DWORD,
 585             )
 586         })?;
 587         Ok(())
 588     }
 589
 590     /// Delete a file using win32 semantics. The file won't actually be deleted
 591     /// until all file handles are closed. However, marking a file for deletion
 592     /// will prevent anyone from opening a new handle to the file.
 593     fn win32_delete(&self) -> io::Result<()> {
 594         let mut info = c::FILE_DISPOSITION_INFO { DeleteFile: c::TRUE as _ };
 595         let size = mem::size_of_val(&info);
 596         cvt(unsafe {
 597             c::SetFileInformationByHandle(
 598                 self.handle.as_raw_handle(),
 599                 c::FileDispositionInfo,
 600                 &mut info as *mut _ as *mut _,
 601                 size as c::DWORD,
 602             )
 603         })?;
 604         Ok(())
 605     }
 606
 607     /// Fill the given buffer with as many directory entries as will fit.
 608     /// This will remember its position and continue from the last call unless
 609     /// `restart` is set to `true`.
 610     ///
 611     /// The returned bool indicates if there are more entries or not.
 612     /// It is an error if `self` is not a directory.
 613     ///
 614     /// # Symlinks and other reparse points
 615     ///
 616     /// On Windows a file is either a directory or a non-directory.
 617     /// A symlink directory is simply an empty directory with some "reparse" metadata attached.
 618     /// So if you open a link (not its target) and iterate the directory,
 619     /// you will always iterate an empty directory regardless of the target.
 620     fn fill_dir_buff(&self, buffer: &mut DirBuff, restart: bool) -> io::Result<bool> {
 621         let class =
 622             if restart { c::FileIdBothDirectoryRestartInfo } else { c::FileIdBothDirectoryInfo };
 623
 624         unsafe {
 625             let result = cvt(c::GetFileInformationByHandleEx(
 626                 self.handle.as_raw_handle(),
 627                 class,
 628                 buffer.as_mut_ptr().cast(),
 629                 buffer.capacity() as _,
 630             ));
 631             match result {
 632                 Ok(_) => Ok(true),
 633                 Err(e) if e.raw_os_error() == Some(c::ERROR_NO_MORE_FILES as _) => Ok(false),
 634                 Err(e) => Err(e),
 635             }
 636         }
 637     }
 638 }
 639
 640 /// A buffer for holding directory entries.
 641 struct DirBuff {
 642     buffer: Vec<u8>,
 643 }
 644 impl DirBuff {
 645     fn new() -> Self {
 646         const BUFFER_SIZE: usize = 1024;
 647         Self { buffer: vec![0_u8; BUFFER_SIZE] }
 648     }
 649     fn capacity(&self) -> usize {
 650         self.buffer.len()
 651     }
 652     fn as_mut_ptr(&mut self) -> *mut u8 {
 653         self.buffer.as_mut_ptr().cast()
 654     }
 655     /// Returns a `DirBuffIter`.
 656     fn iter(&self) -> DirBuffIter<'_> {
 657         DirBuffIter::new(self)
 658     }
 659 }
 660 impl AsRef<[u8]> for DirBuff {
 661     fn as_ref(&self) -> &[u8] {
 662         &self.buffer
 663     }
 664 }
 665
 666 /// An iterator over entries stored in a `DirBuff`.
 667 ///
 668 /// Currently only returns file names (UTF-16 encoded).
 669 struct DirBuffIter<'a> {
 670     buffer: Option<&'a [u8]>,
 671     cursor: usize,
 672 }
 673 impl<'a> DirBuffIter<'a> {
 674     fn new(buffer: &'a DirBuff) -> Self {
 675         Self { buffer: Some(buffer.as_ref()), cursor: 0 }
 676     }
 677 }
 678 impl<'a> Iterator for DirBuffIter<'a> {
 679     type Item = &'a [u16];
 680     fn next(&mut self) -> Option<Self::Item> {
 681         use crate::mem::size_of;
 682         let buffer = &self.buffer?[self.cursor..];
 683
 684         // Get the name and next entry from the buffer.
 685         // SAFETY: The buffer contains a `FILE_ID_BOTH_DIR_INFO` struct but the
 686         // last field (the file name) is unsized. So an offset has to be
 687         // used to get the file name slice.
 688         let (name, next_entry) = unsafe {
 689             let info = buffer.as_ptr().cast::<c::FILE_ID_BOTH_DIR_INFO>();
 690             let next_entry = (*info).NextEntryOffset as usize;
 691             let name = crate::slice::from_raw_parts(
 692                 (*info).FileName.as_ptr().cast::<u16>(),
 693                 (*info).FileNameLength as usize / size_of::<u16>(),
 694             );
 695             (name, next_entry)
 696         };
 697
 698         if next_entry == 0 {
 699             self.buffer = None
 700         } else {
 701             self.cursor += next_entry
 702         }
 703
 704         // Skip `.` and `..` pseudo entries.
 705         const DOT: u16 = b'.' as u16;
 706         match name {
 707             [DOT] | [DOT, DOT] => self.next(),
 708             _ => Some(name),
 709         }
 710     }
 711 }
 712
 713 /// Open a link relative to the parent directory, ensure no symlinks are followed.
 714 fn open_link_no_reparse(parent: &File, name: &[u16], access: u32) -> io::Result<File> {
 715     // This is implemented using the lower level `NtOpenFile` function as
 716     // unfortunately opening a file relative to a parent is not supported by
 717     // win32 functions. It is however a fundamental feature of the NT kernel.
 718     //
 719     // See https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntopenfile
 720     unsafe {
 721         let mut handle = ptr::null_mut();
 722         let mut io_status = c::IO_STATUS_BLOCK::default();
 723         let name_str = c::UNICODE_STRING::from_ref(name);
 724         use crate::sync::atomic::{AtomicU32, Ordering};
 725         // The `OBJ_DONT_REPARSE` attribute ensures that we haven't been
 726         // tricked into following a symlink. However, it may not be available in
 727         // earlier versions of Windows.
 728         static ATTRIBUTES: AtomicU32 = AtomicU32::new(c::OBJ_DONT_REPARSE);
 729         let object = c::OBJECT_ATTRIBUTES {
 730             ObjectName: &name_str,
 731             RootDirectory: parent.as_raw_handle(),
 732             Attributes: ATTRIBUTES.load(Ordering::Relaxed),
 733             ..c::OBJECT_ATTRIBUTES::default()
 734         };
 735         let status = c::NtOpenFile(
 736             &mut handle,
 737             access,
 738             &object,
 739             &mut io_status,
 740             c::FILE_SHARE_DELETE | c::FILE_SHARE_READ | c::FILE_SHARE_WRITE,
 741             // If `name` is a symlink then open the link rather than the target.
 742             c::FILE_OPEN_REPARSE_POINT,
 743         );
 744         // Convert an NTSTATUS to the more familiar Win32 error codes (aka "DosError")
 745         if c::nt_success(status) {
 746             Ok(File::from_raw_handle(handle))
 747         } else if status == c::STATUS_DELETE_PENDING {
 748             // We make a special exception for `STATUS_DELETE_PENDING` because
 749             // otherwise this will be mapped to `ERROR_ACCESS_DENIED` which is
 750             // very unhelpful.
 751             Err(io::Error::from_raw_os_error(c::ERROR_DELETE_PENDING as _))
 752         } else if status == c::STATUS_INVALID_PARAMETER
 753             && ATTRIBUTES.load(Ordering::Relaxed) == c::OBJ_DONT_REPARSE
 754         {
 755             // Try without `OBJ_DONT_REPARSE`. See above.
 756             ATTRIBUTES.store(0, Ordering::Relaxed);
 757             open_link_no_reparse(parent, name, access)
 758         } else {
 759             Err(io::Error::from_raw_os_error(c::RtlNtStatusToDosError(status) as _))
 760         }
 761     }
 762 }
 763
 764 impl AsInner<Handle> for File {
 765     fn as_inner(&self) -> &Handle {
 766         &self.handle
 767     }
 768 }
 769
 770 impl IntoInner<Handle> for File {
 771     fn into_inner(self) -> Handle {
 772         self.handle
 773     }
 774 }
 775
 776 impl FromInner<Handle> for File {
 777     fn from_inner(handle: Handle) -> File {
 778         File { handle }
 779     }
 780 }
 781
 782 impl AsHandle for File {
 783     fn as_handle(&self) -> BorrowedHandle<'_> {
 784         self.as_inner().as_handle()
 785     }
 786 }
 787
 788 impl AsRawHandle for File {
 789     fn as_raw_handle(&self) -> RawHandle {
 790         self.as_inner().as_raw_handle()
 791     }
 792 }
 793
 794 impl IntoRawHandle for File {
 795     fn into_raw_handle(self) -> RawHandle {
 796         self.into_inner().into_raw_handle()
 797     }
 798 }
 799
 800 impl FromRawHandle for File {
 801     unsafe fn from_raw_handle(raw_handle: RawHandle) -> Self {
 802         Self { handle: FromInner::from_inner(FromRawHandle::from_raw_handle(raw_handle)) }
 803     }
 804 }
 805
 806 impl fmt::Debug for File {
 807     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 808         // FIXME(#24570): add more info here (e.g., mode)
 809         let mut b = f.debug_struct("File");
 810         b.field("handle", &self.handle.as_raw_handle());
 811         if let Ok(path) = get_path(&self) {
 812             b.field("path", &path);
 813         }
 814         b.finish()
 815     }
 816 }
 817
 818 impl FileAttr {
 819     pub fn size(&self) -> u64 {
 820         self.file_size
 821     }
 822
 823     pub fn perm(&self) -> FilePermissions {
 824         FilePermissions { attrs: self.attributes }
 825     }
 826
 827     pub fn attrs(&self) -> u32 {
 828         self.attributes
 829     }
 830
 831     pub fn file_type(&self) -> FileType {
 832         FileType::new(self.attributes, self.reparse_tag)
 833     }
 834
 835     pub fn modified(&self) -> io::Result<SystemTime> {
 836         Ok(SystemTime::from(self.last_write_time))
 837     }
 838
 839     pub fn accessed(&self) -> io::Result<SystemTime> {
 840         Ok(SystemTime::from(self.last_access_time))
 841     }
 842
 843     pub fn created(&self) -> io::Result<SystemTime> {
 844         Ok(SystemTime::from(self.creation_time))
 845     }
 846
 847     pub fn modified_u64(&self) -> u64 {
 848         to_u64(&self.last_write_time)
 849     }
 850
 851     pub fn accessed_u64(&self) -> u64 {
 852         to_u64(&self.last_access_time)
 853     }
 854
 855     pub fn created_u64(&self) -> u64 {
 856         to_u64(&self.creation_time)
 857     }
 858
 859     pub fn volume_serial_number(&self) -> Option<u32> {
 860         self.volume_serial_number
 861     }
 862
 863     pub fn number_of_links(&self) -> Option<u32> {
 864         self.number_of_links
 865     }
 866
 867     pub fn file_index(&self) -> Option<u64> {
 868         self.file_index
 869     }
 870 }
 871
 872 fn to_u64(ft: &c::FILETIME) -> u64 {
 873     (ft.dwLowDateTime as u64) | ((ft.dwHighDateTime as u64) << 32)
 874 }
 875
 876 impl FilePermissions {
 877     pub fn readonly(&self) -> bool {
 878         self.attrs & c::FILE_ATTRIBUTE_READONLY != 0
 879     }
 880
 881     pub fn set_readonly(&mut self, readonly: bool) {
 882         if readonly {
 883             self.attrs |= c::FILE_ATTRIBUTE_READONLY;
 884         } else {
 885             self.attrs &= !c::FILE_ATTRIBUTE_READONLY;
 886         }
 887     }
 888 }
 889
 890 impl FileType {
 891     fn new(attrs: c::DWORD, reparse_tag: c::DWORD) -> FileType {
 892         FileType { attributes: attrs, reparse_tag }
 893     }
 894     pub fn is_dir(&self) -> bool {
 895         !self.is_symlink() && self.is_directory()
 896     }
 897     pub fn is_file(&self) -> bool {
 898         !self.is_symlink() && !self.is_directory()
 899     }
 900     pub fn is_symlink(&self) -> bool {
 901         self.is_reparse_point() && self.is_reparse_tag_name_surrogate()
 902     }
 903     pub fn is_symlink_dir(&self) -> bool {
 904         self.is_symlink() && self.is_directory()
 905     }
 906     pub fn is_symlink_file(&self) -> bool {
 907         self.is_symlink() && !self.is_directory()
 908     }
 909     fn is_directory(&self) -> bool {
 910         self.attributes & c::FILE_ATTRIBUTE_DIRECTORY != 0
 911     }
 912     fn is_reparse_point(&self) -> bool {
 913         self.attributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0
 914     }
 915     fn is_reparse_tag_name_surrogate(&self) -> bool {
 916         self.reparse_tag & 0x20000000 != 0
 917     }
 918 }
 919
 920 impl DirBuilder {
 921     pub fn new() -> DirBuilder {
 922         DirBuilder
 923     }
 924
 925     pub fn mkdir(&self, p: &Path) -> io::Result<()> {
 926         let p = maybe_verbatim(p)?;
 927         cvt(unsafe { c::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) })?;
 928         Ok(())
 929     }
 930 }
 931
 932 pub fn readdir(p: &Path) -> io::Result<ReadDir> {
 933     let root = p.to_path_buf();
 934     let star = p.join("*");
 935     let path = maybe_verbatim(&star)?;
 936
 937     unsafe {
 938         let mut wfd = mem::zeroed();
 939         let find_handle = c::FindFirstFileW(path.as_ptr(), &mut wfd);
 940         if find_handle != c::INVALID_HANDLE_VALUE {
 941             Ok(ReadDir {
 942                 handle: FindNextFileHandle(find_handle),
 943                 root: Arc::new(root),
 944                 first: Some(wfd),
 945             })
 946         } else {
 947             Err(Error::last_os_error())
 948         }
 949     }
 950 }
 951
 952 pub fn unlink(p: &Path) -> io::Result<()> {
 953     let p_u16s = maybe_verbatim(p)?;
 954     cvt(unsafe { c::DeleteFileW(p_u16s.as_ptr()) })?;
 955     Ok(())
 956 }
 957
 958 pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
 959     let old = maybe_verbatim(old)?;
 960     let new = maybe_verbatim(new)?;
 961     cvt(unsafe { c::MoveFileExW(old.as_ptr(), new.as_ptr(), c::MOVEFILE_REPLACE_EXISTING) })?;
 962     Ok(())
 963 }
 964
 965 pub fn rmdir(p: &Path) -> io::Result<()> {
 966     let p = maybe_verbatim(p)?;
 967     cvt(unsafe { c::RemoveDirectoryW(p.as_ptr()) })?;
 968     Ok(())
 969 }
 970
 971 /// Open a file or directory without following symlinks.
 972 fn open_link(path: &Path, access_mode: u32) -> io::Result<File> {
 973     let mut opts = OpenOptions::new();
 974     opts.access_mode(access_mode);
 975     // `FILE_FLAG_BACKUP_SEMANTICS` allows opening directories.
 976     // `FILE_FLAG_OPEN_REPARSE_POINT` opens a link instead of its target.
 977     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS | c::FILE_FLAG_OPEN_REPARSE_POINT);
 978     File::open(path, &opts)
 979 }
 980
 981 pub fn remove_dir_all(path: &Path) -> io::Result<()> {
 982     let file = open_link(path, c::DELETE | c::FILE_LIST_DIRECTORY)?;
 983
 984     // Test if the file is not a directory or a symlink to a directory.
 985     if (file.basic_info()?.FileAttributes & c::FILE_ATTRIBUTE_DIRECTORY) == 0 {
 986         return Err(io::Error::from_raw_os_error(c::ERROR_DIRECTORY as _));
 987     }
 988     let mut delete: fn(&File) -> io::Result<()> = File::posix_delete;
 989     let result = match delete(&file) {
 990         Err(e) if e.kind() == io::ErrorKind::DirectoryNotEmpty => {
 991             match remove_dir_all_recursive(&file, delete) {
 992                 // Return unexpected errors.
 993                 Err(e) if e.kind() != io::ErrorKind::DirectoryNotEmpty => return Err(e),
 994                 result => result,
 995             }
 996         }
 997         // If POSIX delete is not supported for this filesystem then fallback to win32 delete.
 998         Err(e)
 999             if e.raw_os_error() == Some(c::ERROR_NOT_SUPPORTED as i32)
1000                 || e.raw_os_error() == Some(c::ERROR_INVALID_PARAMETER as i32) =>
1001         {
1002             delete = File::win32_delete;
1003             Err(e)
1004         }
1005         result => result,
1006     };
1007     if result.is_ok() {
1008         Ok(())
1009     } else {
1010         // This is a fallback to make sure the directory is actually deleted.
1011         // Otherwise this function is prone to failing with `DirectoryNotEmpty`
1012         // due to possible delays between marking a file for deletion and the
1013         // file actually being deleted from the filesystem.
1014         //
1015         // So we retry a few times before giving up.
1016         for _ in 0..5 {
1017             match remove_dir_all_recursive(&file, delete) {
1018                 Err(e) if e.kind() == io::ErrorKind::DirectoryNotEmpty => {}
1019                 result => return result,
1020             }
1021         }
1022         // Try one last time.
1023         delete(&file)
1024     }
1025 }
1026
1027 fn remove_dir_all_recursive(f: &File, delete: fn(&File) -> io::Result<()>) -> io::Result<()> {
1028     let mut buffer = DirBuff::new();
1029     let mut restart = true;
1030     // Fill the buffer and iterate the entries.
1031     while f.fill_dir_buff(&mut buffer, restart)? {
1032         for name in buffer.iter() {
1033             // Open the file without following symlinks and try deleting it.
1034             // We try opening will all needed permissions and if that is denied
1035             // fallback to opening without `FILE_LIST_DIRECTORY` permission.
1036             // Note `SYNCHRONIZE` permission is needed for synchronous access.
1037             let mut result =
1038                 open_link_no_reparse(&f, name, c::SYNCHRONIZE | c::DELETE | c::FILE_LIST_DIRECTORY);
1039             if matches!(&result, Err(e) if e.kind() == io::ErrorKind::PermissionDenied) {
1040                 result = open_link_no_reparse(&f, name, c::SYNCHRONIZE | c::DELETE);
1041             }
1042             match result {
1043                 Ok(file) => match delete(&file) {
1044                     Err(e) if e.kind() == io::ErrorKind::DirectoryNotEmpty => {
1045                         // Iterate the directory's files.
1046                         // Ignore `DirectoryNotEmpty` errors here. They will be
1047                         // caught when `remove_dir_all` tries to delete the top
1048                         // level directory. It can then decide if to retry or not.
1049                         match remove_dir_all_recursive(&file, delete) {
1050                             Err(e) if e.kind() == io::ErrorKind::DirectoryNotEmpty => {}
1051                             result => result?,
1052                         }
1053                     }
1054                     result => result?,
1055                 },
1056                 // Ignore error if a delete is already in progress or the file
1057                 // has already been deleted. It also ignores sharing violations
1058                 // (where a file is locked by another process) as these are
1059                 // usually temporary.
1060                 Err(e)
1061                     if e.raw_os_error() == Some(c::ERROR_DELETE_PENDING as _)
1062                         || e.kind() == io::ErrorKind::NotFound
1063                         || e.raw_os_error() == Some(c::ERROR_SHARING_VIOLATION as _) => {}
1064                 Err(e) => return Err(e),
1065             }
1066         }
1067         // Continue reading directory entries without restarting from the beginning,
1068         restart = false;
1069     }
1070     delete(&f)
1071 }
1072
1073 pub fn readlink(path: &Path) -> io::Result<PathBuf> {
1074     // Open the link with no access mode, instead of generic read.
1075     // By default FILE_LIST_DIRECTORY is denied for the junction "C:\Documents and Settings", so
1076     // this is needed for a common case.
1077     let mut opts = OpenOptions::new();
1078     opts.access_mode(0);
1079     opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS);
1080     let file = File::open(&path, &opts)?;
1081     file.readlink()
1082 }
1083
1084 pub fn symlink(original: &Path, link: &Path) -> io::Result<()> {
1085     symlink_inner(original, link, false)
1086 }
1087
1088 pub fn symlink_inner(original: &Path, link: &Path, dir: bool) -> io::Result<()> {
1089     let original = to_u16s(original)?;
1090     let link = maybe_verbatim(link)?;
1091     let flags = if dir { c::SYMBOLIC_LINK_FLAG_DIRECTORY } else { 0 };
1092     // Formerly, symlink creation required the SeCreateSymbolicLink privilege. For the Windows 10
1093     // Creators Update, Microsoft loosened this to allow unprivileged symlink creation if the
1094     // computer is in Developer Mode, but SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE must be
1095     // added to dwFlags to opt into this behaviour.
1096     let result = cvt(unsafe {
1097         c::CreateSymbolicLinkW(
1098             link.as_ptr(),
1099             original.as_ptr(),
1100             flags | c::SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE,
1101         ) as c::BOOL
1102     });
1103     if let Err(err) = result {
1104         if err.raw_os_error() == Some(c::ERROR_INVALID_PARAMETER as i32) {
1105             // Older Windows objects to SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE,
1106             // so if we encounter ERROR_INVALID_PARAMETER, retry without that flag.
1107             cvt(unsafe {
1108                 c::CreateSymbolicLinkW(link.as_ptr(), original.as_ptr(), flags) as c::BOOL
1109             })?;
1110         } else {
1111             return Err(err);
1112         }
1113     }
1114     Ok(())
1115 }
1116
1117 #[cfg(not(target_vendor = "uwp"))]
1118 pub fn link(original: &Path, link: &Path) -> io::Result<()> {
1119     let original = maybe_verbatim(original)?;
1120     let link = maybe_verbatim(link)?;
1121     cvt(unsafe { c::CreateHardLinkW(link.as_ptr(), original.as_ptr(), ptr::null_mut()) })?;
1122     Ok(())
1123 }
1124
1125 #[cfg(target_vendor = "uwp")]
1126 pub fn link(_original: &Path, _link: &Path) -> io::Result<()> {
1127     return Err(io::Error::new_const(
1128         io::ErrorKind::Unsupported,
1129         &"hard link are not supported on UWP",
1130     ));
1131 }
1132
1133 pub fn stat(path: &Path) -> io::Result<FileAttr> {
1134     let mut opts = OpenOptions::new();
1135     // No read or write permissions are necessary
1136     opts.access_mode(0);
1137     // This flag is so we can open directories too
1138     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS);
1139     let file = File::open(path, &opts)?;
1140     file.file_attr()
1141 }
1142
1143 pub fn lstat(path: &Path) -> io::Result<FileAttr> {
1144     let mut opts = OpenOptions::new();
1145     // No read or write permissions are necessary
1146     opts.access_mode(0);
1147     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS | c::FILE_FLAG_OPEN_REPARSE_POINT);
1148     let file = File::open(path, &opts)?;
1149     file.file_attr()
1150 }
1151
1152 pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
1153     let p = maybe_verbatim(p)?;
1154     unsafe {
1155         cvt(c::SetFileAttributesW(p.as_ptr(), perm.attrs))?;
1156         Ok(())
1157     }
1158 }
1159
1160 fn get_path(f: &File) -> io::Result<PathBuf> {
1161     super::fill_utf16_buf(
1162         |buf, sz| unsafe {
1163             c::GetFinalPathNameByHandleW(f.handle.as_raw_handle(), buf, sz, c::VOLUME_NAME_DOS)
1164         },
1165         |buf| PathBuf::from(OsString::from_wide(buf)),
1166     )
1167 }
1168
1169 pub fn canonicalize(p: &Path) -> io::Result<PathBuf> {
1170     let mut opts = OpenOptions::new();
1171     // No read or write permissions are necessary
1172     opts.access_mode(0);
1173     // This flag is so we can open directories too
1174     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS);
1175     let f = File::open(p, &opts)?;
1176     get_path(&f)
1177 }
1178
1179 pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
1180     unsafe extern "system" fn callback(
1181         _TotalFileSize: c::LARGE_INTEGER,
1182         _TotalBytesTransferred: c::LARGE_INTEGER,
1183         _StreamSize: c::LARGE_INTEGER,
1184         StreamBytesTransferred: c::LARGE_INTEGER,
1185         dwStreamNumber: c::DWORD,
1186         _dwCallbackReason: c::DWORD,
1187         _hSourceFile: c::HANDLE,
1188         _hDestinationFile: c::HANDLE,
1189         lpData: c::LPVOID,
1190     ) -> c::DWORD {
1191         if dwStreamNumber == 1 {
1192             *(lpData as *mut i64) = StreamBytesTransferred;
1193         }
1194         c::PROGRESS_CONTINUE
1195     }
1196     let pfrom = maybe_verbatim(from)?;
1197     let pto = maybe_verbatim(to)?;
1198     let mut size = 0i64;
1199     cvt(unsafe {
1200         c::CopyFileExW(
1201             pfrom.as_ptr(),
1202             pto.as_ptr(),
1203             Some(callback),
1204             &mut size as *mut _ as *mut _,
1205             ptr::null_mut(),
1206             0,
1207         )
1208     })?;
1209     Ok(size as u64)
1210 }
1211
1212 #[allow(dead_code)]
1213 pub fn symlink_junction<P: AsRef<Path>, Q: AsRef<Path>>(
1214     original: P,
1215     junction: Q,
1216 ) -> io::Result<()> {
1217     symlink_junction_inner(original.as_ref(), junction.as_ref())
1218 }
1219
1220 // Creating a directory junction on windows involves dealing with reparse
1221 // points and the DeviceIoControl function, and this code is a skeleton of
1222 // what can be found here:
1223 //
1224 // http://www.flexhex.com/docs/articles/hard-links.phtml
1225 #[allow(dead_code)]
1226 fn symlink_junction_inner(original: &Path, junction: &Path) -> io::Result<()> {
1227     let d = DirBuilder::new();
1228     d.mkdir(&junction)?;
1229
1230     let mut opts = OpenOptions::new();
1231     opts.write(true);
1232     opts.custom_flags(c::FILE_FLAG_OPEN_REPARSE_POINT | c::FILE_FLAG_BACKUP_SEMANTICS);
1233     let f = File::open(junction, &opts)?;
1234     let h = f.as_inner().as_raw_handle();
1235
1236     unsafe {
1237         let mut data = [0u8; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
1238         let db = data.as_mut_ptr() as *mut c::REPARSE_MOUNTPOINT_DATA_BUFFER;
1239         let buf = &mut (*db).ReparseTarget as *mut c::WCHAR;
1240         let mut i = 0;
1241         // FIXME: this conversion is very hacky
1242         let v = br"\??\";
1243         let v = v.iter().map(|x| *x as u16);
1244         for c in v.chain(original.as_os_str().encode_wide()) {
1245             *buf.offset(i) = c;
1246             i += 1;
1247         }
1248         *buf.offset(i) = 0;
1249         i += 1;
1250         (*db).ReparseTag = c::IO_REPARSE_TAG_MOUNT_POINT;
1251         (*db).ReparseTargetMaximumLength = (i * 2) as c::WORD;
1252         (*db).ReparseTargetLength = ((i - 1) * 2) as c::WORD;
1253         (*db).ReparseDataLength = (*db).ReparseTargetLength as c::DWORD + 12;
1254
1255         let mut ret = 0;
1256         cvt(c::DeviceIoControl(
1257             h as *mut _,
1258             c::FSCTL_SET_REPARSE_POINT,
1259             data.as_ptr() as *mut _,
1260             (*db).ReparseDataLength + 8,
1261             ptr::null_mut(),
1262             0,
1263             &mut ret,
1264             ptr::null_mut(),
1265         ))
1266         .map(drop)
1267     }
1268 }
1269
1270 // Try to see if a file exists but, unlike `exists`, report I/O errors.
1271 pub fn try_exists(path: &Path) -> io::Result<bool> {
1272     // Open the file to ensure any symlinks are followed to their target.
1273     let mut opts = OpenOptions::new();
1274     // No read, write, etc access rights are needed.
1275     opts.access_mode(0);
1276     // Backup semantics enables opening directories as well as files.
1277     opts.custom_flags(c::FILE_FLAG_BACKUP_SEMANTICS);
1278     match File::open(path, &opts) {
1279         Err(e) => match e.kind() {
1280             // The file definitely does not exist
1281             io::ErrorKind::NotFound => Ok(false),
1282
1283             // `ERROR_SHARING_VIOLATION` means that the file has been locked by
1284             // another process. This is often temporary so we simply report it
1285             // as the file existing.
1286             _ if e.raw_os_error() == Some(c::ERROR_SHARING_VIOLATION as i32) => Ok(true),
1287
1288             // Other errors such as `ERROR_ACCESS_DENIED` may indicate that the
1289             // file exists. However, these types of errors are usually more
1290             // permanent so we report them here.
1291             _ => Err(e),
1292         },
1293         // The file was opened successfully therefore it must exist,
1294         Ok(_) => Ok(true),
1295     }
1296 }