Function lockf

crates/stdlib/src/fcntl.rs:164–219

(
        _io::Fildes(fd): _io::Fildes,
        cmd: i32,
        len: OptionalArg<PyIntRef>,
        start: OptionalArg<PyIntRef>,
        whence: OptionalArg<i32>,
        vm: &VirtualMachine,
    )

    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
    #[pyfunction]
    fn lockf(
        _io::Fildes(fd): _io::Fildes,
        cmd: i32,
        len: OptionalArg<PyIntRef>,
        start: OptionalArg<PyIntRef>,
        whence: OptionalArg<i32>,
        vm: &VirtualMachine,
    ) -> PyResult {
        macro_rules! try_into_l_type {
            ($l_type:path) => {
                $l_type
                    .try_into()
                    .map_err(|e| vm.new_overflow_error(format!("{e}")))
            };
        }

        let mut l: libc::flock = unsafe { core::mem::zeroed() };
        l.l_type = if cmd == libc::LOCK_UN {
            try_into_l_type!(libc::F_UNLCK)
        } else if (cmd & libc::LOCK_SH) != 0 {
            try_into_l_type!(libc::F_RDLCK)
        } else if (cmd & libc::LOCK_EX) != 0 {
            try_into_l_type!(libc::F_WRLCK)
        } else {
            return Err(vm.new_value_error("unrecognized lockf argument"));
        }?;
        l.l_start = match start {
            OptionalArg::Present(s) => s.try_to_primitive(vm)?,
            OptionalArg::Missing => 0,
        };
        l.l_len = match len {
            OptionalArg::Present(l_) => l_.try_to_primitive(vm)?,
            OptionalArg::Missing => 0,
        };
        l.l_whence = match whence {
            OptionalArg::Present(w) => w
                .try_into()
                .map_err(|e| vm.new_overflow_error(format!("{e}")))?,
            OptionalArg::Missing => 0,
        };
        let ret = unsafe {
            libc::fcntl(
                fd,
                if (cmd & libc::LOCK_NB) != 0 {
                    libc::F_SETLK
                } else {
                    libc::F_SETLKW
                },
                &l,
            )
        };
        if ret < 0 {
            return Err(vm.new_last_errno_error());
        }
        Ok(vm.ctx.new_int(ret).into())
    }
}