use nix::fcntl;

let flags = fcntl::FdFlag::from_bits_truncate(fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFD)?);

let mut new_flags = flags;

new_flags.set(fcntl::FdFlag::FD_CLOEXEC, !inheritable);

if flags != new_flags {

fcntl::fcntl(fd, fcntl::FcntlArg::F_SETFD(new_flags))?;

}

Ok(())

let module = module::make_module(vm);

super::os::extend_module(vm, &module);

module

use crate::{

builtins::{PyDictRef, PyInt, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},

convert::{IntoPyException, ToPyObject, TryFromObject},

function::{Either, KwArgs, OptionalArg},

stdlib::os::{

errno_err, DirFd, FollowSymlinks, OsPath, OsPathOrFd, SupportFunc, TargetIsDirectory,

_os, fs_metadata, IOErrorBuilder,

},

types::{Constructor, Representable},

utils::ToCString,

AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,

};

use bitflags::bitflags;

use nix::{

fcntl,

unistd::{self, Gid, Pid, Uid},

};

use std::{

env,

ffi::{CStr, CString},

fs, io,

os::unix::io::RawFd,

};

use strum_macros::{EnumIter, EnumString};

#[pyattr]

use libc::{PRIO_PGRP, PRIO_PROCESS, PRIO_USER};

#[cfg(any(

#[pyattr]

use libc::{SEEK_DATA, SEEK_HOLE};

#[cfg(not(any(target_os = "redox", target_os = "freebsd")))]

#[pyattr]

use libc::O_DSYNC;

#[pyattr]

use libc::{O_CLOEXEC, O_NONBLOCK, WNOHANG};

#[cfg(target_os = "macos")]

#[pyattr]

use libc::{O_EVTONLY, O_FSYNC, O_NOFOLLOW_ANY, O_SYMLINK};

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

#[pyattr]

use libc::{O_NDELAY, O_NOCTTY};

#[pyattr]

use libc::{RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW};

#[cfg(target_os = "linux")]

#[pyattr]

use libc::{GRND_NONBLOCK, GRND_RANDOM};

#[pyattr]

const EX_OK: i8 = exitcode::OK as i8;

#[pyattr]

const EX_USAGE: i8 = exitcode::USAGE as i8;

#[pyattr]

const EX_DATAERR: i8 = exitcode::DATAERR as i8;

#[pyattr]

const EX_NOINPUT: i8 = exitcode::NOINPUT as i8;

#[pyattr]

const EX_NOUSER: i8 = exitcode::NOUSER as i8;

#[pyattr]

const EX_NOHOST: i8 = exitcode::NOHOST as i8;

#[pyattr]

const EX_UNAVAILABLE: i8 = exitcode::UNAVAILABLE as i8;

#[pyattr]

const EX_SOFTWARE: i8 = exitcode::SOFTWARE as i8;

#[pyattr]

const EX_OSERR: i8 = exitcode::OSERR as i8;

#[pyattr]

const EX_OSFILE: i8 = exitcode::OSFILE as i8;

#[pyattr]

const EX_CANTCREAT: i8 = exitcode::CANTCREAT as i8;

#[pyattr]

const EX_IOERR: i8 = exitcode::IOERR as i8;

#[pyattr]

const EX_TEMPFAIL: i8 = exitcode::TEMPFAIL as i8;

#[pyattr]

const EX_PROTOCOL: i8 = exitcode::PROTOCOL as i8;

#[pyattr]

const EX_NOPERM: i8 = exitcode::NOPERM as i8;

#[pyattr]

const EX_CONFIG: i8 = exitcode::CONFIG as i8;

#[cfg(any(

#[pyattr]

const SCHED_RR: i32 = libc::SCHED_RR;

#[cfg(any(

#[pyattr]

const SCHED_FIFO: i32 = libc::SCHED_FIFO;

#[cfg(any(

#[pyattr]

const SCHED_OTHER: i32 = libc::SCHED_OTHER;

#[cfg(any(target_os = "linux", target_os = "android"))]

#[pyattr]

const SCHED_IDLE: i32 = libc::SCHED_IDLE;

#[cfg(any(target_os = "linux", target_os = "android"))]

#[pyattr]

const SCHED_BATCH: i32 = libc::SCHED_BATCH;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_OPEN: i32 = PosixSpawnFileActionIdentifier::Open as i32;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_CLOSE: i32 = PosixSpawnFileActionIdentifier::Close as i32;

#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]

#[pyattr]

const POSIX_SPAWN_DUP2: i32 = PosixSpawnFileActionIdentifier::Dup2 as i32;

#[cfg(target_os = "macos")]

#[pyattr]

const _COPYFILE_DATA: u32 = 1 << 3;

// Flags for os_access

bitflags! {

pub struct AccessFlags: u8 {

const F_OK = _os::F_OK;

const R_OK = _os::R_OK;

const W_OK = _os::W_OK;

const X_OK = _os::X_OK;

}

}

struct Permissions {

is_readable: bool,

is_writable: bool,

is_executable: bool,

}

fn get_permissions(mode: u32) -> Permissions {

Permissions {

is_readable: mode & 4 != 0,

is_writable: mode & 2 != 0,

is_executable: mode & 1 != 0,

}

}

fn get_right_permission(

mode: u32,

file_owner: Uid,

file_group: Gid,

) -> nix::Result<Permissions> {

let owner_mode = (mode & 0o700) >> 6;

let owner_permissions = get_permissions(owner_mode);

let group_mode = (mode & 0o070) >> 3;

let group_permissions = get_permissions(group_mode);

let others_mode = mode & 0o007;

let others_permissions = get_permissions(others_mode);

let user_id = nix::unistd::getuid();

let groups_ids = getgroups_impl()?;

if file_owner == user_id {

Ok(owner_permissions)

} else if groups_ids.contains(&file_group) {

Ok(group_permissions)

} else {

Ok(others_permissions)

}

}

#[cfg(any(target_os = "macos", target_os = "ios"))]

fn getgroups_impl() -> nix::Result<Vec<Gid>> {

use libc::{c_int, gid_t};

use nix::errno::Errno;

use std::ptr;

let ret = unsafe { libc::getgroups(0, ptr::null_mut()) };

let mut groups = Vec::<Gid>::with_capacity(Errno::result(ret)? as usize);

let ret = unsafe {

libc::getgroups(

groups.capacity() as c_int,

groups.as_mut_ptr() as *mut gid_t,

)

};

Errno::result(ret).map(|s| {

unsafe { groups.set_len(s as usize) };

groups

})

}

#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "redox")))]

use nix::unistd::getgroups as getgroups_impl;

#[cfg(target_os = "redox")]

fn getgroups_impl() -> nix::Result<Vec<Gid>> {

Err(nix::Error::EOPNOTSUPP)

}

#[pyfunction]

fn getgroups(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {

let group_ids = getgroups_impl().map_err(|e| e.into_pyexception(vm))?;

Ok(group_ids

.into_iter()

.map(|gid| vm.ctx.new_int(gid.as_raw()).into())

.collect())

}

#[pyfunction]

pub(super) fn access(path: OsPath, mode: u8, vm: &VirtualMachine) -> PyResult<bool> {

use std::os::unix::fs::MetadataExt;

let flags = AccessFlags::from_bits(mode).ok_or_else(|| {

vm.new_value_error(

"One of the flags is wrong, there are only 4 possibilities F_OK, R_OK, W_OK and X_OK"

.to_owned(),

)

})?;

let metadata = fs::metadata(path.path);

// if it's only checking for F_OK

if flags == AccessFlags::F_OK {

return Ok(metadata.is_ok());

}

let metadata = metadata.map_err(|err| err.into_pyexception(vm))?;

let user_id = metadata.uid();

let group_id = metadata.gid();

let mode = metadata.mode();

let perm = get_right_permission(mode, Uid::from_raw(user_id), Gid::from_raw(group_id))

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

let r_ok = !flags.contains(AccessFlags::R_OK) || perm.is_readable;

let w_ok = !flags.contains(AccessFlags::W_OK) || perm.is_writable;

let x_ok = !flags.contains(AccessFlags::X_OK) || perm.is_executable;

Ok(r_ok && w_ok && x_ok)

}

#[pyattr]

fn environ(vm: &VirtualMachine) -> PyDictRef {

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

let environ = vm.ctx.new_dict();

for (key, value) in env::vars_os() {

let key: PyObjectRef = vm.ctx.new_bytes(key.into_vec()).into();

let value: PyObjectRef = vm.ctx.new_bytes(value.into_vec()).into();

environ.set_item(&*key, value, vm).unwrap();

}

environ

}

#[derive(FromArgs)]

pub(super) struct SymlinkArgs {

src: OsPath,

dst: OsPath,

#[pyarg(flatten)]

_target_is_directory: TargetIsDirectory,

#[pyarg(flatten)]

dir_fd: DirFd<{ _os::SYMLINK_DIR_FD as usize }>,

}

#[pyfunction]

pub(super) fn symlink(args: SymlinkArgs, vm: &VirtualMachine) -> PyResult<()> {

let src = args.src.into_cstring(vm)?;

let dst = args.dst.into_cstring(vm)?;

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

{

nix::unistd::symlinkat(&*src, args.dir_fd.get_opt(), &*dst)

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

}

#[cfg(target_os = "redox")]

{

let [] = args.dir_fd.0;

let res = unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) };

if res < 0 {

Err(errno_err(vm))

} else {

Ok(())

}

}

}

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

#[pyfunction]

fn fchdir(fd: RawFd, vm: &VirtualMachine) -> PyResult<()> {

nix::unistd::fchdir(fd).map_err(|err| err.into_pyexception(vm))

}

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

#[pyfunction]

fn chroot(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {

use crate::stdlib::os::IOErrorBuilder;

nix::unistd::chroot(&*path.path).map_err(|err| {

// Use `From<nix::Error> for io::Error` when it is available

IOErrorBuilder::new(io::Error::from_raw_os_error(err as i32))

.filename(path)

.into_pyexception(vm)

})

}

// As of now, redox does not seems to support chown command (cf. https://gitlab.redox-os.org/redox-os/coreutils , last checked on 05/07/2020)

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

#[pyfunction]

fn chown(

path: OsPathOrFd,

uid: isize,

gid: isize,

dir_fd: DirFd<1>,

follow_symlinks: FollowSymlinks,

vm: &VirtualMachine,

) -> PyResult<()> {

let uid = if uid >= 0 {

Some(nix::unistd::Uid::from_raw(uid as u32))

} else if uid == -1 {

None

} else {

return Err(vm.new_os_error(String::from("Specified uid is not valid.")));

};

let gid = if gid >= 0 {

Some(nix::unistd::Gid::from_raw(gid as u32))

} else if gid == -1 {

None

} else {

return Err(vm.new_os_error(String::from("Specified gid is not valid.")));

};

let flag = if follow_symlinks.0 {

nix::unistd::FchownatFlags::FollowSymlink

} else {

nix::unistd::FchownatFlags::NoFollowSymlink

};

let dir_fd = dir_fd.get_opt();

match path {

OsPathOrFd::Path(ref p) => {

nix::unistd::fchownat(dir_fd, p.path.as_os_str(), uid, gid, flag)

}

OsPathOrFd::Fd(fd) => nix::unistd::fchown(fd, uid, gid),

}

.map_err(|err| {

// Use `From<nix::Error> for io::Error` when it is available

IOErrorBuilder::new(io::Error::from_raw_os_error(err as i32))

.filename(path)

.into_pyexception(vm)

})

}

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

#[pyfunction]

fn lchown(path: OsPath, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {

chown(

OsPathOrFd::Path(path),

uid,

gid,

DirFd::default(),

FollowSymlinks(false),

vm,

)

}

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

#[pyfunction]

fn fchown(fd: i32, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {

chown(

OsPathOrFd::Fd(fd),

uid,

gid,

DirFd::default(),

FollowSymlinks(true),

vm,

)

}

#[derive(FromArgs)]

struct RegisterAtForkArgs {

#[pyarg(named, optional)]

before: OptionalArg<PyObjectRef>,

#[pyarg(named, optional)]

after_in_parent: OptionalArg<PyObjectRef>,

#[pyarg(named, optional)]

after_in_child: OptionalArg<PyObjectRef>,

}

impl RegisterAtForkArgs {

fn into_validated(

self,

vm: &VirtualMachine,

) -> PyResult<(

Option<PyObjectRef>,

Option<PyObjectRef>,

Option<PyObjectRef>,

)> {

fn into_option(

arg: OptionalArg<PyObjectRef>,

vm: &VirtualMachine,

) -> PyResult<Option<PyObjectRef>> {

match arg {

OptionalArg::Present(obj) => {

if !obj.is_callable() {

return Err(vm.new_type_error("Args must be callable".to_owned()));

}

Ok(Some(obj))

}

OptionalArg::Missing => Ok(None),

}

}

let before = into_option(self.before, vm)?;

let after_in_parent = into_option(self.after_in_parent, vm)?;

let after_in_child = into_option(self.after_in_child, vm)?;

if before.is_none() && after_in_parent.is_none() && after_in_child.is_none() {

return Err(vm.new_type_error("At least one arg must be present".to_owned()));

}

Ok((before, after_in_parent, after_in_child))

}

}

#[pyfunction]

fn register_at_fork(

args: RegisterAtForkArgs,

_ignored: KwArgs,

vm: &VirtualMachine,

) -> PyResult<()> {

let (before, after_in_parent, after_in_child) = args.into_validated(vm)?;

if let Some(before) = before {

vm.state.before_forkers.lock().push(before);

}

if let Some(after_in_parent) = after_in_parent {

vm.state.after_forkers_parent.lock().push(after_in_parent);

}

if let Some(after_in_child) = after_in_child {

vm.state.after_forkers_child.lock().push(after_in_child);

}

Ok(())

}

fn run_at_forkers(mut funcs: Vec<PyObjectRef>, reversed: bool, vm: &VirtualMachine) {

if !funcs.is_empty() {

if reversed {

funcs.reverse();

}

for func in funcs.into_iter() {

if let Err(e) = func.call((), vm) {

let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);

vm.run_unraisable(e, Some("Exception ignored in".to_owned()), func);

if exit {

// Do nothing!

}

}

}

}

}

fn py_os_before_fork(vm: &VirtualMachine) {

let before_forkers: Vec<PyObjectRef> = vm.state.before_forkers.lock().clone();

// functions must be executed in reversed order as they are registered

// only for before_forkers, refer: test_register_at_fork in test_posix

run_at_forkers(before_forkers, true, vm);

}

fn py_os_after_fork_child(vm: &VirtualMachine) {

let after_forkers_child: Vec<PyObjectRef> = vm.state.after_forkers_child.lock().clone();

run_at_forkers(after_forkers_child, false, vm);

}

fn py_os_after_fork_parent(vm: &VirtualMachine) {

let after_forkers_parent: Vec<PyObjectRef> = vm.state.after_forkers_parent.lock().clone();

run_at_forkers(after_forkers_parent, false, vm);

}

#[pyfunction]

fn fork(vm: &VirtualMachine) -> i32 {

let pid: i32;

py_os_before_fork(vm);

unsafe {

pid = libc::fork();

}

if pid == 0 {

py_os_after_fork_child(vm);

} else {

py_os_after_fork_parent(vm);

}

pid

}

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

const MKNOD_DIR_FD: bool = cfg!(not(target_vendor = "apple"));

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

#[derive(FromArgs)]

struct MknodArgs {

#[pyarg(any)]

path: OsPath,

#[pyarg(any)]

mode: libc::mode_t,

#[pyarg(any)]

device: libc::dev_t,

#[pyarg(flatten)]

dir_fd: DirFd<{ MKNOD_DIR_FD as usize }>,

}

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

impl MknodArgs {

fn _mknod(self, vm: &VirtualMachine) -> PyResult<i32> {

Ok(unsafe {

libc::mknod(

self.path.clone().into_cstring(vm)?.as_ptr(),

self.mode,

self.device,

)

})

}

#[cfg(not(target_vendor = "apple"))]

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

let ret = match self.dir_fd.get_opt() {

None => self._mknod(vm)?,

Some(non_default_fd) => unsafe {

libc::mknodat(

non_default_fd,

self.path.clone().into_cstring(vm)?.as_ptr(),

self.mode,

self.device,

)

},

};

if ret != 0 {

Err(errno_err(vm))

} else {

Ok(())

}

}

#[cfg(target_vendor = "apple")]

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

let [] = self.dir_fd.0;

let ret = self._mknod(vm)?;

if ret != 0 {

Err(errno_err(vm))

} else {

Ok(())

}

}

}

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

#[pyfunction]

fn mknod(args: MknodArgs, vm: &VirtualMachine) -> PyResult<()> {

args.mknod(vm)

}

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

#[pyfunction]

fn nice(increment: i32, vm: &VirtualMachine) -> PyResult<i32> {

use nix::errno::{errno, Errno};

Errno::clear();

let res = unsafe { libc::nice(increment) };

if res == -1 && errno() != 0 {

Err(errno_err(vm))

} else {

Ok(res)

}

}

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

#[pyfunction]

fn sched_get_priority_max(policy: i32, vm: &VirtualMachine) -> PyResult<i32> {

let max = unsafe { libc::sched_get_priority_max(policy) };

if max == -1 {

Err(errno_err(vm))

} else {

Ok(max)

}

}

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

#[pyfunction]

fn sched_get_priority_min(policy: i32, vm: &VirtualMachine) -> PyResult<i32> {

let min = unsafe { libc::sched_get_priority_min(policy) };

if min == -1 {

Err(errno_err(vm))

} else {

Ok(min)

}

}

#[pyfunction]

fn sched_yield(vm: &VirtualMachine) -> PyResult<()> {

nix::sched::sched_yield().map_err(|e| e.into_pyexception(vm))

}

#[pyattr]

#[pyclass(name = "sched_param")]

#[derive(Debug, PyPayload)]

struct SchedParam {

sched_priority: PyObjectRef,

}

impl TryFromObject for SchedParam {

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

Ok(SchedParam {

sched_priority: obj,

})

}

}

#[pyclass(with(Constructor, Representable))]

impl SchedParam {

#[pygetset]

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

self.sched_priority.clone().to_pyobject(vm)

}

#[cfg(any(

#[cfg(not(target_env = "musl"))]

fn try_to_libc(&self, vm: &VirtualMachine) -> PyResult<libc::sched_param> {

use crate::AsObject;

let priority_class = self.sched_priority.class();

let priority_type = priority_class.name();

let priority = self.sched_priority.clone();

let value = priority.downcast::<PyInt>().map_err(|_| {

vm.new_type_error(format!("an integer is required (got type {priority_type})"))

})?;

let sched_priority = value.try_to_primitive(vm)?;

Ok(libc::sched_param { sched_priority })

}

}

#[derive(FromArgs)]

pub struct SchedParamArg {

sched_priority: PyObjectRef,

}

impl Constructor for SchedParam {

type Args = SchedParamArg;

fn py_new(cls: PyTypeRef, arg: Self::Args, vm: &VirtualMachine) -> PyResult {

SchedParam {

sched_priority: arg.sched_priority,

}

.into_ref_with_type(vm, cls)

.map(Into::into)

}

}

impl Representable for SchedParam {

#[inline]

fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {

let sched_priority_repr = zelf.sched_priority.repr(vm)?;

Ok(format!(

"posix.sched_param(sched_priority = {})",

sched_priority_repr.as_str()

))

}

}

#[cfg(any(

#[pyfunction]

fn sched_getscheduler(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<i32> {

let policy = unsafe { libc::sched_getscheduler(pid) };

if policy == -1 {

Err(errno_err(vm))

} else {

Ok(policy)

}

}

#[cfg(any(

#[derive(FromArgs)]

struct SchedSetschedulerArgs {

#[pyarg(positional)]

pid: i32,

#[pyarg(positional)]

policy: i32,

#[pyarg(positional)]

sched_param_obj: crate::PyRef<SchedParam>,

}

#[cfg(any(

#[cfg(not(target_env = "musl"))]

#[pyfunction]

fn sched_setscheduler(args: SchedSetschedulerArgs, vm: &VirtualMachine) -> PyResult<i32> {

let libc_sched_param = args.sched_param_obj.try_to_libc(vm)?;

let policy = unsafe { libc::sched_setscheduler(args.pid, args.policy, &libc_sched_param) };

if policy == -1 {

Err(errno_err(vm))

} else {

Ok(policy)

}

}

#[cfg(any(

#[pyfunction]

fn sched_getparam(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<SchedParam> {

let param = unsafe {

let mut param = std::mem::MaybeUninit::uninit();

if -1 == libc::sched_getparam(pid, param.as_mut_ptr()) {

return Err(errno_err(vm));

}

param.assume_init()

};

Ok(SchedParam {

sched_priority: param.sched_priority.to_pyobject(vm),

})

}

#[cfg(any(

#[derive(FromArgs)]

struct SchedSetParamArgs {

#[pyarg(positional)]

pid: i32,

#[pyarg(positional)]

sched_param_obj: crate::PyRef<SchedParam>,

}

#[cfg(any(

#[cfg(not(target_env = "musl"))]

#[pyfunction]

fn sched_setparam(args: SchedSetParamArgs, vm: &VirtualMachine) -> PyResult<i32> {

let libc_sched_param = args.sched_param_obj.try_to_libc(vm)?;

let ret = unsafe { libc::sched_setparam(args.pid, &libc_sched_param) };

if ret == -1 {

Err(errno_err(vm))

} else {

Ok(ret)

}

}

#[pyfunction]

fn get_inheritable(fd: RawFd, vm: &VirtualMachine) -> PyResult<bool> {

let flags = fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFD);

match flags {