os.rs

use std::ffi;
use std::fs::File;
use std::fs::OpenOptions;
use std::io::{self, ErrorKind, Read, Write};
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use std::{env, fs};

use crossbeam_utils::atomic::AtomicCell;
use num_traits::ToPrimitive;

use super::errno::errors;
use crate::byteslike::PyBytesLike;
use crate::common::lock::PyRwLock;
use crate::exceptions::{IntoPyException, PyBaseExceptionRef};
use crate::function::{IntoPyNativeFunc, OptionalArg, PyFuncArgs};
use crate::obj::objbytes::{PyBytes, PyBytesRef};
use crate::obj::objdict::PyDictRef;
use crate::obj::objint::{PyInt, PyIntRef};
use crate::obj::objiter;
use crate::obj::objset::PySet;
use crate::obj::objstr::{PyStr, PyStrRef};
use crate::obj::objtuple::PyTupleRef;
use crate::obj::objtype::PyTypeRef;
use crate::pyobject::{
    BorrowValue, Either, IntoPyObject, ItemProtocol, PyObjectRef, PyRef, PyResult,
    PyStructSequence, PyValue, TryFromObject, TypeProtocol,
};
use crate::vm::VirtualMachine;

#[derive(Debug, Copy, Clone)]
enum OutputMode {
    String,
    Bytes,
}

impl OutputMode {
    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)),
                OutputMode::Bytes => {
                    #[cfg(unix)]
                    {
                        use std::os::unix::ffi::OsStringExt;
                        Ok(vm.ctx.new_bytes(path.into_os_string().into_vec()))
                    }
                    #[cfg(target_os = "wasi")]
                    {
                        use std::os::wasi::ffi::OsStringExt;
                        Ok(vm.ctx.new_bytes(path.into_os_string().into_vec()))
                    }
                    #[cfg(windows)]
                    {
                        path_as_string(path).map(|s| vm.ctx.new_bytes(s.into_bytes()))
                    }
                }
            }
        }
        inner(self, path.into(), vm)
    }
}

pub struct PyPathLike {
    pub path: PathBuf,
    mode: OutputMode,
}

impl PyPathLike {
    pub fn new_str(path: String) -> Self {
        Self {
            path: PathBuf::from(path),
            mode: OutputMode::String,
        }
    }
}

fn fs_metadata<P: AsRef<Path>>(path: P, follow_symlink: bool) -> io::Result<fs::Metadata> {
    if follow_symlink {
        fs::metadata(path.as_ref())
    } else {
        fs::symlink_metadata(path.as_ref())
    }
}

impl TryFromObject for PyPathLike {
    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
        let match1 = |obj: &PyObjectRef| {
            let pathlike = match_class!(match obj {
                ref l @ PyStr => PyPathLike {
                    path: l.borrow_value().into(),
                    mode: OutputMode::String,
                },
                ref i @ PyBytes => PyPathLike {
                    path: bytes_as_osstr(&i, vm)?.to_os_string().into(),
                    mode: OutputMode::Bytes,
                },
                _ => return Ok(None),
            });
            Ok(Some(pathlike))
        };
        if let Some(pathlike) = match1(&obj)? {
            return Ok(pathlike);
        }
        let method = vm.get_method_or_type_error(obj.clone(), "__fspath__", || {
            format!(
                "expected str, bytes or os.PathLike object, not '{}'",
                obj.class().name
            )
        })?;
        let result = vm.invoke(&method, PyFuncArgs::default())?;
        match1(&result)?.ok_or_else(|| {
            vm.new_type_error(format!(
                "expected {}.__fspath__() to return str or bytes, not '{}'",
                obj.class().name,
                result.class().name,
            ))
        })
    }
}

fn make_path<'a>(
    vm: &VirtualMachine,
    path: &'a PyPathLike,
    dir_fd: &DirFd,
) -> PyResult<&'a ffi::OsStr> {
    if dir_fd.dir_fd.is_some() {
        Err(vm.new_os_error("dir_fd not supported yet".to_owned()))
    } else {
        Ok(path.path.as_os_str())
    }
}

impl IntoPyException for io::Error {
    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
        #[allow(unreachable_patterns)] // some errors are just aliases of each other
        let exc_type = match self.kind() {
            ErrorKind::NotFound => vm.ctx.exceptions.file_not_found_error.clone(),
            ErrorKind::PermissionDenied => vm.ctx.exceptions.permission_error.clone(),
            ErrorKind::AlreadyExists => vm.ctx.exceptions.file_exists_error.clone(),
            ErrorKind::WouldBlock => vm.ctx.exceptions.blocking_io_error.clone(),
            _ => match self.raw_os_error() {
                Some(errors::EAGAIN)
                | Some(errors::EALREADY)
                | Some(errors::EWOULDBLOCK)
                | Some(errors::EINPROGRESS) => vm.ctx.exceptions.blocking_io_error.clone(),
                _ => vm.ctx.exceptions.os_error.clone(),
            },
        };
        let os_error = vm.new_exception_msg(exc_type, self.to_string());
        let errno = self.raw_os_error().into_pyobject(vm);
        vm.set_attr(os_error.as_object(), "errno", errno).unwrap();
        os_error
    }
}

#[cfg(unix)]
impl IntoPyException for nix::Error {
    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
        let nix_error = match self {
            nix::Error::InvalidPath => {
                let exc_type = vm.ctx.exceptions.file_not_found_error.clone();
                vm.new_exception_msg(exc_type, self.to_string())
            }
            nix::Error::InvalidUtf8 => {
                let exc_type = vm.ctx.exceptions.unicode_error.clone();
                vm.new_exception_msg(exc_type, self.to_string())
            }
            nix::Error::UnsupportedOperation => vm.new_runtime_error(self.to_string()),
            nix::Error::Sys(errno) => {
                let exc_type = posix::convert_nix_errno(vm, errno);
                vm.new_exception_msg(exc_type, self.to_string())
            }
        };

        if let nix::Error::Sys(errno) = self {
            vm.set_attr(nix_error.as_object(), "errno", vm.ctx.new_int(errno as i32))
                .unwrap();
        }

        nix_error
    }
}

/// Convert the error stored in the `errno` variable into an Exception
#[inline]
pub fn errno_err(vm: &VirtualMachine) -> PyBaseExceptionRef {
    io::Error::last_os_error().into_pyexception(vm)
}

#[allow(dead_code)]
#[derive(FromArgs, Default)]
pub struct TargetIsDirectory {
    #[pyarg(named, default = "false")]
    target_is_directory: bool,
}

#[derive(FromArgs, Default)]
pub struct DirFd {
    #[pyarg(named, default)]
    dir_fd: Option<PyIntRef>,
}

#[derive(FromArgs)]
struct FollowSymlinks {
    #[pyarg(named, default = "true")]
    follow_symlinks: bool,
}

#[cfg(unix)]
use posix::bytes_as_osstr;

#[cfg(not(unix))]
fn bytes_as_osstr<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a ffi::OsStr> {
    std::str::from_utf8(b)
        .map(|s| s.as_ref())
        .map_err(|_| vm.new_value_error("Can't convert bytes to str for env function".to_owned()))
}

#[macro_export]
macro_rules! suppress_iph {
    ($e:expr) => {{
        #[cfg(all(windows, target_env = "msvc"))]
        {
            let old = $crate::stdlib::os::_set_thread_local_invalid_parameter_handler(
                $crate::stdlib::os::silent_iph_handler,
            );
            let ret = $e;
            $crate::stdlib::os::_set_thread_local_invalid_parameter_handler(old);
            ret
        }
        #[cfg(not(all(windows, target_env = "msvc")))]
        {
            $e
        }
    }};
}

#[allow(dead_code)]
fn os_unimpl<T>(func: &str, vm: &VirtualMachine) -> PyResult<T> {
    Err(vm.new_os_error(format!("{} is not supported on this platform", func)))
}

#[pymodule]
mod _os {
    use super::platform::OpenFlags;
    use super::*;

    #[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(super) const F_OK: u8 = 0;
    #[pyattr]
    pub(super) const R_OK: u8 = 4;
    #[pyattr]
    pub(super) const W_OK: u8 = 2;
    #[pyattr]
    pub(super) const X_OK: u8 = 1;

    #[pyfunction]
    fn close(fileno: i64) {
        //The File type automatically closes when it goes out of scope.
        //To enable us to close these file descriptors (and hence prevent leaks)
        //we seek to create the relevant File and simply let it pass out of scope!
        rust_file(fileno);
    }

    #[cfg(any(unix, windows, target_os = "wasi"))]
    #[pyfunction]
    pub(crate) fn open(
        name: PyPathLike,
        flags: OpenFlags,
        _mode: OptionalArg<PyIntRef>,
        dir_fd: OptionalArg<PyIntRef>,
        vm: &VirtualMachine,
    ) -> PyResult<i64> {
        let dir_fd = DirFd {
            dir_fd: dir_fd.into_option(),
        };
        let fname = make_path(vm, &name, &dir_fd)?;

        let mut options = OpenOptions::new();

        macro_rules! bit_contains {
            ($c:expr) => {
                flags & $c as OpenFlags == $c as OpenFlags
            };
        }

        if bit_contains!(libc::O_WRONLY) {
            options.write(true);
        } else if bit_contains!(libc::O_RDWR) {
            options.read(true).write(true);
        } else if bit_contains!(libc::O_RDONLY) {
            options.read(true);
        }

        if bit_contains!(libc::O_APPEND) {
            options.append(true);
        }

        if bit_contains!(libc::O_CREAT) {
            if bit_contains!(libc::O_EXCL) {
                options.create_new(true);
            } else {
                options.create(true);
            }
        }

        #[cfg(windows)]
        let flags = flags & !(libc::O_WRONLY as u32);

        #[cfg(not(target_os = "wasi"))]
        {
            use platform::OpenOptionsExt;
            options.custom_flags(flags);
        }
        let handle = options
            .open(fname)
            .map_err(|err| err.into_pyexception(vm))?;

        Ok(raw_file_number(handle))
    }

    #[cfg(not(any(unix, windows, target_os = "wasi")))]
    #[pyfunction]
    pub(crate) fn open(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
        Err(vm.new_os_error("os.open not implemented on this platform".to_owned()))
    }

    #[pyfunction]
    fn error(message: OptionalArg<PyStrRef>, vm: &VirtualMachine) -> PyResult {
        let msg = message.map_or("".to_owned(), |msg| msg.borrow_value().to_owned());

        Err(vm.new_os_error(msg))
    }

    #[pyfunction]
    fn fsync(fd: i64, vm: &VirtualMachine) -> PyResult<()> {
        let file = rust_file(fd);
        file.sync_all().map_err(|err| err.into_pyexception(vm))?;
        // Avoid closing the fd
        raw_file_number(file);
        Ok(())
    }

    #[pyfunction]
    fn read(fd: i64, n: usize, vm: &VirtualMachine) -> PyResult {
        let mut buffer = vec![0u8; n];
        let mut file = rust_file(fd);
        let n = file
            .read(&mut buffer)
            .map_err(|err| err.into_pyexception(vm))?;
        buffer.truncate(n);

        // Avoid closing the fd
        raw_file_number(file);
        Ok(vm.ctx.new_bytes(buffer))
    }

    #[pyfunction]
    fn write(fd: i64, data: PyBytesLike, vm: &VirtualMachine) -> PyResult {
        let mut file = rust_file(fd);
        let written = data
            .with_ref(|b| file.write(b))
            .map_err(|err| err.into_pyexception(vm))?;

        // Avoid closing the fd
        raw_file_number(file);
        Ok(vm.ctx.new_int(written))
    }

    #[pyfunction]
    fn remove(path: PyPathLike, dir_fd: DirFd, vm: &VirtualMachine) -> PyResult<()> {
        let path = make_path(vm, &path, &dir_fd)?;
        fs::remove_file(path).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn mkdir(
        path: PyPathLike,
        _mode: OptionalArg<PyIntRef>,
        dir_fd: DirFd,
        vm: &VirtualMachine,
    ) -> PyResult<()> {
        let path = make_path(vm, &path, &dir_fd)?;
        fs::create_dir(path).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn mkdirs(path: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
        fs::create_dir_all(path.borrow_value()).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn rmdir(path: PyPathLike, dir_fd: DirFd, vm: &VirtualMachine) -> PyResult<()> {
        let path = make_path(vm, &path, &dir_fd)?;
        fs::remove_dir(path).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn listdir(path: PyPathLike, vm: &VirtualMachine) -> PyResult {
        let dir_iter = fs::read_dir(&path.path).map_err(|err| err.into_pyexception(vm))?;
        let res: PyResult<Vec<PyObjectRef>> = dir_iter
            .map(|entry| match entry {
                Ok(entry_path) => path.mode.process_path(entry_path.file_name(), vm),
                Err(err) => Err(err.into_pyexception(vm)),
            })
            .collect();
        Ok(vm.ctx.new_list(res?))
    }

    #[pyfunction]
    fn putenv(
        key: Either<PyStrRef, PyBytesRef>,
        value: Either<PyStrRef, PyBytesRef>,
        vm: &VirtualMachine,
    ) -> PyResult<()> {
        let key: &ffi::OsStr = match key {
            Either::A(ref s) => s.borrow_value().as_ref(),
            Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
        };
        let value: &ffi::OsStr = match value {
            Either::A(ref s) => s.borrow_value().as_ref(),
            Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
        };
        env::set_var(key, value);
        Ok(())
    }

    #[pyfunction]
    fn unsetenv(key: Either<PyStrRef, PyBytesRef>, vm: &VirtualMachine) -> PyResult<()> {
        let key: &ffi::OsStr = match key {
            Either::A(ref s) => s.borrow_value().as_ref(),
            Either::B(ref b) => bytes_as_osstr(b.borrow_value(), vm)?,
        };
        env::remove_var(key);
        Ok(())
    }

    #[pyfunction]
    fn readlink(path: PyPathLike, dir_fd: DirFd, vm: &VirtualMachine) -> PyResult {
        let mode = path.mode;
        let path = make_path(vm, &path, &dir_fd)?;
        let path = fs::read_link(path).map_err(|err| err.into_pyexception(vm))?;
        mode.process_path(path, vm)
    }

    #[pyattr]
    #[pyclass(name)]
    #[derive(Debug)]
    struct DirEntry {
        entry: fs::DirEntry,
        mode: OutputMode,
    }

    impl PyValue for DirEntry {
        fn class(vm: &VirtualMachine) -> PyTypeRef {
            vm.class(super::MODULE_NAME, "DirEntry")
        }
    }

    #[pyimpl]
    impl DirEntry {
        #[pyproperty]
        fn name(&self, vm: &VirtualMachine) -> PyResult {
            self.mode.process_path(self.entry.file_name(), vm)
        }

        #[pyproperty]
        fn path(&self, vm: &VirtualMachine) -> PyResult {
            self.mode.process_path(self.entry.path(), vm)
        }

        #[allow(clippy::match_bool)]
        fn perform_on_metadata(
            &self,
            follow_symlinks: FollowSymlinks,
            action: fn(fs::Metadata) -> bool,
            vm: &VirtualMachine,
        ) -> PyResult<bool> {
            let meta = fs_metadata(self.entry.path(), follow_symlinks.follow_symlinks)
                .map_err(|err| err.into_pyexception(vm))?;
            Ok(action(meta))
        }

        #[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
                .entry
                .file_type()
                .map_err(|err| err.into_pyexception(vm))?
                .is_symlink())
        }

        #[pymethod]
        fn stat(
            &self,
            dir_fd: DirFd,
            follow_symlinks: FollowSymlinks,
            vm: &VirtualMachine,
        ) -> PyResult {
            super::platform::stat(
                Either::A(PyPathLike {
                    path: self.entry.path(),
                    mode: OutputMode::String,
                }),
                dir_fd,
                follow_symlinks,
                vm,
            )
        }
    }

    #[pyattr]
    #[pyclass(name = "ScandirIter")]
    #[derive(Debug)]
    struct ScandirIterator {
        entries: PyRwLock<fs::ReadDir>,
        exhausted: AtomicCell<bool>,
        mode: OutputMode,
    }

    impl PyValue for ScandirIterator {
        fn class(vm: &VirtualMachine) -> PyTypeRef {
            vm.class(super::MODULE_NAME, "ScandirIter")
        }
    }

    #[pyimpl]
    impl ScandirIterator {
        #[pymethod(name = "__next__")]
        fn next(&self, vm: &VirtualMachine) -> PyResult {
            if self.exhausted.load() {
                return Err(objiter::new_stop_iteration(vm));
            }

            match self.entries.write().next() {
                Some(entry) => match entry {
                    Ok(entry) => Ok(DirEntry {
                        entry,
                        mode: self.mode,
                    }
                    .into_ref(vm)
                    .into_object()),
                    Err(err) => Err(err.into_pyexception(vm)),
                },
                None => {
                    self.exhausted.store(true);
                    Err(objiter::new_stop_iteration(vm))
                }
            }
        }

        #[pymethod]
        fn close(&self) {
            self.exhausted.store(true);
        }

        #[pymethod(name = "__iter__")]
        fn iter(zelf: PyRef<Self>) -> PyRef<Self> {
            zelf
        }

        #[pymethod(name = "__enter__")]
        fn enter(zelf: PyRef<Self>) -> PyRef<Self> {
            zelf
        }

        #[pymethod(name = "__exit__")]
        fn exit(zelf: PyRef<Self>, _args: PyFuncArgs) {
            zelf.close()
        }
    }

    #[pyfunction]
    fn scandir(path: OptionalArg<PyPathLike>, vm: &VirtualMachine) -> PyResult {
        let path = match path {
            OptionalArg::Present(path) => path,
            OptionalArg::Missing => PyPathLike::new_str(".".to_owned()),
        };

        let entries = fs::read_dir(path.path).map_err(|err| err.into_pyexception(vm))?;
        Ok(ScandirIterator {
            entries: PyRwLock::new(entries),
            exhausted: AtomicCell::new(false),
            mode: path.mode,
        }
        .into_ref(vm)
        .into_object())
    }

    #[pyattr]
    #[pyclass(module = "os", name = "stat_result")]
    #[derive(Debug, PyStructSequence)]
    pub(super) struct StatResult {
        pub st_mode: u32,
        pub st_ino: u64,
        pub st_dev: u64,
        pub st_nlink: u64,
        pub st_uid: u32,
        pub st_gid: u32,
        pub st_size: u64,
        pub st_atime: f64,
        pub st_mtime: f64,
        pub st_ctime: f64,
    }

    #[pyimpl(with(PyStructSequence))]
    impl StatResult {
        pub(super) fn into_obj(self, vm: &VirtualMachine) -> PyObjectRef {
            self.into_struct_sequence(vm, vm.class(super::MODULE_NAME, "stat_result"))
                .unwrap()
                .into_object()
        }
    }

    #[pyfunction]
    fn lstat(file: Either<PyPathLike, i64>, dir_fd: DirFd, vm: &VirtualMachine) -> PyResult {
        super::platform::stat(
            file,
            dir_fd,
            FollowSymlinks {
                follow_symlinks: false,
            },
            vm,
        )
    }

    #[pyfunction]
    fn getcwd(vm: &VirtualMachine) -> PyResult<String> {
        Ok(env::current_dir()
            .map_err(|err| err.into_pyexception(vm))?
            .as_path()
            .to_str()
            .unwrap()
            .to_owned())
    }

    #[pyfunction]
    fn getcwdb(vm: &VirtualMachine) -> PyResult<Vec<u8>> {
        Ok(getcwd(vm)?.into_bytes().to_vec())
    }

    #[pyfunction]
    fn chdir(path: PyPathLike, vm: &VirtualMachine) -> PyResult<()> {
        env::set_current_dir(&path.path).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn fspath(path: PyPathLike, vm: &VirtualMachine) -> PyResult {
        path.mode.process_path(path.path, vm)
    }

    #[pyfunction]
    fn rename(src: PyPathLike, dst: PyPathLike, vm: &VirtualMachine) -> PyResult<()> {
        fs::rename(src.path, dst.path).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn getpid(vm: &VirtualMachine) -> PyObjectRef {
        let pid = std::process::id();
        vm.ctx.new_int(pid)
    }

    #[pyfunction]
    fn cpu_count(vm: &VirtualMachine) -> PyObjectRef {
        let cpu_count = num_cpus::get();
        vm.ctx.new_int(cpu_count)
    }

    #[pyfunction]
    fn exit(code: i32) {
        std::process::exit(code)
    }

    #[pyfunction]
    fn abort() {
        extern "C" {
            fn abort();
        }
        unsafe { abort() }
    }

    #[pyfunction]
    fn urandom(size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
        let mut buf = vec![0u8; size];
        getrandom::getrandom(&mut buf).map_err(|e| match e.raw_os_error() {
            Some(errno) => io::Error::from_raw_os_error(errno).into_pyexception(vm),
            None => vm.new_os_error("Getting random failed".to_owned()),
        })?;
        Ok(buf)
    }

    // this is basically what CPython has for Py_off_t; windows uses long long
    // for offsets, other platforms just use off_t
    #[cfg(not(windows))]
    pub type Offset = libc::off_t;
    #[cfg(windows)]
    pub type Offset = libc::c_longlong;

    #[pyfunction]
    fn isatty(fd: i32) -> bool {
        unsafe { suppress_iph!(libc::isatty(fd)) != 0 }
    }

    #[pyfunction]
    fn lseek(fd: i32, position: Offset, how: i32, vm: &VirtualMachine) -> PyResult<Offset> {
        #[cfg(not(windows))]
        let res = unsafe { suppress_iph!(libc::lseek(fd, position, how)) };
        #[cfg(windows)]
        let res = unsafe {
            use std::os::windows::io::RawHandle;
            use winapi::um::{fileapi, winnt};
            let mut li = winnt::LARGE_INTEGER::default();
            *li.QuadPart_mut() = position;
            let ret = fileapi::SetFilePointer(
                fd as RawHandle,
                li.u().LowPart as _,
                &mut li.u_mut().HighPart,
                how as _,
            );
            if ret == fileapi::INVALID_SET_FILE_POINTER {
                -1
            } else {
                li.u_mut().LowPart = ret;
                *li.QuadPart()
            }
        };
        if res < 0 {
            Err(errno_err(vm))
        } else {
            Ok(res)
        }
    }

    #[pyfunction]
    fn link(src: PyPathLike, dst: PyPathLike, vm: &VirtualMachine) -> PyResult<()> {
        fs::hard_link(src.path, dst.path).map_err(|err| err.into_pyexception(vm))
    }

    #[derive(FromArgs)]
    struct UtimeArgs {
        #[pyarg(any)]
        path: PyPathLike,
        #[pyarg(any, default)]
        times: Option<PyTupleRef>,
        #[pyarg(named, default)]
        ns: Option<PyTupleRef>,
        #[pyarg(flatten)]
        _dir_fd: DirFd,
        #[pyarg(flatten)]
        _follow_symlinks: FollowSymlinks,
    }

    #[cfg(not(target_os = "wasi"))]
    #[pyfunction]
    fn utime(args: UtimeArgs, vm: &VirtualMachine) -> PyResult<()> {
        let parse_tup = |tup: PyTupleRef| -> Option<(i64, i64)> {
            let tup = tup.borrow_value();
            if tup.len() != 2 {
                return None;
            }
            let i = |e: &PyObjectRef| e.clone().downcast::<PyInt>().ok()?.borrow_value().to_i64();
            Some((i(&tup[0])?, i(&tup[1])?))
        };
        let (acc, modif) = match (args.times, args.ns) {
            (Some(t), None) => parse_tup(t).ok_or_else(|| {
                vm.new_type_error(
                    "utime: 'times' must be either a tuple of two ints or None".to_owned(),
                )
            })?,
            (None, Some(ns)) => {
                let (a, m) = parse_tup(ns).ok_or_else(|| {
                    vm.new_type_error("utime: 'ns' must be a tuple of two ints".to_owned())
                })?;
                // TODO: do validation to make sure this doesn't.. underflow?
                (a / 1_000_000_000, m / 1_000_000_000)
            }
            (None, None) => {
                let now = SystemTime::now();
                let now = now
                    .duration_since(SystemTime::UNIX_EPOCH)
                    .map(|d| d.as_secs() as i64)
                    .unwrap_or_else(|e| -(e.duration().as_secs() as i64));
                (now, now)
            }
            (Some(_), Some(_)) => {
                return Err(vm.new_value_error(
                    "utime: you may specify either 'times' or 'ns' but not both".to_owned(),
                ))
            }
        };
        utime::set_file_times(&args.path.path, acc, modif).map_err(|err| err.into_pyexception(vm))
    }

    #[pyfunction]
    fn strerror(e: i32) -> String {
        unsafe { ffi::CStr::from_ptr(libc::strerror(e)) }
            .to_string_lossy()
            .into_owned()
    }

    #[pyattr]
    #[pyclass(module = "os", name = "terminal_size")]
    #[derive(PyStructSequence)]
    #[allow(dead_code)]
    pub(super) struct PyTerminalSize {
        pub columns: usize,
        pub lines: usize,
    }
    #[pyimpl(with(PyStructSequence))]
    impl PyTerminalSize {}

    pub(super) fn support_funcs(vm: &VirtualMachine) -> Vec<SupportFunc> {
        let mut supports = super::platform::support_funcs(vm);
        supports.extend(vec![
            SupportFunc::new(vm, "open", open, None, Some(false), None),
            SupportFunc::new(
                vm,
                "access",
                platform::access,
                Some(false),
                Some(false),
                None,
            ),
            SupportFunc::new(vm, "chdir", chdir, Some(false), None, None),
            // chflags Some, None Some
            SupportFunc::new(vm, "listdir", listdir, Some(false), None, None),
            SupportFunc::new(vm, "mkdir", mkdir, Some(false), Some(false), None),
            // mkfifo Some Some None
            // mknod Some Some None
            // pathconf Some None None
            SupportFunc::new(vm, "readlink", readlink, Some(false), Some(false), None),
            SupportFunc::new(vm, "remove", remove, Some(false), Some(false), None),
            SupportFunc::new(vm, "rename", rename, Some(false), Some(false), None),
            SupportFunc::new(vm, "replace", rename, Some(false), Some(false), None), // TODO: Fix replace
            SupportFunc::new(vm, "rmdir", rmdir, Some(false), Some(false), None),
            SupportFunc::new(vm, "scandir", scandir, Some(false), None, None),
            SupportFunc::new(
                vm,
                "stat",
                platform::stat,
                Some(false),
                Some(false),
                Some(false),
            ),
            SupportFunc::new(
                vm,
                "fstat",
                platform::stat,
                Some(false),
                Some(false),
                Some(false),
            ),
            SupportFunc::new(vm, "symlink", platform::symlink, None, Some(false), None),
            // truncate Some None None
            SupportFunc::new(vm, "unlink", remove, Some(false), Some(false), None),
            #[cfg(not(target_os = "wasi"))]
            SupportFunc::new(vm, "utime", utime, Some(false), Some(false), Some(false)),
        ]);
        supports
    }
}

struct SupportFunc {
    name: &'static str,
    func_obj: PyObjectRef,
    fd: Option<bool>,
    dir_fd: Option<bool>,
    follow_symlinks: Option<bool>,
}

impl<'a> SupportFunc {
    fn new<F, FKind>(
        vm: &VirtualMachine,
        name: &'static str,
        func: F,
        fd: Option<bool>,
        dir_fd: Option<bool>,
        follow_symlinks: Option<bool>,
    ) -> Self
    where
        F: IntoPyNativeFunc<FKind>,
    {
        let func_obj = vm.ctx.new_function(func);
        Self {
            name,
            func_obj,
            fd,
            dir_fd,
            follow_symlinks,
        }
    }
}

pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
    let module = platform::make_module(vm);

    _os::extend_module(&vm, &module);

    let support_funcs = _os::support_funcs(vm);
    let supports_fd = PySet::default().into_ref(vm);
    let supports_dir_fd = PySet::default().into_ref(vm);
    let supports_follow_symlinks = PySet::default().into_ref(vm);
    for support in support_funcs {
        if support.fd.unwrap_or(false) {
            supports_fd
                .clone()
                .add(support.func_obj.clone(), vm)
                .unwrap();
        }
        if support.dir_fd.unwrap_or(false) {
            supports_dir_fd
                .clone()
                .add(support.func_obj.clone(), vm)
                .unwrap();
        }
        if support.follow_symlinks.unwrap_or(false) {
            supports_follow_symlinks
                .clone()
                .add(support.func_obj.clone(), vm)
                .unwrap();
        }
        vm.set_attr(&module, support.name, support.func_obj)
            .unwrap();
    }

    extend_module!(vm, module, {
        "supports_fd" => supports_fd.into_object(),
        "supports_dir_fd" => supports_dir_fd.into_object(),
        "supports_follow_symlinks" => supports_follow_symlinks.into_object(),
    });

    module
}
pub(crate) use _os::open;

// Copied code from Duration::as_secs_f64 as it's still unstable
fn duration_as_secs_f64(duration: Duration) -> f64 {
    (duration.as_secs() as f64) + f64::from(duration.subsec_nanos()) / 1_000_000_000_f64
}

fn to_seconds_from_unix_epoch(sys_time: SystemTime) -> f64 {
    match sys_time.duration_since(SystemTime::UNIX_EPOCH) {
        Ok(duration) => duration_as_secs_f64(duration),
        Err(err) => -duration_as_secs_f64(err.duration()),
    }
}

#[cfg(unix)]
#[pymodule]
mod posix {
    use super::*;

    use crate::obj::objdict::PyMapping;
    use crate::obj::objlist::PyListRef;
    use crate::pyobject::PyIterable;
    use bitflags::bitflags;
    use nix::errno::Errno;
    use nix::unistd::{self, Gid, Pid, Uid};
    use std::convert::TryFrom;
    pub(super) use std::os::unix::fs::OpenOptionsExt;
    use std::os::unix::io::RawFd;

    #[pyattr]
    use libc::{O_CLOEXEC, O_NONBLOCK, WNOHANG};
    #[cfg(not(target_os = "redox"))]
    #[pyattr]
    use libc::{O_DSYNC, O_NDELAY, O_NOCTTY};

    #[pyattr]