From 6bfbad937bdf578e35777d079f8dcfab49758041 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Mon, 2 Feb 2015 21:39:14 -0800 Subject: std: Add a new `fs` module This commit is an implementation of [RFC 739][rfc] which adds a new `std::fs` module to the standard library. This module provides much of the same functionality as `std::old_io::fs` but it has many tweaked APIs as well as uses the new `std::path` module. [rfc]: https://github.com/rust-lang/rfcs/pull/739 --- src/libstd/sys/windows/ext.rs | 61 +++++- src/libstd/sys/windows/fs2.rs | 428 +++++++++++++++++++++++++++++++++++++++ src/libstd/sys/windows/handle.rs | 1 + src/libstd/sys/windows/mod.rs | 40 +++- src/libstd/sys/windows/os.rs | 2 +- 5 files changed, 525 insertions(+), 7 deletions(-) create mode 100644 src/libstd/sys/windows/fs2.rs (limited to 'src/libstd/sys/windows') diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index a3bbf5c5fe7..dc874c2c791 100644 --- a/src/libstd/sys/windows/ext.rs +++ b/src/libstd/sys/windows/ext.rs @@ -18,10 +18,11 @@ pub use sys_common::wtf8::{Wtf8Buf, EncodeWide}; -use sys::os_str::Buf; -use sys_common::{AsInner, FromInner}; use ffi::{OsStr, OsString}; +use fs::{self, OpenOptions}; use libc; +use sys::os_str::Buf; +use sys_common::{AsInner, FromInner, AsInnerMut}; use old_io; @@ -43,6 +44,12 @@ impl AsRawHandle for old_io::fs::File { } } +impl AsRawHandle for fs::File { + fn as_raw_handle(&self) -> Handle { + self.as_inner().handle().raw() + } +} + impl AsRawHandle for old_io::pipe::PipeStream { fn as_raw_handle(&self) -> Handle { self.as_inner().handle() @@ -122,9 +129,57 @@ impl OsStrExt for OsStr { } } +// Windows-specific extensions to `OpenOptions` +pub trait OpenOptionsExt { + /// Override the `dwDesiredAccess` argument to the call to `CreateFile` with + /// the specified value. + fn desired_access(&mut self, access: i32) -> &mut Self; + + /// Override the `dwCreationDisposition` argument to the call to + /// `CreateFile` with the specified value. + /// + /// This will override any values of the standard `create` flags, for + /// example. + fn creation_disposition(&mut self, val: i32) -> &mut Self; + + /// Override the `dwFlagsAndAttributes` argument to the call to + /// `CreateFile` with the specified value. + /// + /// This will override any values of the standard flags on the `OpenOptions` + /// structure. + fn flags_and_attributes(&mut self, val: i32) -> &mut Self; + + /// Override the `dwShareMode` argument to the call to `CreateFile` with the + /// specified value. + /// + /// This will override any values of the standard flags on the `OpenOptions` + /// structure. + fn share_mode(&mut self, val: i32) -> &mut Self; +} + +impl OpenOptionsExt for OpenOptions { + fn desired_access(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().desired_access(access); self + } + fn creation_disposition(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().creation_disposition(access); self + } + fn flags_and_attributes(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().flags_and_attributes(access); self + } + fn share_mode(&mut self, access: i32) -> &mut OpenOptions { + self.as_inner_mut().share_mode(access); self + } +} + /// A prelude for conveniently writing platform-specific code. /// /// Includes all extension traits, and some important type definitions. pub mod prelude { - pub use super::{Socket, Handle, AsRawSocket, AsRawHandle, OsStrExt, OsStringExt}; + #[doc(no_inline)] + pub use super::{Socket, Handle, AsRawSocket, AsRawHandle}; + #[doc(no_inline)] + pub use super::{OsStrExt, OsStringExt}; + #[doc(no_inline)] + pub use super::OpenOptionsExt; } diff --git a/src/libstd/sys/windows/fs2.rs b/src/libstd/sys/windows/fs2.rs new file mode 100644 index 00000000000..74bb509789b --- /dev/null +++ b/src/libstd/sys/windows/fs2.rs @@ -0,0 +1,428 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use core::prelude::*; +use io::prelude::*; +use os::windows::prelude::*; + +use default::Default; +use ffi::{OsString, AsOsStr}; +use io::{self, Error, SeekFrom}; +use libc::{self, HANDLE}; +use mem; +use path::{Path, PathBuf}; +use ptr; +use sys::handle::Handle as RawHandle; +use sys::{c, cvt}; +use vec::Vec; + +pub struct File { handle: RawHandle } +pub struct FileAttr { data: c::WIN32_FILE_ATTRIBUTE_DATA } + +pub struct ReadDir { + handle: libc::HANDLE, + root: PathBuf, + first: Option, +} + +pub struct DirEntry { path: PathBuf } + +#[derive(Clone, Default)] +pub struct OpenOptions { + create: bool, + append: bool, + read: bool, + write: bool, + truncate: bool, + desired_access: Option, + share_mode: Option, + creation_disposition: Option, + flags_and_attributes: Option, +} + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct FilePermissions { attrs: libc::DWORD } + +impl Iterator for ReadDir { + type Item = io::Result; + fn next(&mut self) -> Option> { + if let Some(first) = self.first.take() { + if let Some(e) = DirEntry::new(&self.root, &first) { + return Some(Ok(e)); + } + } + unsafe { + let mut wfd = mem::zeroed(); + loop { + if libc::FindNextFileW(self.handle, &mut wfd) == 0 { + if libc::GetLastError() == + c::ERROR_NO_MORE_FILES as libc::DWORD { + return None + } else { + return Some(Err(Error::last_os_error())) + } + } + if let Some(e) = DirEntry::new(&self.root, &wfd) { + return Some(Ok(e)) + } + } + } + } +} + +impl Drop for ReadDir { + fn drop(&mut self) { + let r = unsafe { libc::FindClose(self.handle) }; + debug_assert!(r != 0); + } +} + +impl DirEntry { + fn new(root: &Path, wfd: &libc::WIN32_FIND_DATAW) -> Option { + match &wfd.cFileName[0..3] { + // check for '.' and '..' + [46, 0, ..] | + [46, 46, 0, ..] => return None, + _ => {} + } + + let filename = super::truncate_utf16_at_nul(&wfd.cFileName); + let filename: OsString = OsStringExt::from_wide(filename); + Some(DirEntry { path: root.join(&filename) }) + } + + pub fn path(&self) -> PathBuf { + self.path.clone() + } +} + +impl OpenOptions { + pub fn new() -> OpenOptions { Default::default() } + pub fn read(&mut self, read: bool) { self.read = read; } + pub fn write(&mut self, write: bool) { self.write = write; } + pub fn append(&mut self, append: bool) { self.append = append; } + pub fn create(&mut self, create: bool) { self.create = create; } + pub fn truncate(&mut self, truncate: bool) { self.truncate = truncate; } + pub fn creation_disposition(&mut self, val: i32) { + self.creation_disposition = Some(val as libc::DWORD); + } + pub fn flags_and_attributes(&mut self, val: i32) { + self.flags_and_attributes = Some(val as libc::DWORD); + } + pub fn desired_access(&mut self, val: i32) { + self.desired_access = Some(val as libc::DWORD); + } + pub fn share_mode(&mut self, val: i32) { + self.share_mode = Some(val as libc::DWORD); + } + + fn get_desired_access(&self) -> libc::DWORD { + self.desired_access.unwrap_or({ + let mut base = if self.read {libc::FILE_GENERIC_READ} else {0} | + if self.write {libc::FILE_GENERIC_WRITE} else {0}; + if self.append { + base &= !libc::FILE_WRITE_DATA; + base |= libc::FILE_APPEND_DATA; + } + base + }) + } + + fn get_share_mode(&self) -> libc::DWORD { + // libuv has a good comment about this, but the basic idea is that + // we try to emulate unix semantics by enabling all sharing by + // allowing things such as deleting a file while it's still open. + self.share_mode.unwrap_or(libc::FILE_SHARE_READ | + libc::FILE_SHARE_WRITE | + libc::FILE_SHARE_DELETE) + } + + fn get_creation_disposition(&self) -> libc::DWORD { + self.creation_disposition.unwrap_or({ + match (self.create, self.truncate) { + (true, true) => libc::CREATE_ALWAYS, + (true, false) => libc::OPEN_ALWAYS, + (false, false) => libc::OPEN_EXISTING, + (false, true) => { + if self.write && !self.append { + libc::CREATE_ALWAYS + } else { + libc::TRUNCATE_EXISTING + } + } + } + }) + } + + fn get_flags_and_attributes(&self) -> libc::DWORD { + self.flags_and_attributes.unwrap_or(libc::FILE_ATTRIBUTE_NORMAL) + } +} + +impl File { + pub fn open(path: &Path, opts: &OpenOptions) -> io::Result { + let path = to_utf16(path); + let handle = unsafe { + libc::CreateFileW(path.as_ptr(), + opts.get_desired_access(), + opts.get_share_mode(), + ptr::null_mut(), + opts.get_creation_disposition(), + opts.get_flags_and_attributes(), + ptr::null_mut()) + }; + if handle == libc::INVALID_HANDLE_VALUE { + Err(Error::last_os_error()) + } else { + Ok(File { handle: RawHandle::new(handle) }) + } + } + + pub fn fsync(&self) -> io::Result<()> { + try!(cvt(unsafe { libc::FlushFileBuffers(self.handle.raw()) })); + Ok(()) + } + + pub fn datasync(&self) -> io::Result<()> { self.fsync() } + + pub fn truncate(&self, size: u64) -> io::Result<()> { + let mut info = c::FILE_END_OF_FILE_INFO { + EndOfFile: size as libc::LARGE_INTEGER, + }; + let size = mem::size_of_val(&info); + try!(cvt(unsafe { + c::SetFileInformationByHandle(self.handle.raw(), + c::FileEndOfFileInfo, + &mut info as *mut _ as *mut _, + size as libc::DWORD) + })); + Ok(()) + } + + pub fn file_attr(&self) -> io::Result { + unsafe { + let mut info: c::BY_HANDLE_FILE_INFORMATION = mem::zeroed(); + try!(cvt(c::GetFileInformationByHandle(self.handle.raw(), + &mut info))); + Ok(FileAttr { + data: c::WIN32_FILE_ATTRIBUTE_DATA { + dwFileAttributes: info.dwFileAttributes, + ftCreationTime: info.ftCreationTime, + ftLastAccessTime: info.ftLastAccessTime, + ftLastWriteTime: info.ftLastWriteTime, + nFileSizeHigh: info.nFileSizeHigh, + nFileSizeLow: info.nFileSizeLow, + } + }) + } + } + + pub fn read(&self, buf: &mut [u8]) -> io::Result { + let mut read = 0; + try!(cvt(unsafe { + libc::ReadFile(self.handle.raw(), + buf.as_ptr() as libc::LPVOID, + buf.len() as libc::DWORD, + &mut read, + ptr::null_mut()) + })); + Ok(read as usize) + } + + pub fn write(&self, buf: &[u8]) -> io::Result { + let mut amt = 0; + try!(cvt(unsafe { + libc::WriteFile(self.handle.raw(), + buf.as_ptr() as libc::LPVOID, + buf.len() as libc::DWORD, + &mut amt, + ptr::null_mut()) + })); + Ok(amt as usize) + } + + pub fn flush(&self) -> io::Result<()> { Ok(()) } + + pub fn seek(&self, pos: SeekFrom) -> io::Result { + let (whence, pos) = match pos { + SeekFrom::Start(n) => (libc::FILE_BEGIN, n as i64), + SeekFrom::End(n) => (libc::FILE_END, n), + SeekFrom::Current(n) => (libc::FILE_CURRENT, n), + }; + let pos = pos as libc::LARGE_INTEGER; + let mut newpos = 0; + try!(cvt(unsafe { + libc::SetFilePointerEx(self.handle.raw(), pos, + &mut newpos, whence) + })); + Ok(newpos as u64) + } + + pub fn handle(&self) -> &RawHandle { &self.handle } +} + +pub fn to_utf16(s: &Path) -> Vec { + s.as_os_str().encode_wide().chain(Some(0).into_iter()).collect() +} + +impl FileAttr { + pub fn is_dir(&self) -> bool { + self.data.dwFileAttributes & c::FILE_ATTRIBUTE_DIRECTORY != 0 + } + pub fn is_file(&self) -> bool { + !self.is_dir() + } + pub fn size(&self) -> u64 { + ((self.data.nFileSizeHigh as u64) << 32) | (self.data.nFileSizeLow as u64) + } + pub fn perm(&self) -> FilePermissions { + FilePermissions { attrs: self.data.dwFileAttributes } + } + + pub fn accessed(&self) -> u64 { self.to_ms(&self.data.ftLastAccessTime) } + pub fn modified(&self) -> u64 { self.to_ms(&self.data.ftLastWriteTime) } + + fn to_ms(&self, ft: &libc::FILETIME) -> u64 { + // FILETIME is in 100ns intervals and there are 10000 intervals in a + // millisecond. + let bits = (ft.dwLowDateTime as u64) | ((ft.dwHighDateTime as u64) << 32); + bits / 10000 + } +} + +impl FilePermissions { + pub fn readonly(&self) -> bool { + self.attrs & c::FILE_ATTRIBUTE_READONLY != 0 + } + + pub fn set_readonly(&mut self, readonly: bool) { + if readonly { + self.attrs |= c::FILE_ATTRIBUTE_READONLY; + } else { + self.attrs &= !c::FILE_ATTRIBUTE_READONLY; + } + } +} + +pub fn mkdir(p: &Path) -> io::Result<()> { + let p = to_utf16(p); + try!(cvt(unsafe { + libc::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) + })); + Ok(()) +} + +pub fn readdir(p: &Path) -> io::Result { + let root = p.to_path_buf(); + let star = p.join("*"); + let path = to_utf16(&star); + + unsafe { + let mut wfd = mem::zeroed(); + let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd); + if find_handle != libc::INVALID_HANDLE_VALUE { + Ok(ReadDir { handle: find_handle, root: root, first: Some(wfd) }) + } else { + Err(Error::last_os_error()) + } + } +} + +pub fn unlink(p: &Path) -> io::Result<()> { + let p_utf16 = to_utf16(p); + try!(cvt(unsafe { libc::DeleteFileW(p_utf16.as_ptr()) })); + Ok(()) +} + +pub fn rename(old: &Path, new: &Path) -> io::Result<()> { + let old = to_utf16(old); + let new = to_utf16(new); + try!(cvt(unsafe { + libc::MoveFileExW(old.as_ptr(), new.as_ptr(), + libc::MOVEFILE_REPLACE_EXISTING) + })); + Ok(()) +} + +pub fn rmdir(p: &Path) -> io::Result<()> { + let p = to_utf16(p); + try!(cvt(unsafe { c::RemoveDirectoryW(p.as_ptr()) })); + Ok(()) +} + +pub fn readlink(p: &Path) -> io::Result { + use sys::c::compat::kernel32::GetFinalPathNameByHandleW; + let mut opts = OpenOptions::new(); + opts.read(true); + let file = try!(File::open(p, &opts));; + + // Specify (sz - 1) because the documentation states that it's the size + // without the null pointer + // + // FIXME: I have a feeling that this reads intermediate symlinks as well. + let ret: OsString = try!(super::fill_utf16_buf_new(|buf, sz| unsafe { + GetFinalPathNameByHandleW(file.handle.raw(), + buf as *const u16, + sz - 1, + libc::VOLUME_NAME_DOS) + }, |s| OsStringExt::from_wide(s))); + Ok(PathBuf::new(&ret)) +} + +pub fn symlink(src: &Path, dst: &Path) -> io::Result<()> { + use sys::c::compat::kernel32::CreateSymbolicLinkW; + let src = to_utf16(src); + let dst = to_utf16(dst); + try!(cvt(unsafe { + CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), 0) as libc::BOOL + })); + Ok(()) +} + +pub fn link(src: &Path, dst: &Path) -> io::Result<()> { + let src = to_utf16(src); + let dst = to_utf16(dst); + try!(cvt(unsafe { + libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut()) + })); + Ok(()) +} + +pub fn stat(p: &Path) -> io::Result { + let p = to_utf16(p); + unsafe { + let mut attr: FileAttr = mem::zeroed(); + try!(cvt(c::GetFileAttributesExW(p.as_ptr(), + c::GetFileExInfoStandard, + &mut attr.data as *mut _ as *mut _))); + Ok(attr) + } +} + +pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { + let p = to_utf16(p); + unsafe { + try!(cvt(c::SetFileAttributesW(p.as_ptr(), perm.attrs))); + Ok(()) + } +} + +pub fn utimes(p: &Path, atime: u64, mtime: u64) -> io::Result<()> { + let atime = super::ms_to_filetime(atime); + let mtime = super::ms_to_filetime(mtime); + + let mut o = OpenOptions::new(); + o.write(true); + let f = try!(File::open(p, &o)); + try!(cvt(unsafe { + c::SetFileTime(f.handle.raw(), 0 as *const _, &atime, &mtime) + })); + Ok(()) +} diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index 6737eeef125..52aa5fb036a 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -21,6 +21,7 @@ impl Handle { pub fn new(handle: HANDLE) -> Handle { Handle(handle) } + pub fn raw(&self) -> HANDLE { self.0 } } impl Drop for Handle { diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index f1af70e2cf7..140bdb14501 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -15,10 +15,11 @@ use prelude::v1::*; use ffi::OsStr; -use io::ErrorKind; +use io::{self, ErrorKind}; use libc; use mem; use old_io::{self, IoResult, IoError}; +use num::Int; use os::windows::OsStrExt; use sync::{Once, ONCE_INIT}; @@ -38,6 +39,7 @@ pub mod c; pub mod condvar; pub mod ext; pub mod fs; +pub mod fs2; pub mod handle; pub mod helper_signal; pub mod mutex; @@ -248,7 +250,7 @@ fn to_utf16_os(s: &OsStr) -> Vec { // Once the syscall has completed (errors bail out early) the second closure is // yielded the data which has been read from the syscall. The return value // from this closure is then the return value of the function. -fn fill_utf16_buf(mut f1: F1, f2: F2) -> IoResult +fn fill_utf16_buf_base(mut f1: F1, f2: F2) -> Result where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD, F2: FnOnce(&[u16]) -> T { @@ -280,7 +282,7 @@ fn fill_utf16_buf(mut f1: F1, f2: F2) -> IoResult c::SetLastError(0); let k = match f1(buf.as_mut_ptr(), n as libc::DWORD) { 0 if libc::GetLastError() == 0 => 0, - 0 => return Err(IoError::last_error()), + 0 => return Err(()), n => n, } as usize; if k == n && libc::GetLastError() == @@ -295,6 +297,20 @@ fn fill_utf16_buf(mut f1: F1, f2: F2) -> IoResult } } +fn fill_utf16_buf(f1: F1, f2: F2) -> IoResult + where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD, + F2: FnOnce(&[u16]) -> T +{ + fill_utf16_buf_base(f1, f2).map_err(|()| IoError::last_error()) +} + +fn fill_utf16_buf_new(f1: F1, f2: F2) -> io::Result + where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD, + F2: FnOnce(&[u16]) -> T +{ + fill_utf16_buf_base(f1, f2).map_err(|()| io::Error::last_os_error()) +} + fn os2path(s: &[u16]) -> Path { // FIXME: this should not be a panicking conversion (aka path reform) Path::new(String::from_utf16(s).unwrap()) @@ -307,3 +323,21 @@ pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { None => v } } + +fn cvt(i: I) -> io::Result { + if i == Int::zero() { + Err(io::Error::last_os_error()) + } else { + Ok(i) + } +} + +fn ms_to_filetime(ms: u64) -> libc::FILETIME { + // A FILETIME is a count of 100 nanosecond intervals, so we multiply by + // 10000 b/c there are 10000 intervals in 1 ms + let ms = ms * 10000; + libc::FILETIME { + dwLowDateTime: ms as u32, + dwHighDateTime: (ms >> 32) as u32, + } +} diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index c71e2d057c3..36c12deacaa 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -191,7 +191,7 @@ impl<'a> Iterator for SplitPaths<'a> { } } -#[derive(Show)] +#[derive(Debug)] pub struct JoinPathsError; pub fn join_paths(paths: I) -> Result -- cgit 1.4.1-3-g733a5