( )⚙ D8382 rust-chg: send client side umask to server

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8382

rust-chg: send client side umask to server
ClosedPublic

Authored by yuja on Apr 6 2020, 10:19 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG065048e66f32: rust-chg: send client side umask to server
Summary

This is equivalent to forwardumask() of hgclient.c.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

yuja created this revision.Apr 6 2020, 10:19 AM
Alphare accepted this revision.Apr 8 2020, 4:41 AM
yuja added a commit: rHG065048e66f32: rust-chg: send client side umask to server.Apr 9 2020, 3:26 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG065048e66f32: rust-chg: send client side umask to server (authored by yuja). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 20998

rust/chg/src/clientext.rs

// Copyright 2018 Yuya Nishihara <yuya@tcha.org> // Copyright 2018 Yuya Nishihara <yuya@tcha.org>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! cHg extensions to command server client. //! cHg extensions to command server client.
use bytes::Bytes; use bytes::{BufMut, Bytes, BytesMut};
use std::ffi::OsStr; use std::ffi::OsStr;
use std::io; use std::io;
use std::mem;
use std::os::unix::ffi::OsStrExt; use std::os::unix::ffi::OsStrExt;
use std::os::unix::io::AsRawFd; use std::os::unix::io::AsRawFd;
use std::path::Path; use std::path::Path;
use tokio_hglib::protocol::{OneShotQuery, OneShotRequest}; use tokio_hglib::protocol::{OneShotQuery, OneShotRequest};
use tokio_hglib::{Client, Connection}; use tokio_hglib::{Client, Connection};
use super::attachio::AttachIo; use super::attachio::AttachIo;
use super::message::{self, Instruction}; use super::message::{self, Instruction};
P: AsRef<Path>; P: AsRef<Path>;
/// Updates the environment variables of the server. /// Updates the environment variables of the server.
fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C> fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C>
where where
I: IntoIterator<Item = (P, P)>, I: IntoIterator<Item = (P, P)>,
P: AsRef<OsStr>; P: AsRef<OsStr>;
/// Changes the umask of the server process.
fn set_umask(self, mask: u32) -> OneShotRequest<C>;
/// Runs the specified Mercurial command with cHg extension. /// Runs the specified Mercurial command with cHg extension.
fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H> fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H>
where where
I: IntoIterator<Item = P>, I: IntoIterator<Item = P>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
H: SystemHandler; H: SystemHandler;
/// Validates if the server can run Mercurial commands with the expected /// Validates if the server can run Mercurial commands with the expected
fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C> fn set_env_vars_os<I, P>(self, vars: I) -> OneShotRequest<C>
where where
I: IntoIterator<Item = (P, P)>, I: IntoIterator<Item = (P, P)>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
{ {
OneShotRequest::start_with_args(self, b"setenv", message::pack_env_vars_os(vars)) OneShotRequest::start_with_args(self, b"setenv", message::pack_env_vars_os(vars))
} }
fn set_umask(self, mask: u32) -> OneShotRequest<C> {
let mut args = BytesMut::with_capacity(mem::size_of_val(&mask));
args.put_u32_be(mask);
OneShotRequest::start_with_args(self, b"setumask2", args)
}
fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H> fn run_command_chg<I, P, H>(self, handler: H, args: I) -> ChgRunCommand<C, H>
where where
I: IntoIterator<Item = P>, I: IntoIterator<Item = P>,
P: AsRef<OsStr>, P: AsRef<OsStr>,
H: SystemHandler, H: SystemHandler,
{ {
ChgRunCommand::with_client(self, handler, message::pack_args_os(args)) ChgRunCommand::with_client(self, handler, message::pack_args_os(args))
} }

rust/chg/src/locator.rs

use tokio_hglib::UnixClient; use tokio_hglib::UnixClient;
use tokio_process::{Child, CommandExt}; use tokio_process::{Child, CommandExt};
use tokio_timer; use tokio_timer;
use super::clientext::ChgClientExt; use super::clientext::ChgClientExt;
use super::message::{Instruction, ServerSpec}; use super::message::{Instruction, ServerSpec};
use super::procutil; use super::procutil;
const REQUIRED_SERVER_CAPABILITIES: &[&str] = const REQUIRED_SERVER_CAPABILITIES: &[&str] = &[
&["attachio", "chdir", "runcommand", "setenv", "validate"]; "attachio",
"chdir",
"runcommand",
"setenv",
"setumask2",
"validate",
];
/// Helper to connect to and spawn a server process. /// Helper to connect to and spawn a server process.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Locator { pub struct Locator {
hg_command: OsString, hg_command: OsString,
hg_early_args: Vec<OsString>, hg_early_args: Vec<OsString>,
current_dir: PathBuf, current_dir: PathBuf,
env_vars: Vec<(OsString, OsString)>, env_vars: Vec<(OsString, OsString)>,

rust/chg/src/main.rs

let code = run().unwrap_or_else(|err| { let code = run().unwrap_or_else(|err| {
writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(()); writeln!(io::stderr(), "chg: abort: {}", err).unwrap_or(());
255 255
}); });
process::exit(code); process::exit(code);
} }
fn run() -> io::Result<i32> { fn run() -> io::Result<i32> {
let umask = unsafe { procutil::get_umask() }; // not thread safe
let mut loc = Locator::prepare_from_env()?; let mut loc = Locator::prepare_from_env()?;
loc.set_early_args(locator::collect_early_args(env::args_os().skip(1))); loc.set_early_args(locator::collect_early_args(env::args_os().skip(1)));
let handler = ChgUiHandler::new(); let handler = ChgUiHandler::new();
let (result_tx, result_rx) = oneshot::channel(); let (result_tx, result_rx) = oneshot::channel();
let fut = loc let fut = loc
.connect() .connect()
.and_then(|(_, client)| client.attach_io(io::stdin(), io::stdout(), io::stderr())) .and_then(|(_, client)| client.attach_io(io::stdin(), io::stdout(), io::stderr()))
.and_then(move |client| client.set_umask(umask))
.and_then(|client| { .and_then(|client| {
let pid = client.server_spec().process_id.unwrap(); let pid = client.server_spec().process_id.unwrap();
let pgid = client.server_spec().process_group_id; let pgid = client.server_spec().process_group_id;
procutil::setup_signal_handler_once(pid, pgid)?; procutil::setup_signal_handler_once(pid, pgid)?;
Ok(client) Ok(client)
}) })
.and_then(|client| client.run_command_chg(handler, env::args_os().skip(1))) .and_then(|client| client.run_command_chg(handler, env::args_os().skip(1)))
.map(|(_client, _handler, code)| { .map(|(_client, _handler, code)| {

rust/chg/src/procutil.rs

fn restoresignalhandler() -> c_int; fn restoresignalhandler() -> c_int;
} }
/// Returns the effective uid of the current process. /// Returns the effective uid of the current process.
pub fn get_effective_uid() -> u32 { pub fn get_effective_uid() -> u32 {
unsafe { libc::geteuid() } 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. /// Changes the given fd to blocking mode.
pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> { pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> {
let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) }; let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
if flags < 0 { if flags < 0 {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());
} }
let r = unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) }; let r = unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) };
if r < 0 { if r < 0 {