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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

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 21020

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 {