match cvt(syscall::clone(0))? {
0 => {
drop(input);
- let err = self.do_exec(theirs);
+ let Err(err) = self.do_exec(theirs);
let errno = err.raw_os_error().unwrap_or(syscall::EINVAL) as u32;
let bytes = [
(errno >> 24) as u8,
}
match self.setup_io(default, true) {
- Ok((_, theirs)) => unsafe { self.do_exec(theirs) },
+ Ok((_, theirs)) => unsafe {
+ let Err(e) = self.do_exec(theirs);
+ e
+ },
Err(e) => e,
}
}
// allocation). Instead we just close it manually. This will never
// have the drop glue anyway because this code never returns (the
// child will either exec() or invoke syscall::exit)
- unsafe fn do_exec(&mut self, stdio: ChildPipes) -> io::Error {
+ unsafe fn do_exec(&mut self, stdio: ChildPipes) -> Result<!, io::Error> {
if let Some(fd) = stdio.stderr.fd() {
cvt(syscall::dup2(fd, 2, &[]))?;
let mut flags = cvt(syscall::fcntl(2, syscall::F_GETFD, 0))?;
let mut file = if let Some(program) = program {
File::open(program.as_os_str())?
} else {
- return io::Error::from_raw_os_error(syscall::ENOENT);
+ return Err(io::Error::from_raw_os_error(syscall::ENOENT));
};
// Push all the arguments
meta.mode() & 0o7
};
if mode & 1 == 0 {
- return io::Error::from_raw_os_error(syscall::EPERM);
+ return Err(io::Error::from_raw_os_error(syscall::EPERM));
}
// Second of all, we need to actually read which interpreter it wants
}
if let Err(err) = syscall::fexec(file.as_raw_fd(), &args, &vars) {
- io::Error::from_raw_os_error(err.errno as i32)
+ Err(io::Error::from_raw_os_error(err.errno as i32))
} else {
panic!("return from exec without err");
}
}
-
fn setup_io(&self, default: Stdio, needs_stdin: bool)
-> io::Result<(StdioPipes, ChildPipes)> {
let null = Stdio::Null;
match result {
0 => {
drop(input);
- let err = self.do_exec(theirs, envp.as_ref());
+ let Err(err) = self.do_exec(theirs, envp.as_ref());
let errno = err.raw_os_error().unwrap_or(libc::EINVAL) as u32;
let bytes = [
(errno >> 24) as u8,
// environment lock before we try to exec.
let _lock = sys::os::env_lock();
- self.do_exec(theirs, envp.as_ref())
+ let Err(e) = self.do_exec(theirs, envp.as_ref());
+ e
}
}
Err(e) => e,
&mut self,
stdio: ChildPipes,
maybe_envp: Option<&CStringArray>
- ) -> io::Error {
+ ) -> Result<!, io::Error> {
use crate::sys::{self, cvt_r};
if let Some(fd) = stdio.stdin.fd() {
ptr::null_mut()))?;
let ret = sys::signal(libc::SIGPIPE, libc::SIG_DFL);
if ret == libc::SIG_ERR {
- return io::Error::last_os_error()
+ return Err(io::Error::last_os_error())
}
}
}
libc::execvp(self.get_argv()[0], self.get_argv().as_ptr());
- io::Error::last_os_error()
+ Err(io::Error::last_os_error())
}
#[cfg(not(any(target_os = "macos", target_os = "freebsd",