Ronald Kinard
8 years ago
committed by
GitHub
14 changed files with 6875 additions and 236 deletions
@ -1,30 +1,32 @@
@@ -1,30 +1,32 @@
|
||||
{ |
||||
"data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", |
||||
"llvm-target": "arm-none-eabihf", |
||||
"linker": "arm-none-eabi-g++", |
||||
"linker": "arm-none-eabi-gcc", |
||||
"ar": "arm-none-eabi-ar", |
||||
"target-endian": "little", |
||||
"target-pointer-width": "32", |
||||
"arch": "arm", |
||||
"os": "none", |
||||
"os": "linux", |
||||
"cpu": "mpcore", |
||||
"features": "+vfp2", |
||||
"relocation-model": "static", |
||||
"linker-is-gnu": true, |
||||
"has-rpath": true, |
||||
"morestack": false, |
||||
"disable-redzone": true, |
||||
"executables": true, |
||||
"dynamic-linking": false, |
||||
"no-compiler-rt": true, |
||||
"exe-suffix": ".elf", |
||||
"is-like-windows": true, |
||||
"function-sections": false, |
||||
"pre-link-args": [ |
||||
"-specs", |
||||
"3dsx.specs", |
||||
"-specs=3dsx.specs", |
||||
"-march=armv6k", |
||||
"-mtune=mpcore", |
||||
"-mfloat-abi=hard" |
||||
"-mfloat-abi=hard", |
||||
"-mtp=soft" |
||||
], |
||||
"post-link-args": [ |
||||
"-lc", |
||||
"-lm", |
||||
"-lsysbase", |
||||
"-lc", |
||||
"-lgcc", |
||||
"-lc" |
||||
] |
||||
} |
||||
|
||||
@ -0,0 +1,3 @@
@@ -0,0 +1,3 @@
|
||||
pub use self::os_str::{OsString, OsStr}; |
||||
|
||||
mod os_str; |
||||
@ -0,0 +1,576 @@
@@ -0,0 +1,576 @@
|
||||
// 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.
|
||||
|
||||
use collections::borrow::{Borrow, Cow, ToOwned}; |
||||
use core::fmt::{self, Debug}; |
||||
use core::mem; |
||||
use collections::String; |
||||
use core::ops; |
||||
use core::cmp; |
||||
use core::hash::{Hash, Hasher}; |
||||
use collections::Vec; |
||||
|
||||
use sys::wtf8::{Wtf8, Wtf8Buf}; |
||||
use sys::{AsInner, IntoInner, FromInner}; |
||||
|
||||
pub use sys::wtf8::EncodeWide; |
||||
|
||||
/// A type that can represent owned, mutable platform-native strings, but is
|
||||
/// cheaply inter-convertible with Rust strings.
|
||||
///
|
||||
/// The need for this type arises from the fact that:
|
||||
///
|
||||
/// * On Unix systems, strings are often arbitrary sequences of non-zero
|
||||
/// bytes, in many cases interpreted as UTF-8.
|
||||
///
|
||||
/// * On Windows, strings are often arbitrary sequences of non-zero 16-bit
|
||||
/// values, interpreted as UTF-16 when it is valid to do so.
|
||||
///
|
||||
/// * In Rust, strings are always valid UTF-8, but may contain zeros.
|
||||
///
|
||||
/// `OsString` and `OsStr` bridge this gap by simultaneously representing Rust
|
||||
/// and platform-native string values, and in particular allowing a Rust string
|
||||
/// to be converted into an "OS" string with no cost.
|
||||
#[derive(Clone)] |
||||
pub struct OsString { |
||||
inner: Wtf8Buf
|
||||
} |
||||
|
||||
/// Slices into OS strings (see `OsString`).
|
||||
pub struct OsStr { |
||||
inner: Wtf8 |
||||
} |
||||
|
||||
impl OsString { |
||||
/// Constructs a new empty `OsString`.
|
||||
pub fn new() -> OsString { |
||||
OsString { inner: Wtf8Buf::from_string(String::new()) } |
||||
} |
||||
|
||||
fn _from_bytes(vec: Vec<u8>) -> Option<OsString> { |
||||
String::from_utf8(vec).ok().map(OsString::from) |
||||
} |
||||
|
||||
/// Converts to an `OsStr` slice.
|
||||
pub fn as_os_str(&self) -> &OsStr { |
||||
self |
||||
} |
||||
|
||||
/// Converts the `OsString` into a `String` if it contains valid Unicode data.
|
||||
///
|
||||
/// On failure, ownership of the original `OsString` is returned.
|
||||
pub fn into_string(self) -> Result<String, OsString> { |
||||
self.inner.into_string().map_err(|buf| OsString { inner: buf} ) |
||||
} |
||||
|
||||
/// Extends the string with the given `&OsStr` slice.
|
||||
pub fn push<T: AsRef<OsStr>>(&mut self, s: T) { |
||||
self.inner.push_wtf8(&s.as_ref().inner) |
||||
} |
||||
|
||||
/// Creates a new `OsString` with the given capacity.
|
||||
///
|
||||
/// The string will be able to hold exactly `capacity` lenth units of other
|
||||
/// OS strings without reallocating. If `capacity` is 0, the string will not
|
||||
/// allocate.
|
||||
///
|
||||
/// See main `OsString` documentation information about encoding.
|
||||
pub fn with_capacity(capacity: usize) -> OsString { |
||||
OsString { |
||||
inner: Wtf8Buf::with_capacity(capacity) |
||||
} |
||||
} |
||||
|
||||
/// Truncates the `OsString` to zero length.
|
||||
pub fn clear(&mut self) { |
||||
self.inner.clear() |
||||
} |
||||
|
||||
/// Returns the capacity this `OsString` can hold without reallocating.
|
||||
///
|
||||
/// See `OsString` introduction for information about encoding.
|
||||
pub fn capacity(&self) -> usize { |
||||
self.inner.capacity() |
||||
} |
||||
|
||||
/// Reserves capacity for at least `additional` more capacity to be inserted
|
||||
/// in the given `OsString`.
|
||||
///
|
||||
/// The collection may reserve more space to avoid frequent reallocations.
|
||||
pub fn reserve(&mut self, additional: usize) { |
||||
self.inner.reserve(additional) |
||||
} |
||||
|
||||
/// Reserves the minimum capacity for exactly `additional` more capacity to
|
||||
/// be inserted in the given `OsString`. Does nothing if the capacity is
|
||||
/// already sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer reserve if future insertions are expected.
|
||||
pub fn reserve_exact(&mut self, additional: usize) { |
||||
self.inner.reserve_exact(additional) |
||||
} |
||||
|
||||
/// Creates an `OsString` from a potentially ill-formed UTF-16 slice of
|
||||
/// 16-bit code units.
|
||||
///
|
||||
/// This is lossless: calling `.encode_wide()` on the resulting string
|
||||
/// will always return the original code units.
|
||||
///
|
||||
/// NOTE: This function was copied from the windows implementation of OsStringExt
|
||||
pub fn from_wide(wide: &[u16]) -> OsString { |
||||
OsString { inner: Wtf8Buf::from_wide(wide) } |
||||
} |
||||
} |
||||
|
||||
impl From<String> for OsString { |
||||
fn from(s: String) -> OsString { |
||||
OsString { inner: Wtf8Buf::from_string(s) } |
||||
} |
||||
} |
||||
|
||||
impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString { |
||||
fn from(s: &'a T) -> OsString { |
||||
s.as_ref().to_os_string() |
||||
} |
||||
} |
||||
|
||||
impl ops::Index<ops::RangeFull> for OsString { |
||||
type Output = OsStr; |
||||
|
||||
#[inline] |
||||
fn index(&self, _index: ops::RangeFull) -> &OsStr { |
||||
OsStr::from_inner(self.inner.as_slice()) |
||||
} |
||||
} |
||||
|
||||
impl ops::Deref for OsString { |
||||
type Target = OsStr; |
||||
|
||||
#[inline] |
||||
fn deref(&self) -> &OsStr { |
||||
&self[..] |
||||
} |
||||
} |
||||
|
||||
impl Default for OsString { |
||||
#[inline] |
||||
fn default() -> OsString { |
||||
OsString::new() |
||||
} |
||||
} |
||||
|
||||
impl Debug for OsString { |
||||
fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { |
||||
fmt::Debug::fmt(&**self, formatter) |
||||
} |
||||
} |
||||
|
||||
impl PartialEq for OsString { |
||||
fn eq(&self, other: &OsString) -> bool { |
||||
&**self == &**other |
||||
} |
||||
} |
||||
|
||||
impl PartialEq<str> for OsString { |
||||
fn eq(&self, other: &str) -> bool { |
||||
&**self == other |
||||
} |
||||
} |
||||
|
||||
impl PartialEq<OsString> for str { |
||||
fn eq(&self, other: &OsString) -> bool { |
||||
&**other == self |
||||
} |
||||
} |
||||
|
||||
impl Eq for OsString {} |
||||
|
||||
impl PartialOrd for OsString { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &OsString) -> Option<cmp::Ordering> { |
||||
(&**self).partial_cmp(&**other) |
||||
} |
||||
#[inline] |
||||
fn lt(&self, other: &OsString) -> bool { &**self < &**other } |
||||
#[inline] |
||||
fn le(&self, other: &OsString) -> bool { &**self <= &**other } |
||||
#[inline] |
||||
fn gt(&self, other: &OsString) -> bool { &**self > &**other } |
||||
#[inline] |
||||
fn ge(&self, other: &OsString) -> bool { &**self >= &**other } |
||||
} |
||||
|
||||
impl PartialOrd<str> for OsString { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { |
||||
(&**self).partial_cmp(other) |
||||
} |
||||
} |
||||
|
||||
impl Ord for OsString { |
||||
#[inline] |
||||
fn cmp(&self, other: &OsString) -> cmp::Ordering { |
||||
(&**self).cmp(&**other) |
||||
} |
||||
} |
||||
|
||||
impl Hash for OsString { |
||||
#[inline] |
||||
fn hash<H: Hasher>(&self, state: &mut H) { |
||||
(&**self).hash(state) |
||||
} |
||||
} |
||||
|
||||
impl OsStr { |
||||
/// Coerces into an `OsStr` slice.
|
||||
pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr { |
||||
s.as_ref() |
||||
} |
||||
|
||||
fn from_inner(inner: &Wtf8) -> &OsStr { |
||||
unsafe { mem::transmute(inner) } |
||||
} |
||||
|
||||
/// Yields a `&str` slice if the `OsStr` is valid Unicode.
|
||||
///
|
||||
/// This conversion may entail doing a check for UTF-8 validity.
|
||||
pub fn to_str(&self) -> Option<&str> { |
||||
self.inner.as_str() |
||||
} |
||||
|
||||
/// Converts an `OsStr` to a `Cow<str>`.
|
||||
///
|
||||
/// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
|
||||
pub fn to_string_lossy(&self) -> Cow<str> { |
||||
self.inner.to_string_lossy() |
||||
} |
||||
|
||||
/// Copies the slice into an owned `OsString`.
|
||||
pub fn to_os_string(&self) -> OsString { |
||||
let mut buf = Wtf8Buf::with_capacity(self.inner.len()); |
||||
buf.push_wtf8(&self.inner); |
||||
OsString { inner: buf } |
||||
} |
||||
|
||||
/// Checks whether the `OsStr` is empty.
|
||||
pub fn is_empty(&self) -> bool { |
||||
self.inner.is_empty() |
||||
} |
||||
|
||||
/// Returns the length of this `OsStr`.
|
||||
///
|
||||
/// Note that this does **not** return the number of bytes in this string
|
||||
/// as, for example, OS strings on Windows are encoded as a list of `u16`
|
||||
/// rather than a list of bytes. This number is simply useful for passing to
|
||||
/// other methods like `OsString::with_capacity` to avoid reallocations.
|
||||
///
|
||||
/// See `OsStr` introduction for more information about encoding.
|
||||
pub fn len(&self) -> usize { |
||||
self.inner.len() |
||||
} |
||||
|
||||
/// Gets the underlying byte representation.
|
||||
///
|
||||
/// Note: it is *crucial* that this API is private, to avoid
|
||||
/// revealing the internal, platform-specific encodings.
|
||||
fn bytes(&self) -> &[u8] { |
||||
unsafe { mem::transmute(&self.inner) } |
||||
} |
||||
|
||||
/// Re-encodes an `OsStr` as a wide character sequence,
|
||||
/// i.e. potentially ill-formed UTF-16.
|
||||
/// This is lossless. Note that the encoding does not include a final
|
||||
/// null.
|
||||
///
|
||||
/// NOTE: This function was copied from the windows implementation of OsStrExt
|
||||
pub fn encode_wide(&self) -> EncodeWide { |
||||
self.inner.encode_wide() |
||||
} |
||||
|
||||
} |
||||
|
||||
impl<'a> Default for &'a OsStr { |
||||
#[inline] |
||||
fn default() -> &'a OsStr { |
||||
OsStr::new("") |
||||
} |
||||
} |
||||
|
||||
impl PartialEq for OsStr { |
||||
fn eq(&self, other: &OsStr) -> bool { |
||||
self.bytes().eq(other.bytes()) |
||||
} |
||||
} |
||||
|
||||
impl PartialEq<str> for OsStr { |
||||
fn eq(&self, other: &str) -> bool { |
||||
*self == *OsStr::new(other) |
||||
} |
||||
} |
||||
|
||||
impl PartialEq<OsStr> for str { |
||||
fn eq(&self, other: &OsStr) -> bool { |
||||
*other == *OsStr::new(self) |
||||
} |
||||
} |
||||
|
||||
impl Eq for OsStr {} |
||||
|
||||
impl PartialOrd for OsStr { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &OsStr) -> Option<cmp::Ordering> { |
||||
self.bytes().partial_cmp(other.bytes()) |
||||
} |
||||
#[inline] |
||||
fn lt(&self, other: &OsStr) -> bool { self.bytes().lt(other.bytes()) } |
||||
#[inline] |
||||
fn le(&self, other: &OsStr) -> bool { self.bytes().le(other.bytes()) } |
||||
#[inline] |
||||
fn gt(&self, other: &OsStr) -> bool { self.bytes().gt(other.bytes()) } |
||||
#[inline] |
||||
fn ge(&self, other: &OsStr) -> bool { self.bytes().ge(other.bytes()) } |
||||
} |
||||
|
||||
impl PartialOrd<str> for OsStr { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { |
||||
self.partial_cmp(OsStr::new(other)) |
||||
} |
||||
} |
||||
|
||||
// FIXME (#19470): cannot provide PartialOrd<OsStr> for str until we
|
||||
// have more flexible coherence rules.
|
||||
|
||||
impl Ord for OsStr { |
||||
#[inline] |
||||
fn cmp(&self, other: &OsStr) -> cmp::Ordering { self.bytes().cmp(other.bytes()) } |
||||
} |
||||
|
||||
macro_rules! impl_cmp { |
||||
($lhs:ty, $rhs: ty) => { |
||||
impl<'a, 'b> PartialEq<$rhs> for $lhs { |
||||
#[inline] |
||||
fn eq(&self, other: &$rhs) -> bool { <OsStr as PartialEq>::eq(self, other) } |
||||
} |
||||
|
||||
impl<'a, 'b> PartialEq<$lhs> for $rhs { |
||||
#[inline] |
||||
fn eq(&self, other: &$lhs) -> bool { <OsStr as PartialEq>::eq(self, other) } |
||||
} |
||||
|
||||
impl<'a, 'b> PartialOrd<$rhs> for $lhs { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> { |
||||
<OsStr as PartialOrd>::partial_cmp(self, other) |
||||
} |
||||
} |
||||
|
||||
impl<'a, 'b> PartialOrd<$lhs> for $rhs { |
||||
#[inline] |
||||
fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> { |
||||
<OsStr as PartialOrd>::partial_cmp(self, other) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl_cmp!(OsString, OsStr); |
||||
impl_cmp!(OsString, &'a OsStr); |
||||
impl_cmp!(Cow<'a, OsStr>, OsStr); |
||||
impl_cmp!(Cow<'a, OsStr>, &'b OsStr); |
||||
impl_cmp!(Cow<'a, OsStr>, OsString); |
||||
|
||||
impl Hash for OsStr { |
||||
#[inline] |
||||
fn hash<H: Hasher>(&self, state: &mut H) { |
||||
self.bytes().hash(state) |
||||
} |
||||
} |
||||
|
||||
impl Debug for OsStr { |
||||
fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { |
||||
self.inner.fmt(formatter) |
||||
} |
||||
} |
||||
|
||||
impl Borrow<OsStr> for OsString { |
||||
fn borrow(&self) -> &OsStr { &self[..] } |
||||
} |
||||
|
||||
impl ToOwned for OsStr { |
||||
type Owned = OsString; |
||||
fn to_owned(&self) -> OsString { self.to_os_string() } |
||||
} |
||||
|
||||
impl AsRef<OsStr> for OsStr { |
||||
fn as_ref(&self) -> &OsStr { |
||||
self |
||||
} |
||||
} |
||||
|
||||
impl AsRef<OsStr> for OsString { |
||||
fn as_ref(&self) -> &OsStr { |
||||
self |
||||
} |
||||
} |
||||
|
||||
impl AsRef<OsStr> for str { |
||||
fn as_ref(&self) -> &OsStr { |
||||
OsStr::from_inner(Wtf8::from_str(self)) |
||||
} |
||||
} |
||||
|
||||
impl AsRef<OsStr> for String { |
||||
fn as_ref(&self) -> &OsStr { |
||||
(&**self).as_ref() |
||||
} |
||||
} |
||||
|
||||
impl FromInner<Wtf8Buf> for OsString { |
||||
fn from_inner(buf: Wtf8Buf) -> OsString { |
||||
OsString { inner: buf } |
||||
} |
||||
} |
||||
|
||||
impl IntoInner<Wtf8Buf> for OsString { |
||||
fn into_inner(self) -> Wtf8Buf { |
||||
self.inner |
||||
} |
||||
} |
||||
|
||||
impl AsInner<Wtf8> for OsStr { |
||||
fn as_inner(&self) -> &Wtf8 { |
||||
&self.inner |
||||
} |
||||
} |
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use super::*; |
||||
use sys::{AsInner, IntoInner}; |
||||
|
||||
#[test] |
||||
fn test_os_string_with_capacity() { |
||||
let os_string = OsString::with_capacity(0); |
||||
assert_eq!(0, os_string.inner.capacity()); |
||||
|
||||
let os_string = OsString::with_capacity(10); |
||||
assert_eq!(10, os_string.inner.capacity()); |
||||
|
||||
let mut os_string = OsString::with_capacity(0); |
||||
os_string.push("abc"); |
||||
assert!(os_string.inner.capacity() >= 3); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_string_clear() { |
||||
let mut os_string = OsString::from("abc"); |
||||
assert_eq!(3, os_string.inner.len()); |
||||
|
||||
os_string.clear(); |
||||
assert_eq!(&os_string, ""); |
||||
assert_eq!(0, os_string.inner.len()); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_string_capacity() { |
||||
let os_string = OsString::with_capacity(0); |
||||
assert_eq!(0, os_string.capacity()); |
||||
|
||||
let os_string = OsString::with_capacity(10); |
||||
assert_eq!(10, os_string.capacity()); |
||||
|
||||
let mut os_string = OsString::with_capacity(0); |
||||
os_string.push("abc"); |
||||
assert!(os_string.capacity() >= 3); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_string_reserve() { |
||||
let mut os_string = OsString::new(); |
||||
assert_eq!(os_string.capacity(), 0); |
||||
|
||||
os_string.reserve(2); |
||||
assert!(os_string.capacity() >= 2); |
||||
|
||||
for _ in 0..16 { |
||||
os_string.push("a"); |
||||
} |
||||
|
||||
assert!(os_string.capacity() >= 16); |
||||
os_string.reserve(16); |
||||
assert!(os_string.capacity() >= 32); |
||||
|
||||
os_string.push("a"); |
||||
|
||||
os_string.reserve(16); |
||||
assert!(os_string.capacity() >= 33) |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_string_reserve_exact() { |
||||
let mut os_string = OsString::new(); |
||||
assert_eq!(os_string.capacity(), 0); |
||||
|
||||
os_string.reserve_exact(2); |
||||
assert!(os_string.capacity() >= 2); |
||||
|
||||
for _ in 0..16 { |
||||
os_string.push("a"); |
||||
} |
||||
|
||||
assert!(os_string.capacity() >= 16); |
||||
os_string.reserve_exact(16); |
||||
assert!(os_string.capacity() >= 32); |
||||
|
||||
os_string.push("a"); |
||||
|
||||
os_string.reserve_exact(16); |
||||
assert!(os_string.capacity() >= 33) |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_string_default() { |
||||
let os_string: OsString = Default::default(); |
||||
assert_eq!("", &os_string); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_str_is_empty() { |
||||
let mut os_string = OsString::new(); |
||||
assert!(os_string.is_empty()); |
||||
|
||||
os_string.push("abc"); |
||||
assert!(!os_string.is_empty()); |
||||
|
||||
os_string.clear(); |
||||
assert!(os_string.is_empty()); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_str_len() { |
||||
let mut os_string = OsString::new(); |
||||
assert_eq!(0, os_string.len()); |
||||
|
||||
os_string.push("abc"); |
||||
assert_eq!(3, os_string.len()); |
||||
|
||||
os_string.clear(); |
||||
assert_eq!(0, os_string.len()); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_os_str_default() { |
||||
let os_str: &OsStr = Default::default(); |
||||
assert_eq!("", os_str); |
||||
} |
||||
} |
||||
@ -0,0 +1,892 @@
@@ -0,0 +1,892 @@
|
||||
//! Filesystem service
|
||||
//!
|
||||
//! This module contains basic methods to manipulate the contents of the 3DS's filesystem.
|
||||
//! Only the SD card is currently supported.
|
||||
|
||||
|
||||
use core::marker::PhantomData; |
||||
use core::ptr; |
||||
use core::slice; |
||||
use core::mem; |
||||
use alloc::arc::Arc; |
||||
use collections::Vec; |
||||
|
||||
use path::{Path, PathBuf}; |
||||
use ffi::OsString; |
||||
|
||||
use libctru::services::fs::*; |
||||
|
||||
#[derive(Copy, Clone, Debug)] |
||||
pub enum PathType { |
||||
Invalid, |
||||
Empty, |
||||
Binary, |
||||
ASCII, |
||||
UTF16, |
||||
} |
||||
|
||||
#[derive(Copy, Clone, Debug)] |
||||
pub enum ArchiveID { |
||||
RomFS, |
||||
Savedata, |
||||
Extdata, |
||||
SharedExtdata, |
||||
SystemSavedata, |
||||
Sdmc, |
||||
SdmcWriteOnly, |
||||
BossExtdata, |
||||
CardSpiFS, |
||||
ExtDataAndBossExtdata, |
||||
SystemSaveData2, |
||||
NandRW, |
||||
NandRO, |
||||
NandROWriteAccess, |
||||
SaveDataAndContent, |
||||
SaveDataAndContent2, |
||||
NandCtrFS, |
||||
TwlPhoto, |
||||
NandTwlFS, |
||||
GameCardSavedata, |
||||
UserSavedata, |
||||
DemoSavedata, |
||||
} |
||||
|
||||
/// Represents the filesystem service. No file IO can be performed
|
||||
/// until an instance of this struct is created.
|
||||
///
|
||||
/// The service exits when all instances of this struct go out of scope.
|
||||
pub struct Fs { |
||||
pd: PhantomData<i32>, |
||||
} |
||||
|
||||
/// Handle to an open filesystem archive.
|
||||
///
|
||||
/// Archives are automatically closed when they go out of scope.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// use ctru::services::fs::Fs
|
||||
///
|
||||
/// let fs = Fs::init().unwrap();
|
||||
/// let sdmc_archive = fs.sdmc().unwrap();
|
||||
/// ```
|
||||
pub struct Archive { |
||||
id: ArchiveID, |
||||
handle: u64, |
||||
} |
||||
|
||||
/// A reference to an open file on the filesystem.
|
||||
///
|
||||
/// An instance of a `File` can be read and/or written to depending
|
||||
/// on what options It was opened with.
|
||||
///
|
||||
/// Files are automatically closed when they go out of scope.
|
||||
pub struct File { |
||||
handle: u32, |
||||
offset: u64, |
||||
} |
||||
|
||||
/// Metadata information about a file.
|
||||
///
|
||||
/// This structure is returned from the [`metadata`] function and
|
||||
/// represents known metadata about a file.
|
||||
///
|
||||
/// [`metadata`]: fn.metadata.html
|
||||
pub struct Metadata { |
||||
attributes: u32, |
||||
size: u64, |
||||
} |
||||
|
||||
/// Options and flags which can be used to configure how a [`File`] is opened.
|
||||
/// This builder exposes the ability to configure how a `File` is opened
|
||||
/// and what operations are permitted on the open file. The [`File::open`]
|
||||
/// and [`File::create`] methods are aliases for commonly used options
|
||||
/// using this builder.
|
||||
///
|
||||
/// [`File`]: struct.File.html
|
||||
/// [`File::open`]: struct.File.html#method.open
|
||||
/// [`File::create`]: struct.File.html#method.create
|
||||
///
|
||||
/// Generally speaking, when using `OpenOptions`, you'll first call [`new()`],
|
||||
/// then chain calls to methods to set each option, then call [`open()`],
|
||||
/// passing the path of the file you're trying to open.
|
||||
///
|
||||
/// It is required to also pass a reference to the [`Archive`] that the
|
||||
/// file lives in.
|
||||
///
|
||||
/// [`new()`]: struct.OpenOptions.html#method.new
|
||||
/// [`open()`]: struct.OpenOptions.html#method.open
|
||||
/// [`Archive`]: struct.Archive.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Opening a file to read:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use ctru::services::fs::OpenOptions;
|
||||
///
|
||||
/// let fs = Fs::init().unwrap();
|
||||
/// let sdmc_archive = fs.sdmc().unwrap();
|
||||
/// let file = OpenOptions::new()
|
||||
/// .read(true)
|
||||
/// .archive(&sdmc_archive)
|
||||
/// .open("foo.txt")
|
||||
/// .unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// Opening a file for both reading and writing, as well as creating it if it
|
||||
/// doesn't exist:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use ctru::services::fs::OpenOptions;
|
||||
///
|
||||
/// let fs = Fs::init().unwrap();
|
||||
/// let sdmc_archive = fs.sdmc().unwrap();
|
||||
/// let file = OpenOptions::new()
|
||||
/// .read(true)
|
||||
/// .write(true)
|
||||
/// .create(true)
|
||||
/// .archive(&sdmc_archive)
|
||||
/// .open("foo.txt")
|
||||
/// .unwrap();
|
||||
/// ```
|
||||
#[derive(Clone)] |
||||
pub struct OpenOptions { |
||||
read: bool, |
||||
write: bool, |
||||
append: bool, |
||||
truncate: bool, |
||||
create: bool, |
||||
arch_handle: u64, |
||||
} |
||||
|
||||
/// Iterator over the entries in a directory.
|
||||
///
|
||||
/// This iterator is returned from the [`read_dir`] function of this module and
|
||||
/// will yield instances of `Result<DirEntry, i32>`. Through a [`DirEntry`]
|
||||
/// information like the entry's path and possibly other metadata can be
|
||||
/// learned.
|
||||
///
|
||||
/// [`read_dir`]: fn.read_dir.html
|
||||
/// [`DirEntry`]: struct.DirEntry.html
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This Result will return Err if there's some sort of intermittent IO error
|
||||
/// during iteration.
|
||||
pub struct ReadDir<'a> { |
||||
handle: Dir, |
||||
root: Arc<PathBuf>, |
||||
arch: &'a Archive, |
||||
} |
||||
|
||||
/// Entries returned by the [`ReadDir`] iterator.
|
||||
///
|
||||
/// [`ReadDir`]: struct.ReadDir.html
|
||||
///
|
||||
/// An instance of `DirEntry` represents an entry inside of a directory on the
|
||||
/// filesystem. Each entry can be inspected via methods to learn about the full
|
||||
/// path or possibly other metadata.
|
||||
pub struct DirEntry<'a> { |
||||
entry: FS_DirectoryEntry, |
||||
root: Arc<PathBuf>, |
||||
arch: &'a Archive, |
||||
} |
||||
|
||||
#[doc(hidden)] |
||||
struct Dir(u32); |
||||
|
||||
#[doc(hidden)] |
||||
unsafe impl Send for Dir {} |
||||
#[doc(hidden)] |
||||
unsafe impl Sync for Dir {} |
||||
|
||||
impl Fs { |
||||
/// Initializes the FS service.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return Err if there was an error initializing the
|
||||
/// FS service, which in practice should never happen unless there is
|
||||
/// an error in the execution environment (i.e. the homebrew launcher
|
||||
/// somehow fails to provide fs:USER permissions)
|
||||
///
|
||||
/// ctrulib services are reference counted, so this function may be called
|
||||
/// as many times as desired and the service will not exit until all
|
||||
/// instances of Fs drop out of scope.
|
||||
pub fn init() -> Result<Fs, i32> { |
||||
unsafe { |
||||
let r = fsInit(); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(Fs { pd: PhantomData }) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Returns a handle to the SDMC (memory card) Archive.
|
||||
pub fn sdmc(&self) -> Result<Archive, i32> { |
||||
unsafe { |
||||
let mut handle = 0; |
||||
let id = ArchiveID::Sdmc; |
||||
let path = fsMakePath(PathType::Empty.into(), ptr::null() as _); |
||||
let r = FSUSER_OpenArchive(&mut handle, id.into(), path); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(Archive { |
||||
handle: handle, |
||||
id: id, |
||||
}) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Archive { |
||||
/// Retrieves an Archive's [`ArchiveID`]
|
||||
///
|
||||
/// [`ArchiveID`]: enum.ArchiveID.html
|
||||
pub fn get_id(&self) -> ArchiveID { |
||||
self.id |
||||
} |
||||
} |
||||
|
||||
impl File { |
||||
/// Attempts to open a file in read-only mode.
|
||||
///
|
||||
/// See the [`OpenOptions::open`] method for more details.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if `path` does not already exit.
|
||||
/// Other errors may also be returned accoridng to [`OpenOptions::open`]
|
||||
///
|
||||
/// [`OpenOptions::open`]: struct.OpenOptions.html#method.open
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// use ctru::services::fs::{Fs, File};
|
||||
///
|
||||
/// let fs = Fs::init().unwrap()
|
||||
/// let sdmc_archive = fs.sdmc().unwrap()
|
||||
/// let mut f = File::open(&sdmc_archive, "/foo.txt").unwrap();
|
||||
/// ```
|
||||
pub fn open<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<File, i32> { |
||||
OpenOptions::new().read(true).archive(arch).open(path.as_ref()) |
||||
} |
||||
|
||||
/// Opens a file in write-only mode.
|
||||
///
|
||||
/// This function will create a file if it does not exist.
|
||||
///
|
||||
/// See the [`OpenOptions::create`] method for more details.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error if `path` does not already exit.
|
||||
/// Other errors may also be returned accoridng to [`OpenOptions::create`]
|
||||
///
|
||||
/// [`OpenOptions::create`]: struct.OpenOptions.html#method.create
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// use ctru::services::fs::{Fs, File};
|
||||
///
|
||||
/// let fs = Fs::init().unwrap()
|
||||
/// let sdmc_archive = fs.sdmc().unwrap()
|
||||
/// let mut f = File::create(&sdmc_archive, "/foo.txt").unwrap();
|
||||
/// ```
|
||||
pub fn create<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<File, i32> { |
||||
OpenOptions::new().write(true).create(true).archive(arch).open(path.as_ref()) |
||||
} |
||||
|
||||
/// Truncates or extends the underlying file, updating the size of this file to become size.
|
||||
///
|
||||
/// If the size is less than the current file's size, then the file will be shrunk. If it is
|
||||
/// greater than the current file's size, then the file will be extended to size and have all
|
||||
/// of the intermediate data filled in with 0s.
|
||||
pub fn set_len(&mut self, size: u64) -> Result<(), i32> { |
||||
unsafe { |
||||
let r = FSFILE_SetSize(self.handle, size); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Queries metadata about the underlying file.
|
||||
pub fn metadata(&self) -> Result<Metadata, i32> { |
||||
// The only metadata we have for files right now is file size.
|
||||
// This is likely to change in the future.
|
||||
unsafe { |
||||
let mut size = 0; |
||||
let r = FSFILE_GetSize(self.handle, &mut size); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(Metadata { attributes: 0, size: size }) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Pull some bytes from the file into the specified buffer, returning
|
||||
/// how many bytes were read.
|
||||
///
|
||||
/// This function will become private when std::io support is ported
|
||||
/// to this library.
|
||||
pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, i32> { |
||||
unsafe { |
||||
let mut n_read = 0; |
||||
let r = FSFILE_Read( |
||||
self.handle, |
||||
&mut n_read, |
||||
self.offset, |
||||
buf.as_mut_ptr() as _, |
||||
buf.len() as u32 |
||||
); |
||||
self.offset += n_read as u64; |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(n_read as usize) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Read all bytes until EOF in this source, placing them into buf.
|
||||
///
|
||||
/// This function will become private when std::io support is ported
|
||||
/// to this library.
|
||||
pub fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, i32> { |
||||
unsafe { |
||||
read_to_end_uninitialized(self, buf) |
||||
} |
||||
} |
||||
|
||||
/// Write a buffer into this object, returning how many bytes were written.
|
||||
///
|
||||
/// This function will become private when std::io support is ported
|
||||
/// to this library.
|
||||
pub fn write(&mut self, buf: &[u8]) -> Result<usize, i32> { |
||||
unsafe { |
||||
let mut n_written = 0; |
||||
let r = FSFILE_Write( |
||||
self.handle, |
||||
&mut n_written, |
||||
self.offset, |
||||
buf.as_ptr() as _, |
||||
buf.len() as u32, |
||||
FS_WRITE_UPDATE_TIME |
||||
); |
||||
self.offset += n_written as u64; |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(n_written as usize) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Metadata { |
||||
/// Returns whether this metadata is for a directory.
|
||||
pub fn is_dir(&self) -> bool { |
||||
self.attributes == self.attributes | FS_ATTRIBUTE_DIRECTORY |
||||
} |
||||
|
||||
/// Returns whether this metadata is for a regular file.
|
||||
pub fn is_file(&self) -> bool { |
||||
!self.is_dir() |
||||
} |
||||
|
||||
/// Returns the size, in bytes, this metadata is for.
|
||||
///
|
||||
/// Directories return size = 0.
|
||||
pub fn len(&self) -> u64 { |
||||
self.size |
||||
} |
||||
} |
||||
|
||||
impl OpenOptions { |
||||
/// Creates a blank set of options ready for configuration.
|
||||
///
|
||||
/// All options are initially set to `false`
|
||||
pub fn new() -> OpenOptions { |
||||
OpenOptions { |
||||
read: false, |
||||
write: false, |
||||
append: false, |
||||
truncate: false, |
||||
create: false, |
||||
arch_handle: 0, |
||||
} |
||||
} |
||||
|
||||
/// Sets the option for read access.
|
||||
///
|
||||
/// This option, when true, will indicate that the file should be
|
||||
/// `read`-able if opened.
|
||||
pub fn read(&mut self, read: bool) -> &mut OpenOptions { |
||||
self.read = read; |
||||
self |
||||
} |
||||
|
||||
/// Sets the option for write access.
|
||||
///
|
||||
/// This option, when true, will indicate that the file should be
|
||||
/// `write`-able if opened.
|
||||
///
|
||||
/// If the file already exists, any write calls on it will overwrite
|
||||
/// its contents, without truncating it.
|
||||
pub fn write(&mut self, write: bool) -> &mut OpenOptions { |
||||
self.write = write; |
||||
self |
||||
} |
||||
|
||||
/// Sets the option for the append mode.
|
||||
///
|
||||
/// This option, when true, means that writes will append to a file instead
|
||||
/// of overwriting previous contents. Note that setting .write(true).append(true)
|
||||
/// has the same effect as setting only .append(true).
|
||||
///
|
||||
/// If both truncate and append are set to true, the file will simply be truncated
|
||||
pub fn append(&mut self, append: bool) -> &mut OpenOptions { |
||||
self.append = append; |
||||
self |
||||
} |
||||
|
||||
/// Sets the option for truncating a previous file.
|
||||
///
|
||||
/// If a file is successfully opened with this option set it will truncate
|
||||
/// the file to 0 length if it already exists.
|
||||
///
|
||||
/// The file must be opened with write access for truncate to work.
|
||||
pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions { |
||||
self.truncate = truncate; |
||||
self |
||||
} |
||||
|
||||
/// Sets the option for creating a new file.
|
||||
///
|
||||
/// This option indicates whether a new file will be created
|
||||
/// if the file does not yet already
|
||||
/// exist.
|
||||
///
|
||||
/// In order for the file to be created, write access must also be used.
|
||||
pub fn create(&mut self, create: bool) -> &mut OpenOptions { |
||||
self.create = create; |
||||
self |
||||
} |
||||
|
||||
/// Sets which archive the file is to be opened in.
|
||||
///
|
||||
/// Failing to pass in an archive will result in the file failing to open.
|
||||
pub fn archive(&mut self, archive: &Archive) -> &mut OpenOptions { |
||||
self.arch_handle = archive.handle; |
||||
self |
||||
} |
||||
|
||||
/// Opens a file at `path` with the options specified by `self`
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error under a number of different
|
||||
/// circumstances, including but not limited to:
|
||||
///
|
||||
/// * Opening a file that doesn't exist without setting `create`.
|
||||
/// * Attempting to open a file without passing an [`Archive`] reference
|
||||
/// to the `archive` method.
|
||||
/// * Filesystem-level errors (full disk, etc).
|
||||
/// * Invalid combinations of open options.
|
||||
///
|
||||
/// [`Archive`]: struct.Archive.html
|
||||
pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<File, i32> { |
||||
self._open(path.as_ref(), self.get_open_flags()) |
||||
} |
||||
|
||||
fn _open(&self, path: &Path, flags: u32) -> Result<File, i32> { |
||||
unsafe { |
||||
let mut file_handle = 0; |
||||
let path = to_utf16(path); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_OpenFile(&mut file_handle, self.arch_handle, fs_path, flags, 0); |
||||
if r < 0 { |
||||
return Err(r); |
||||
} |
||||
|
||||
let mut file = File { handle: file_handle, offset: 0 }; |
||||
|
||||
if self.append { |
||||
let metadata = try!(file.metadata()); |
||||
file.offset = metadata.len(); |
||||
} |
||||
|
||||
// set the offset to 0 just in case both append and truncate were
|
||||
// set to true
|
||||
if self.truncate { |
||||
try!(file.set_len(0)); |
||||
file.offset = 0; |
||||
} |
||||
Ok(file) |
||||
} |
||||
} |
||||
|
||||
fn get_open_flags(&self) -> u32 { |
||||
match (self.read, self.write || self.append, self.create) { |
||||
(true, false, false) => FS_OPEN_READ, |
||||
(false, true, false) => FS_OPEN_WRITE, |
||||
(false, true, true) => FS_OPEN_WRITE | FS_OPEN_CREATE, |
||||
(true, false, true) => FS_OPEN_READ | FS_OPEN_CREATE, |
||||
(true, true, false) => FS_OPEN_READ | FS_OPEN_WRITE, |
||||
(true, true, true) => FS_OPEN_READ | FS_OPEN_WRITE | FS_OPEN_CREATE, |
||||
_ => 0, //failure case
|
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<'a> Iterator for ReadDir<'a> { |
||||
type Item = Result<DirEntry<'a>, i32>; |
||||
|
||||
fn next(&mut self) -> Option<Result<DirEntry<'a>, i32>> { |
||||
unsafe { |
||||
let mut ret = DirEntry { |
||||
entry: mem::zeroed(), |
||||
root: self.root.clone(), |
||||
arch: self.arch, |
||||
}; |
||||
let mut entries_read = 0; |
||||
let entry_count = 1; |
||||
let r = FSDIR_Read(self.handle.0, &mut entries_read, entry_count, &mut ret.entry); |
||||
|
||||
if r < 0 { |
||||
return Some(Err(r)) |
||||
} |
||||
if entries_read != entry_count { |
||||
return None |
||||
} |
||||
Some(Ok(ret)) |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<'a> DirEntry<'a> { |
||||
/// Returns the full path to the file that this entry represents.
|
||||
///
|
||||
/// The full path is created by joining the original path to `read_dir`
|
||||
/// with the filename of this entry.
|
||||
pub fn path(&self) -> PathBuf { |
||||
self.root.join(&self.file_name()) |
||||
} |
||||
|
||||
/// Return the metadata for the file that this entry points at.
|
||||
pub fn metadata(&self) -> Result<Metadata, i32> { |
||||
metadata(self.arch, self.path()) |
||||
} |
||||
|
||||
/// Returns the bare file name of this directory entry without any other leading path
|
||||
/// component.
|
||||
pub fn file_name(&self) -> OsString { |
||||
let filename = truncate_utf16_at_nul(&self.entry.name); |
||||
OsString::from_wide(filename) |
||||
} |
||||
} |
||||
|
||||
/// Creates a new, empty directory at the provided path
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error in the following situations,
|
||||
/// but is not limited to just these cases:
|
||||
///
|
||||
/// * User lacks permissions to create directory at `path`
|
||||
pub fn create_dir<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<(), i32> { |
||||
unsafe { |
||||
let path = to_utf16(path.as_ref()); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_CreateDirectory(arch.handle, fs_path, FS_ATTRIBUTE_DIRECTORY); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Recursively create a directory and all of its parent components if they are missing.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error in the following situations,
|
||||
/// but is not limited to just these cases:
|
||||
///
|
||||
/// * If any directory in the path specified by `path` does not already exist
|
||||
/// and it could not be created otherwise.
|
||||
pub fn create_dir_all<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<(), i32> { |
||||
let path = path.as_ref(); |
||||
let mut dir = PathBuf::new(); |
||||
let mut result = Ok(()); |
||||
|
||||
for component in path.components() { |
||||
let component = component.as_os_str(); |
||||
dir.push(component); |
||||
result = create_dir(arch, &dir); |
||||
} |
||||
result |
||||
} |
||||
|
||||
/// Given a path, query the file system to get information about a file, directory, etc
|
||||
pub fn metadata<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<Metadata, i32> { |
||||
let maybe_file = File::open(&arch, path.as_ref()); |
||||
let maybe_dir = read_dir(&arch, path.as_ref()); |
||||
match (maybe_file, maybe_dir) { |
||||
(Ok(file), _) => file.metadata(), |
||||
(_, Ok(_dir)) => Ok(Metadata { attributes: FS_ATTRIBUTE_DIRECTORY, size: 0 }), |
||||
(Err(r), _) => Err(r), |
||||
} |
||||
} |
||||
|
||||
/// Removes an existing, empty directory.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error in the following situations, but is not limited to just
|
||||
/// these cases:
|
||||
///
|
||||
/// * The user lacks permissions to remove the directory at the provided path.
|
||||
/// * The directory isn't empty.
|
||||
pub fn remove_dir<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<(), i32> { |
||||
unsafe { |
||||
let path = to_utf16(path.as_ref()); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_DeleteDirectory(arch.handle, fs_path); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Removes a directory at this path, after removing all its contents. Use carefully!
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// see `file::remove_file` and `fs::remove_dir`
|
||||
pub fn remove_dir_all<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<(), i32> { |
||||
unsafe { |
||||
let path = to_utf16(path.as_ref()); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_DeleteDirectoryRecursively(arch.handle, fs_path); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Returns an iterator over the entries within a directory.
|
||||
///
|
||||
/// The iterator will yield instances of Result<DirEntry, i32>. New errors
|
||||
/// may be encountered after an iterator is initially constructed.
|
||||
///
|
||||
/// This function will return an error in the following situations, but is not limited to just
|
||||
/// these cases:
|
||||
///
|
||||
/// * The provided path doesn't exist.
|
||||
/// * The process lacks permissions to view the contents.
|
||||
/// * The path points at a non-directory file.
|
||||
pub fn read_dir<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<ReadDir, i32> { |
||||
unsafe { |
||||
let mut handle = 0; |
||||
let root = Arc::new(path.as_ref().to_path_buf()); |
||||
let path = to_utf16(path.as_ref()); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_OpenDirectory(&mut handle, arch.handle, fs_path); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(ReadDir { handle: Dir(handle), root: root, arch: arch}) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Removes a file from the filesystem.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error in the following situations, but is not limited to just
|
||||
/// these cases:
|
||||
///
|
||||
/// * path points to a directory.
|
||||
/// * The user lacks permissions to remove the file.
|
||||
pub fn remove_file<P: AsRef<Path>>(arch: &Archive, path: P) -> Result<(), i32> { |
||||
unsafe { |
||||
let path = to_utf16(path.as_ref()); |
||||
let fs_path = fsMakePath(PathType::UTF16.into(), path.as_ptr() as _); |
||||
let r = FSUSER_DeleteFile(arch.handle, fs_path); |
||||
if r < 0 { |
||||
Err(r) |
||||
} else { |
||||
Ok(()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// Rename a file or directory to a new name, replacing the original file
|
||||
/// if to already exists.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return an error in the following situations, but is not limited to just
|
||||
/// these cases:
|
||||
///
|
||||
/// * from does not exist.
|
||||
/// * The user lacks permissions to view contents.
|
||||
pub fn rename<P, Q>(arch: &Archive, from: P, to: Q) -> Result<(), i32> |
||||
where P: AsRef<Path>, |
||||
Q: AsRef<Path> { |
||||
|
||||
unsafe { |
||||
let from = to_utf16(from.as_ref()); |
||||
let to = to_utf16(to.as_ref()); |
||||
|
||||
let fs_from = fsMakePath(PathType::UTF16.into(), from.as_ptr() as _); |
||||
let fs_to = fsMakePath(PathType::UTF16.into(), to.as_ptr() as _); |
||||
|
||||
let r = FSUSER_RenameFile(arch.handle, fs_from, arch.handle, fs_to); |
||||
if r == 0 { |
||||
return Ok(()) |
||||
} |
||||
let r = FSUSER_RenameDirectory(arch.handle, fs_from, arch.handle, fs_to); |
||||
if r == 0 { |
||||
return Ok(()) |
||||
} |
||||
Err((r)) |
||||
} |
||||
} |
||||
|
||||
// TODO: Determine if we should check UTF-16 paths for interior NULs
|
||||
fn to_utf16(path: &Path) -> Vec<u16> { |
||||
path.as_os_str().encode_wide().collect::<Vec<_>>() |
||||
} |
||||
|
||||
// Adapted from sys/windows/fs.rs in libstd
|
||||
fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] { |
||||
match v.iter().position(|c| *c == 0) { |
||||
// don't include the 0
|
||||
Some(i) => &v[..i], |
||||
None => v |
||||
} |
||||
} |
||||
|
||||
// Adapted from sys/common/io.rs in libstd
|
||||
unsafe fn read_to_end_uninitialized(f: &mut File, buf: &mut Vec<u8>) -> Result<usize, i32> { |
||||
let start_len = buf.len(); |
||||
buf.reserve(16); |
||||
|
||||
// Always try to read into the empty space of the vector (from the length to the capacity).
|
||||
// If the vector ever fills up then we reserve an extra byte which should trigger the normal
|
||||
// reallocation routines for the vector, which will likely double the size.
|
||||
//
|
||||
// This function is similar to the read_to_end function in std::io, but the logic about
|
||||
// reservations and slicing is different enough that this is duplicated here.
|
||||
loop { |
||||
if buf.len() == buf.capacity() { |
||||
buf.reserve(1); |
||||
} |
||||
|
||||
let buf_slice = slice::from_raw_parts_mut(buf.as_mut_ptr().offset(buf.len() as isize), |
||||
buf.capacity() - buf.len()); |
||||
|
||||
match f.read(buf_slice) { |
||||
Ok(0) => { return Ok(buf.len() - start_len); } |
||||
Ok(n) => { let len = buf.len() + n; buf.set_len(len); }, |
||||
Err(e) => { return Err(e); } |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Drop for Fs { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
fsExit(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Drop for Archive { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
FSUSER_CloseArchive(self.handle); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Drop for File { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
FSFILE_Close(self.handle); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Drop for Dir { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
FSDIR_Close(self.0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl From<PathType> for FS_PathType { |
||||
fn from(p: PathType) -> Self { |
||||
use self::PathType::*; |
||||
use libctru::services::fs::FS_PathType::*; |
||||
match p { |
||||
Invalid => PATH_INVALID, |
||||
Empty => PATH_EMPTY, |
||||
Binary => PATH_BINARY, |
||||
ASCII => PATH_ASCII, |
||||
UTF16 => PATH_UTF16, |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl From<ArchiveID> for FS_ArchiveID { |
||||
fn from(a: ArchiveID) -> Self { |
||||
use self::ArchiveID::*; |
||||
use libctru::services::fs::FS_ArchiveID::*; |
||||
match a { |
||||
RomFS => ARCHIVE_ROMFS, |
||||
Savedata => ARCHIVE_SAVEDATA, |
||||
Extdata => ARCHIVE_EXTDATA, |
||||
SharedExtdata => ARCHIVE_SHARED_EXTDATA, |
||||
SystemSavedata => ARCHIVE_SYSTEM_SAVEDATA, |
||||
Sdmc => ARCHIVE_SDMC, |
||||
SdmcWriteOnly => ARCHIVE_SDMC_WRITE_ONLY, |
||||
BossExtdata => ARCHIVE_BOSS_EXTDATA, |
||||
CardSpiFS => ARCHIVE_CARD_SPIFS, |
||||
ExtDataAndBossExtdata => ARCHIVE_EXTDATA_AND_BOSS_EXTDATA,
|
||||
SystemSaveData2 => ARCHIVE_SYSTEM_SAVEDATA2, |
||||
NandRW => ARCHIVE_NAND_RW, |
||||
NandRO => ARCHIVE_NAND_RO, |
||||
NandROWriteAccess => ARCHIVE_NAND_RO_WRITE_ACCESS, |
||||
SaveDataAndContent => ARCHIVE_SAVEDATA_AND_CONTENT, |
||||
SaveDataAndContent2 => ARCHIVE_SAVEDATA_AND_CONTENT2, |
||||
NandCtrFS => ARCHIVE_NAND_CTR_FS, |
||||
TwlPhoto => ARCHIVE_TWL_PHOTO, |
||||
NandTwlFS => ARCHIVE_NAND_TWL_FS, |
||||
GameCardSavedata => ARCHIVE_GAMECARD_SAVEDATA, |
||||
UserSavedata => ARCHIVE_USER_SAVEDATA, |
||||
DemoSavedata => ARCHIVE_DEMO_SAVEDATA, |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,25 @@
@@ -0,0 +1,25 @@
|
||||
/// A trait for viewing representations from std types
|
||||
#[doc(hidden)] |
||||
pub trait AsInner<Inner: ?Sized> { |
||||
fn as_inner(&self) -> &Inner; |
||||
} |
||||
|
||||
/// A trait for viewing representations from std types
|
||||
#[doc(hidden)] |
||||
pub trait AsInnerMut<Inner: ?Sized> { |
||||
fn as_inner_mut(&mut self) -> &mut Inner; |
||||
} |
||||
|
||||
/// A trait for extracting representations from std types
|
||||
#[doc(hidden)] |
||||
pub trait IntoInner<Inner> { |
||||
fn into_inner(self) -> Inner; |
||||
} |
||||
|
||||
/// A trait for creating std types from internal representations
|
||||
#[doc(hidden)] |
||||
pub trait FromInner<Inner> { |
||||
fn from_inner(inner: Inner) -> Self; |
||||
} |
||||
|
||||
pub mod wtf8; |
||||
Loading…
Reference in new issue