9348700007
This commit is an implementation of [RFC 1044][rfc] which adds additional surface area to the `std::fs` module. All new APIs are `#[unstable]` behind assorted feature names for each one. [rfc]: https://github.com/rust-lang/rfcs/pull/1044 The new APIs added are: * `fs::canonicalize` - bindings to `realpath` on unix and `GetFinalPathNameByHandle` on windows. * `fs::symlink_metadata` - similar to `lstat` on unix * `fs::FileType` and accessor methods as `is_{file,dir,symlink}` * `fs::Metadata::file_type` - accessor for the raw file type * `fs::DirEntry::metadata` - acquisition of metadata which is free on Windows but requires a syscall on unix. * `fs::DirEntry::file_type` - access the file type which may not require a syscall on most platforms. * `fs::DirEntry::file_name` - access just the file name without leading components. * `fs::PathExt::symlink_metadata` - convenience method for the top-level function. * `fs::PathExt::canonicalize` - convenience method for the top-level function. * `fs::PathExt::read_link` - convenience method for the top-level function. * `fs::PathExt::read_dir` - convenience method for the top-level function. * `std::os::raw` - type definitions for raw OS/C types available on all platforms. * `std::os::$platform` - new modules have been added for all currently supported platforms (e.g. those more specific than just `unix`). * `std::os::$platform::raw` - platform-specific type definitions. These modules are populated with the bare essentials necessary for lowing I/O types into their raw representations, and currently largely consist of the `stat` definition for unix platforms. This commit also deprecates `Metadata::{modified, accessed}` in favor of inspecting the raw representations via the lowering methods of `Metadata`.
109 lines
4.0 KiB
Rust
109 lines
4.0 KiB
Rust
// Copyright 2015 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 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! Unix-specific extensions to general I/O primitives
|
|
|
|
#![stable(feature = "rust1", since = "1.0.0")]
|
|
|
|
use fs;
|
|
use net;
|
|
use os::raw;
|
|
use sys;
|
|
use sys_common::{net2, AsInner, FromInner};
|
|
|
|
/// Raw file descriptors.
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
pub type RawFd = raw::c_int;
|
|
|
|
/// A trait to extract the raw unix file descriptor from an underlying
|
|
/// object.
|
|
///
|
|
/// This is only available on unix platforms and must be imported in order
|
|
/// to call the method. Windows platforms have a corresponding `AsRawHandle`
|
|
/// and `AsRawSocket` set of traits.
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
pub trait AsRawFd {
|
|
/// Extracts the raw file descriptor.
|
|
///
|
|
/// This method does **not** pass ownership of the raw file descriptor
|
|
/// to the caller. The descriptor is only guarantee to be valid while
|
|
/// the original object has not yet been destroyed.
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
fn as_raw_fd(&self) -> RawFd;
|
|
}
|
|
|
|
/// A trait to express the ability to construct an object from a raw file
|
|
/// descriptor.
|
|
#[unstable(feature = "from_raw_os",
|
|
reason = "recent addition to std::os::unix::io")]
|
|
pub trait FromRawFd {
|
|
/// Constructs a new instances of `Self` from the given raw file
|
|
/// descriptor.
|
|
///
|
|
/// This function **consumes ownership** of the specified file
|
|
/// descriptor. The returned object will take responsibility for closing
|
|
/// it when the object goes out of scope.
|
|
///
|
|
/// This function is also unsafe as the primitives currently returned
|
|
/// have the contract that they are the sole owner of the file
|
|
/// descriptor they are wrapping. Usage of this function could
|
|
/// accidentally allow violating this contract which can cause memory
|
|
/// unsafety in code that relies on it being true.
|
|
unsafe fn from_raw_fd(fd: RawFd) -> Self;
|
|
}
|
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
impl AsRawFd for fs::File {
|
|
fn as_raw_fd(&self) -> RawFd {
|
|
self.as_inner().fd().raw()
|
|
}
|
|
}
|
|
#[unstable(feature = "from_raw_os", reason = "trait is unstable")]
|
|
impl FromRawFd for fs::File {
|
|
unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
|
|
fs::File::from_inner(sys::fs2::File::from_inner(fd))
|
|
}
|
|
}
|
|
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
impl AsRawFd for net::TcpStream {
|
|
fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() }
|
|
}
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
impl AsRawFd for net::TcpListener {
|
|
fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() }
|
|
}
|
|
#[stable(feature = "rust1", since = "1.0.0")]
|
|
impl AsRawFd for net::UdpSocket {
|
|
fn as_raw_fd(&self) -> RawFd { *self.as_inner().socket().as_inner() }
|
|
}
|
|
|
|
#[unstable(feature = "from_raw_os", reason = "trait is unstable")]
|
|
impl FromRawFd for net::TcpStream {
|
|
unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
|
|
let socket = sys::net::Socket::from_inner(fd);
|
|
net::TcpStream::from_inner(net2::TcpStream::from_inner(socket))
|
|
}
|
|
}
|
|
#[unstable(feature = "from_raw_os", reason = "trait is unstable")]
|
|
impl FromRawFd for net::TcpListener {
|
|
unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
|
|
let socket = sys::net::Socket::from_inner(fd);
|
|
net::TcpListener::from_inner(net2::TcpListener::from_inner(socket))
|
|
}
|
|
}
|
|
#[unstable(feature = "from_raw_os", reason = "trait is unstable")]
|
|
impl FromRawFd for net::UdpSocket {
|
|
unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
|
|
let socket = sys::net::Socket::from_inner(fd);
|
|
net::UdpSocket::from_inner(net2::UdpSocket::from_inner(socket))
|
|
}
|
|
}
|