Mercurial > hg
view rust/chg/src/procutil.rs @ 50824:489268c8ee7e
cmdutil: migrate `opts` on commitstatus() to native kwargs
author | Matt Harbison <matt_harbison@yahoo.com> |
---|---|
date | Sat, 19 Aug 2023 23:06:40 -0400 |
parents | 426294d06ddc |
children |
line wrap: on
line source
// Copyright 2018 Yuya Nishihara <yuya@tcha.org> // // This software may be used and distributed according to the terms of the // GNU General Public License version 2 or any later version. //! Low-level utility for signal and process handling. use libc::{self, c_int, pid_t, size_t, ssize_t}; use std::io; use std::os::unix::io::RawFd; use std::sync; #[link(name = "procutil", kind = "static")] extern "C" { // sendfds.c fn sendfds(sockfd: c_int, fds: *const c_int, fdlen: size_t) -> ssize_t; // sighandlers.c fn setupsignalhandler(pid: pid_t, pgid: pid_t) -> c_int; fn restoresignalhandler() -> c_int; } /// Returns the effective uid of the current process. pub fn get_effective_uid() -> u32 { unsafe { libc::geteuid() } } /// Returns the umask of the current process. /// /// # Safety /// /// This is unsafe because the umask value is temporarily changed, and /// the change can be observed from the other threads. Don't call this in /// multi-threaded context. pub unsafe fn get_umask() -> u32 { let mask = libc::umask(0); libc::umask(mask); mask } /// Changes the given fd to blocking mode. pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> { let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; if flags < 0 { return Err(io::Error::last_os_error()); } let r = unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) }; if r < 0 { return Err(io::Error::last_os_error()); } Ok(()) } /// Sends file descriptors via the given socket. pub fn send_raw_fds(sock_fd: RawFd, fds: &[RawFd]) -> io::Result<()> { let r = unsafe { sendfds(sock_fd, fds.as_ptr(), fds.len() as size_t) }; if r < 0 { return Err(io::Error::last_os_error()); } Ok(()) } static SETUP_SIGNAL_HANDLER: sync::Once = sync::Once::new(); static RESTORE_SIGNAL_HANDLER: sync::Once = sync::Once::new(); /// Installs signal handlers to forward signals to the server. /// /// # Safety /// /// This touches global states, and thus synchronized as a one-time /// initialization function. pub fn setup_signal_handler_once( pid: u32, pgid: Option<u32>, ) -> io::Result<()> { let pid_signed = pid as i32; let pgid_signed = pgid.map(|n| n as i32).unwrap_or(0); let mut r = 0; SETUP_SIGNAL_HANDLER.call_once(|| { r = unsafe { setupsignalhandler(pid_signed, pgid_signed) }; }); if r < 0 { return Err(io::Error::last_os_error()); } Ok(()) } /// Restores the original signal handlers. /// /// # Safety /// /// This touches global states, and thus synchronized as a one-time /// initialization function. pub fn restore_signal_handler_once() -> io::Result<()> { let mut r = 0; RESTORE_SIGNAL_HANDLER.call_once(|| { r = unsafe { restoresignalhandler() }; }); if r < 0 { return Err(io::Error::last_os_error()); } Ok(()) }