pub(super) fn process_path(self, path: impl Into<PathBuf>, vm: &VirtualMachine) -> PyResult {

fn inner(mode: OutputMode, path: PathBuf, vm: &VirtualMachine) -> PyResult {

let path_as_string = |p: PathBuf| {

p.into_os_string().into_string().map_err(|_| {

vm.new_unicode_decode_error(

"Can't convert OS path to valid UTF-8 string".into(),

)

})

};

match mode {

OutputMode::String => path_as_string(path).map(|s| vm.ctx.new_str(s).into()),

OutputMode::Bytes => {

#[cfg(any(unix, target_os = "wasi"))]

{

use rustpython_common::os::ffi::OsStringExt;

Ok(vm.ctx.new_bytes(path.into_os_string().into_vec()).into())

}

#[cfg(windows)]

{

path_as_string(path).map(|s| vm.ctx.new_bytes(s.into_bytes()).into())

}

}

}

}

inner(self, path.into(), vm)

}

pub fn new_str(path: impl Into<ffi::OsString>) -> Self {

let path = path.into();

Self {

path,

mode: OutputMode::String,

}

}

pub(crate) fn from_fspath(fspath: FsPath, vm: &VirtualMachine) -> PyResult<OsPath> {

let path = fspath.as_os_str(vm)?.to_owned();

let mode = match fspath {

FsPath::Str(_) => OutputMode::String,

FsPath::Bytes(_) => OutputMode::Bytes,

};

Ok(OsPath { path, mode })

}

pub fn as_path(&self) -> &Path {

Path::new(&self.path)

}

#[cfg(any(unix, target_os = "wasi"))]

pub fn into_bytes(self) -> Vec<u8> {

use rustpython_common::os::ffi::OsStrExt;

self.path.as_bytes().to_vec()

}

#[cfg(windows)]

pub fn into_bytes(self) -> Vec<u8> {

self.path.to_string_lossy().to_string().into_bytes()

}

pub fn into_cstring(self, vm: &VirtualMachine) -> PyResult<ffi::CString> {

ffi::CString::new(self.into_bytes()).map_err(|err| err.into_pyexception(vm))

}

#[cfg(windows)]

pub fn to_widecstring(&self, vm: &VirtualMachine) -> PyResult<widestring::WideCString> {

widestring::WideCString::from_os_str(&self.path).map_err(|err| err.into_pyexception(vm))

}

pub fn filename(&self, vm: &VirtualMachine) -> PyResult {

self.mode.process_path(self.path.clone(), vm)

}

path: P,

follow_symlink: bool,

) -> io::Result<fs::Metadata> {

if follow_symlink {

fs::metadata(path.as_ref())

} else {

fs::symlink_metadata(path.as_ref())

}

fn as_ref(&self) -> &Path {

self.as_path()

}

// TODO: path_converter with allow_fd=0 in CPython

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

let fspath = FsPath::try_from(obj, true, vm)?;

Self::from_fspath(fspath, vm)

}

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {

let r = match obj.try_index_opt(vm) {

Some(int) => Self::Fd(int?.try_to_primitive(vm)?),

None => Self::Path(obj.try_into_value(vm)?),

};

Ok(r)

}

fn from(path: OsPath) -> Self {

Self::Path(path)

}

pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {

match self {

OsPathOrFd::Path(path) => path.filename(vm).unwrap_or_else(|_| vm.ctx.none()),

OsPathOrFd::Fd(fd) => vm.ctx.new_int(*fd).into(),

}

}

error: io::Error,

filename: Option<OsPathOrFd>,

filename2: Option<OsPathOrFd>,

pub fn new(error: io::Error) -> Self {

Self {

error,

filename: None,

filename2: None,

}

}

pub(crate) fn filename(mut self, filename: impl Into<OsPathOrFd>) -> Self {

let filename = filename.into();

self.filename.replace(filename);

self

}

pub(crate) fn filename2(mut self, filename: impl Into<OsPathOrFd>) -> Self {

let filename = filename.into();

self.filename2.replace(filename);

self

}

fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {

let excp = self.error.into_pyexception(vm);

if let Some(filename) = self.filename {

excp.as_object()

.set_attr("filename", filename.filename(vm), vm)

.unwrap();

}

if let Some(filename2) = self.filename2 {

excp.as_object()

.set_attr("filename2", filename2.filename(vm), vm)

.unwrap();

}

excp

}

fn default() -> Self {

Self([DEFAULT_DIR_FD; AVAILABLE])

}

#[inline(always)]

pub(crate) fn fd_opt(&self) -> Option<Fd> {

self.get_opt().map(Fd)

}

#[inline]

pub(crate) fn get_opt(&self) -> Option<i32> {

let fd = self.fd();

if fd == DEFAULT_DIR_FD {

None

} else {

Some(fd.0)

}

}

#[inline(always)]

pub(crate) fn fd(&self) -> Fd {

self.0[0]

}

fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {

let fd = match args.take_keyword("dir_fd") {

Some(o) if vm.is_none(&o) => DEFAULT_DIR_FD,

None => DEFAULT_DIR_FD,

Some(o) => {

let fd = o.try_index_opt(vm).unwrap_or_else(|| {

Err(vm.new_type_error(format!(

"argument should be integer or None, not {}",

o.class().name()

)))

})?;

let fd = fd.try_to_primitive(vm)?;

Fd(fd)

}

};

if AVAILABLE == 0 && fd != DEFAULT_DIR_FD {

return Err(vm

.new_not_implemented_error("dir_fd unavailable on this platform".to_owned())

.into());

}

Ok(Self([fd; AVAILABLE]))

}

use super::{

errno_err, DirFd, FollowSymlinks, IOErrorBuilder, OsPath, OsPathOrFd, OutputMode,

SupportFunc,

};

use crate::{

builtins::{

PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,

},

common::crt_fd::{Fd, Offset},

common::lock::{OnceCell, PyRwLock},

common::suppress_iph,

convert::{IntoPyException, ToPyObject},

function::{ArgBytesLike, Either, FsPath, FuncArgs, OptionalArg},

protocol::PyIterReturn,

recursion::ReprGuard,

types::{IterNext, IterNextIterable, PyStructSequence, Representable},

vm::VirtualMachine,

AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,

};

use crossbeam_utils::atomic::AtomicCell;

use itertools::Itertools;

use std::{

env, ffi, fs,

fs::OpenOptions,

io::{self, Read, Write},

path::PathBuf,

time::{Duration, SystemTime},

};

const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));

pub(crate) const MKDIR_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));

const STAT_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));

const UTIME_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));

pub(crate) const SYMLINK_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));

#[pyattr]

use libc::{

O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END,

SEEK_SET,

};

#[pyattr]

pub(crate) const F_OK: u8 = 0;

#[pyattr]

pub(crate) const R_OK: u8 = 1 << 2;

#[pyattr]

pub(crate) const W_OK: u8 = 1 << 1;

#[pyattr]

pub(crate) const X_OK: u8 = 1 << 0;

#[pyfunction]

fn close(fileno: i32, vm: &VirtualMachine) -> PyResult<()> {

Fd(fileno).close().map_err(|e| e.into_pyexception(vm))

}

#[pyfunction]

fn closerange(fd_low: i32, fd_high: i32) {

for fileno in fd_low..fd_high {

let _ = Fd(fileno).close();

}

}

#[cfg(any(unix, windows, target_os = "wasi"))]

#[derive(FromArgs)]

struct OpenArgs {

path: OsPath,

flags: i32,

#[pyarg(any, default)]

mode: Option<i32>,

#[pyarg(flatten)]

dir_fd: DirFd<{ OPEN_DIR_FD as usize }>,

}

#[pyfunction]

fn open(args: OpenArgs, vm: &VirtualMachine) -> PyResult<i32> {

os_open(args.path, args.flags, args.mode, args.dir_fd, vm)

}

#[cfg(any(unix, windows, target_os = "wasi"))]

pub(crate) fn os_open(

name: OsPath,

flags: i32,

mode: Option<i32>,

dir_fd: DirFd<{ OPEN_DIR_FD as usize }>,

vm: &VirtualMachine,

) -> PyResult<i32> {

let mode = mode.unwrap_or(0o777);

#[cfg(windows)]

let fd = {

let [] = dir_fd.0;

let name = name.to_widecstring(vm)?;

let flags = flags | libc::O_NOINHERIT;

Fd::wopen(&name, flags, mode)

};

#[cfg(not(windows))]

let fd = {

let name = name.clone().into_cstring(vm)?;

#[cfg(not(target_os = "wasi"))]

let flags = flags | libc::O_CLOEXEC;

#[cfg(not(target_os = "redox"))]

if let Some(dir_fd) = dir_fd.fd_opt() {

dir_fd.openat(&name, flags, mode)

} else {

Fd::open(&name, flags, mode)

}

#[cfg(target_os = "redox")]

{

let [] = dir_fd.0;

Fd::open(&name, flags, mode)

}

};

fd.map(|fd| fd.0)

.map_err(|e| IOErrorBuilder::new(e).filename(name).into_pyexception(vm))

}

#[pyfunction]

fn fsync(fd: i32, vm: &VirtualMachine) -> PyResult<()> {

Fd(fd).fsync().map_err(|err| err.into_pyexception(vm))

}

#[pyfunction]

fn read(fd: i32, n: usize, vm: &VirtualMachine) -> PyResult<PyBytesRef> {

let mut buffer = vec![0u8; n];

let mut file = Fd(fd);

let n = file

.read(&mut buffer)

.map_err(|err| err.into_pyexception(vm))?;

buffer.truncate(n);

Ok(vm.ctx.new_bytes(buffer))

}

#[pyfunction]

fn write(fd: i32, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult {

let mut file = Fd(fd);

let written = data

.with_ref(|b| file.write(b))

.map_err(|err| err.into_pyexception(vm))?;

Ok(vm.ctx.new_int(written).into())

}

#[pyfunction]

#[pyfunction(name = "unlink")]

fn remove(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult<()> {

let [] = dir_fd.0;

let is_junction = cfg!(windows)

&& fs::metadata(&path).map_or(false, |meta| meta.file_type().is_dir())

&& fs::symlink_metadata(&path).map_or(false, |meta| meta.file_type().is_symlink());

let res = if is_junction {

fs::remove_dir(&path)

} else {

fs::remove_file(&path)

};

res.map_err(|e| IOErrorBuilder::new(e).filename(path).into_pyexception(vm))

}

#[cfg(not(windows))]

#[pyfunction]

fn mkdir(

path: OsPath,

mode: OptionalArg<i32>,

dir_fd: DirFd<{ MKDIR_DIR_FD as usize }>,

vm: &VirtualMachine,

) -> PyResult<()> {

let mode = mode.unwrap_or(0o777);

let path = path.into_cstring(vm)?;

#[cfg(not(target_os = "redox"))]

if let Some(fd) = dir_fd.get_opt() {

let res = unsafe { libc::mkdirat(fd, path.as_ptr(), mode as _) };

let res = if res < 0 { Err(errno_err(vm)) } else { Ok(()) };

return res;

}

#[cfg(target_os = "redox")]

let [] = dir_fd.0;

let res = unsafe { libc::mkdir(path.as_ptr(), mode as _) };

if res < 0 {

Err(errno_err(vm))

} else {

Ok(())

}

}

#[pyfunction]

fn mkdirs(path: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {

fs::create_dir_all(path.as_str()).map_err(|err| err.into_pyexception(vm))

}

#[pyfunction]

fn rmdir(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult<()> {

let [] = dir_fd.0;

fs::remove_dir(&path)

.map_err(|e| IOErrorBuilder::new(e).filename(path).into_pyexception(vm))

}

const LISTDIR_FD: bool = cfg!(all(unix, not(target_os = "redox")));

#[pyfunction]

fn listdir(path: OptionalArg<OsPathOrFd>, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {

let path = path.unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));

let list = match path {

OsPathOrFd::Path(path) => {

let dir_iter = fs::read_dir(&path).map_err(|err| err.into_pyexception(vm))?;

dir_iter

.map(|entry| match entry {

Ok(entry_path) => path.mode.process_path(entry_path.file_name(), vm),

Err(e) => Err(IOErrorBuilder::new(e)

.filename(path.clone())

.into_pyexception(vm)),

})

.collect::<PyResult<_>>()?

}

OsPathOrFd::Fd(fno) => {

#[cfg(not(all(unix, not(target_os = "redox"))))]

{

let _ = fno;

return Err(vm.new_not_implemented_error(

"can't pass fd to listdir on this platform".to_owned(),

));

}

#[cfg(all(unix, not(target_os = "redox")))]

{

use rustpython_common::os::ffi::OsStrExt;

let new_fd = nix::unistd::dup(fno).map_err(|e| e.into_pyexception(vm))?;

let mut dir =

nix::dir::Dir::from_fd(new_fd).map_err(|e| e.into_pyexception(vm))?;

dir.iter()

.filter_map(|entry| {

entry

.map_err(|e| e.into_pyexception(vm))

.and_then(|entry| {

let fname = entry.file_name().to_bytes();

Ok(match fname {

b"." | b".." => None,

_ => Some(

OutputMode::String

.process_path(ffi::OsStr::from_bytes(fname), vm)?,

),

})

})

.transpose()

})

.collect::<PyResult<_>>()?

}

}

};

Ok(list)

}

fn pyref_as_str<'a>(

obj: &'a Either<PyStrRef, PyBytesRef>,

vm: &VirtualMachine,

) -> PyResult<&'a str> {

Ok(match obj {

Either::A(ref s) => s.as_str(),

Either::B(ref b) => super::bytes_as_osstr(b.as_bytes(), vm)?

.to_str()

.ok_or_else(|| {

vm.new_unicode_decode_error("can't decode bytes for utf-8".to_owned())

})?,

})

}

#[pyfunction]

fn putenv(

key: Either<PyStrRef, PyBytesRef>,

value: Either<PyStrRef, PyBytesRef>,

vm: &VirtualMachine,

) -> PyResult<()> {

let key = pyref_as_str(&key, vm)?;

let value = pyref_as_str(&value, vm)?;

if key.contains('\0') || value.contains('\0') {

return Err(vm.new_value_error("embedded null byte".to_string()));

}

if key.is_empty() || key.contains('=') {

return Err(vm.new_value_error("illegal environment variable name".to_string()));

}

env::set_var(key, value);

Ok(())

}

#[pyfunction]

fn unsetenv(key: Either<PyStrRef, PyBytesRef>, vm: &VirtualMachine) -> PyResult<()> {

let key = pyref_as_str(&key, vm)?;

if key.contains('\0') {

return Err(vm.new_value_error("embedded null byte".to_string()));

}

if key.is_empty() || key.contains('=') {

return Err(vm.new_value_error("illegal environment variable name".to_string()));

}

env::remove_var(key);

Ok(())

}

#[pyfunction]

fn readlink(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult {

let mode = path.mode;

let [] = dir_fd.0;

let path = fs::read_link(&path)

.map_err(|err| IOErrorBuilder::new(err).filename(path).into_pyexception(vm))?;

mode.process_path(path, vm)

}

#[pyattr]

#[pyclass(name)]

#[derive(Debug, PyPayload)]

struct DirEntry {

file_name: std::ffi::OsString,

pathval: PathBuf,

file_type: io::Result<fs::FileType>,

mode: OutputMode,

stat: OnceCell<PyObjectRef>,

lstat: OnceCell<PyObjectRef>,

#[cfg(unix)]

ino: AtomicCell<u64>,

#[cfg(not(unix))]

ino: AtomicCell<Option<u64>>,

}

#[pyclass(with(Representable))]

impl DirEntry {

#[pygetset]

fn name(&self, vm: &VirtualMachine) -> PyResult {

self.mode.process_path(&self.file_name, vm)

}

#[pygetset]

fn path(&self, vm: &VirtualMachine) -> PyResult {

self.mode.process_path(&self.pathval, vm)

}

fn perform_on_metadata(

&self,

follow_symlinks: FollowSymlinks,

action: fn(fs::Metadata) -> bool,

vm: &VirtualMachine,

) -> PyResult<bool> {

match super::fs_metadata(&self.pathval, follow_symlinks.0) {

Ok(meta) => Ok(action(meta)),

Err(e) => {

// FileNotFoundError is caught and not raised

if e.kind() == io::ErrorKind::NotFound {

Ok(false)

} else {

Err(e.into_pyexception(vm))

}

}

}

}

#[pymethod]

fn is_dir(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {

self.perform_on_metadata(

follow_symlinks,

|meta: fs::Metadata| -> bool { meta.is_dir() },

vm,

)

}

#[pymethod]

fn is_file(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {

self.perform_on_metadata(

follow_symlinks,

|meta: fs::Metadata| -> bool { meta.is_file() },

vm,

)

}

#[pymethod]

fn is_symlink(&self, vm: &VirtualMachine) -> PyResult<bool> {

Ok(self

.file_type

.as_ref()

.map_err(|err| err.into_pyexception(vm))?

.is_symlink())

}

#[pymethod]

fn stat(

&self,

dir_fd: DirFd<{ STAT_DIR_FD as usize }>,

follow_symlinks: FollowSymlinks,

vm: &VirtualMachine,

) -> PyResult {

let do_stat = |follow_symlinks| {

stat(

OsPath {

path: self.pathval.as_os_str().to_owned(),

mode: OutputMode::String,

}

.into(),

dir_fd,

FollowSymlinks(follow_symlinks),

vm,

)

};

let lstat = || self.lstat.get_or_try_init(|| do_stat(false));

let stat = if follow_symlinks.0 {

// if follow_symlinks == true and we aren't a symlink, cache both stat and lstat

self.stat.get_or_try_init(|| {

if self.is_symlink(vm)? {

do_stat(true)

} else {

lstat().map(Clone::clone)

}

})?

} else {

lstat()?

};

Ok(stat.clone())

}

#[cfg(not(unix))]

#[pymethod]

fn inode(&self, vm: &VirtualMachine) -> PyResult<u64> {

match self.ino.load() {

Some(ino) => Ok(ino),

None => {

let stat = stat_inner(

OsPath {

path: self.pathval.as_os_str().to_owned(),

mode: OutputMode::String,

}

.into(),

DirFd::default(),

FollowSymlinks(false),

)

.map_err(|e| e.into_pyexception(vm))?

.ok_or_else(|| crate::exceptions::cstring_error(vm))?;

// Err(T) means other thread set `ino` at the mean time which is safe to ignore

let _ = self.ino.compare_exchange(None, Some(stat.st_ino));

Ok(stat.st_ino)

}

}

}

#[cfg(unix)]

#[pymethod]

fn inode(&self, _vm: &VirtualMachine) -> PyResult<u64> {

Ok(self.ino.load())

}

#[pymethod(magic)]

fn fspath(&self, vm: &VirtualMachine) -> PyResult {

self.path(vm)

}

#[pyclassmethod(magic)]

fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {