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(())

b: &'a [u8],

_vm: &VirtualMachine,

) -> PyResult<&'a std::ffi::OsStr> {

use std::os::unix::ffi::OsStrExt;

Ok(std::ffi::OsStr::from_bytes(b))

let module = module::make_module(vm);

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

module

use crate::{

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

exceptions::IntoPyException,

function::OptionalArg,

slots::SlotConstructor,

stdlib::os::{

errno_err, DirFd, FollowSymlinks, PathOrFd, PyPathLike, SupportFunc, TargetIsDirectory,

_os, fs_metadata, IOErrorWithFilename,

},

utils::{Either, ToCString},

IntoPyObject, ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromObject, VirtualMachine,

};

use bitflags::bitflags;

use nix::fcntl;

use nix::unistd::{self, Gid, Pid, Uid};

#[allow(unused_imports)] // TODO: use will be unnecessary in edition 2021

use std::convert::TryFrom;

use std::ffi::{CStr, CString};

use std::os::unix::ffi as ffi_ext;

use std::os::unix::io::RawFd;

use std::{env, fs, io};

use strum_macros::EnumString;

#[pyattr]

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

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

#[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(not(target_os = "redox"))]

#[pyattr]

use libc::{O_NDELAY, O_NOCTTY};

#[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 {

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

Ok(vm.ctx.new_list(

group_ids

.into_iter()

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

.collect(),

))

}

#[pyfunction]

pub(super) fn access(path: PyPathLike, 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 ffi_ext::OsStringExt;

let environ = vm.ctx.new_dict();

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

environ

.set_item(

vm.ctx.new_bytes(key.into_vec()),

vm.ctx.new_bytes(value.into_vec()),

vm,

)

.unwrap();

}

environ

}

#[derive(FromArgs)]

pub(super) struct SimlinkArgs {

src: PyPathLike,

dst: PyPathLike,

#[pyarg(flatten)]

_target_is_directory: TargetIsDirectory,

#[pyarg(flatten)]

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

}

#[pyfunction]

pub(super) fn symlink(args: SimlinkArgs, 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: PyPathLike, vm: &VirtualMachine) -> PyResult<()> {

nix::unistd::chroot(&*path.path).map_err(|err| err.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: PathOrFd,

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 {

PathOrFd::Path(ref p) => {

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

}

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

}

.map_err(|err| {

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

IOErrorWithFilename::new(io::Error::from_raw_os_error(err as i32), path, vm)

.into_pyexception(vm)

})

}

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

#[pyfunction]

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

chown(

PathOrFd::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(

PathOrFd::Fd(fd),

uid,

gid,

DirFd::default(),

FollowSymlinks(true),

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<()> {

let _ = nix::sched::sched_yield().map_err(|e| e.into_pyexception(vm))?;

Ok(())

}

#[pyattr]

#[pyclass(name = "sched_param")]

#[derive(Debug, PyValue)]

struct SchedParam {

sched_priority: PyObjectRef,

}

impl TryFromObject for SchedParam {

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

Ok(SchedParam {

sched_priority: obj,

})

}

}

#[pyimpl(with(SlotConstructor))]

impl SchedParam {

#[pyproperty]

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

self.sched_priority.clone().into_pyobject(vm)

}

#[pymethod(magic)]

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

let sched_priority_repr = vm.to_repr(&self.sched_priority)?;

Ok(format!(

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

sched_priority_repr.as_str()

))

}

#[cfg(any(

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

use crate::TypeProtocol;

let priority = self.sched_priority.clone();

let priority_type = priority.class().name();

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 SlotConstructor for SchedParam {

type Args = SchedParamArg;

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

SchedParam {

sched_priority: arg.sched_priority,

}

.into_pyresult_with_type(vm, cls)

}

}

#[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(

#[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.into_pyobject(vm),

})

}

#[cfg(any(

#[derive(FromArgs)]

struct SchedSetParamArgs {

#[pyarg(positional)]

pid: i32,

#[pyarg(positional)]

sched_param_obj: crate::PyRef<SchedParam>,

}

#[cfg(any(

#[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 {

Ok(ret) => Ok((ret & libc::FD_CLOEXEC) == 0),

Err(err) => Err(err.into_pyexception(vm)),

}

}

#[pyfunction]

fn set_inheritable(fd: i32, inheritable: bool, vm: &VirtualMachine) -> PyResult<()> {

super::raw_set_inheritable(fd, inheritable).map_err(|err| err.into_pyexception(vm))

}

#[pyfunction]

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

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

match flags {

Ok(ret) => Ok((ret & libc::O_NONBLOCK) == 0),

Err(err) => Err(err.into_pyexception(vm)),

}

}

#[pyfunction]

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

let _set_flag = || {

use nix::fcntl::{fcntl, FcntlArg, OFlag};

let flags = OFlag::from_bits_truncate(fcntl(fd, FcntlArg::F_GETFL)?);

let mut new_flags = flags;

new_flags.set(OFlag::from_bits_truncate(libc::O_NONBLOCK), !blocking);

if flags != new_flags {

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

}

Ok(())

};

_set_flag().map_err(|err: nix::Error| err.into_pyexception(vm))

}

#[pyfunction]

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

use nix::unistd::close;

use nix::unistd::pipe;

let (rfd, wfd) = pipe().map_err(|err| err.into_pyexception(vm))?;

set_inheritable(rfd, false, vm)

.and_then(|_| set_inheritable(wfd, false, vm))

.map_err(|err| {

let _ = close(rfd);

let _ = close(wfd);

err

})?;

Ok((rfd, wfd))

}

// cfg from nix

#[cfg(any(

#[pyfunction]

fn pipe2(flags: libc::c_int, vm: &VirtualMachine) -> PyResult<(RawFd, RawFd)> {

let oflags = fcntl::OFlag::from_bits_truncate(flags);

nix::unistd::pipe2(oflags).map_err(|err| err.into_pyexception(vm))

}

#[pyfunction]

fn system(command: PyStrRef, vm: &VirtualMachine) -> PyResult<i32> {

let cstr = command.to_cstring(vm)?;

let x = unsafe { libc::system(cstr.as_ptr()) };

Ok(x)

}

#[pyfunction]

fn chmod(

path: PyPathLike,

dir_fd: DirFd<0>,

mode: u32,

follow_symlinks: FollowSymlinks,

vm: &VirtualMachine,

) -> PyResult<()> {

let [] = dir_fd.0;

let err_path = path.clone();

let body = move || {

use std::os::unix::fs::PermissionsExt;

let meta = fs_metadata(&path, follow_symlinks.0)?;

let mut permissions = meta.permissions();

permissions.set_mode(mode);

fs::set_permissions(&path, permissions)

};

body().map_err(|err| IOErrorWithFilename::new(err, err_path, vm).into_pyexception(vm))

}

#[pyfunction]

fn execv(

path: PyPathLike,

argv: Either<PyListRef, PyTupleRef>,

vm: &VirtualMachine,

) -> PyResult<()> {

let path = path.into_cstring(vm)?;

let argv = vm.extract_elements_func(argv.as_object(), |obj| {

PyStrRef::try_from_object(vm, obj)?.to_cstring(vm)

})?;

let argv: Vec<&CStr> = argv.iter().map(|entry| entry.as_c_str()).collect();

let first = argv

.first()

.ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty".to_owned()))?;

if first.to_bytes().is_empty() {

return Err(

vm.new_value_error("execv() arg 2 first element cannot be empty".to_owned())

);

}

unistd::execv(&path, &argv)

.map(|_ok| ())

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

}

#[pyfunction]

fn execve(

path: PyPathLike,

argv: Either<PyListRef, PyTupleRef>,

env: PyDictRef,

vm: &VirtualMachine,

) -> PyResult<()> {

let path = path.into_cstring(vm)?;

let argv = vm.extract_elements_func(argv.as_object(), |obj| {

PyStrRef::try_from_object(vm, obj)?.to_cstring(vm)

})?;

let argv: Vec<&CStr> = argv.iter().map(|entry| entry.as_c_str()).collect();

let first = argv

.first()

.ok_or_else(|| vm.new_value_error("execve() arg 2 must not be empty".to_owned()))?;

if first.to_bytes().is_empty() {

return Err(

vm.new_value_error("execve() arg 2 first element cannot be empty".to_owned())

);

}

let env = env

.into_iter()

.map(|(k, v)| -> PyResult<_> {

let (key, value) = (

PyPathLike::try_from_object(vm, k)?.into_bytes(),

PyPathLike::try_from_object(vm, v)?.into_bytes(),

);

if memchr::memchr(b'=', &key).is_some() {

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

}

let mut entry = key;

entry.push(b'=');

entry.extend_from_slice(&value);

CString::new(entry).map_err(|err| err.into_pyexception(vm))

})

.collect::<Result<Vec<_>, _>>()?;

let env: Vec<&CStr> = env.iter().map(|entry| entry.as_c_str()).collect();

unistd::execve(&path, &argv, &env).map_err(|err| err.into_pyexception(vm))?;

Ok(())

}

#[pyfunction]

fn getppid(vm: &VirtualMachine) -> PyObjectRef {

let ppid = unistd::getppid().as_raw();

vm.ctx.new_int(ppid)

}

#[pyfunction]

fn getgid(vm: &VirtualMachine) -> PyObjectRef {

let gid = unistd::getgid().as_raw();

vm.ctx.new_int(gid)

}

#[pyfunction]

fn getegid(vm: &VirtualMachine) -> PyObjectRef {

let egid = unistd::getegid().as_raw();