1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 use libc
::{self, c_int}
;
18 use sys
::fd
::FileDesc
;
20 ////////////////////////////////////////////////////////////////////////////////
22 ////////////////////////////////////////////////////////////////////////////////
24 pub struct AnonPipe(FileDesc
);
26 pub fn anon_pipe() -> io
::Result
<(AnonPipe
, AnonPipe
)> {
29 // Unfortunately the only known way right now to create atomically set the
30 // CLOEXEC flag is to use the `pipe2` syscall on Linux. This was added in
31 // 2.6.27, however, and because we support 2.6.18 we must detect this
32 // support dynamically.
33 if cfg
!(target_os
= "linux") {
34 weak
! { fn pipe2(*mut c_int, c_int) -> c_int }
35 if let Some(pipe
) = pipe2
.get() {
36 match cvt_r(|| unsafe { pipe(fds.as_mut_ptr(), libc::O_CLOEXEC) }
) {
38 return Ok((AnonPipe(FileDesc
::new(fds
[0])),
39 AnonPipe(FileDesc
::new(fds
[1]))))
41 Err(ref e
) if e
.raw_os_error() == Some(libc
::ENOSYS
) => {}
42 Err(e
) => return Err(e
),
46 if unsafe { libc::pipe(fds.as_mut_ptr()) == 0 }
{
47 Ok((AnonPipe
::from_fd(fds
[0]), AnonPipe
::from_fd(fds
[1])))
49 Err(io
::Error
::last_os_error())
54 pub fn from_fd(fd
: libc
::c_int
) -> AnonPipe
{
55 let fd
= FileDesc
::new(fd
);
60 pub fn read(&self, buf
: &mut [u8]) -> io
::Result
<usize> {
64 pub fn read_to_end(&self, buf
: &mut Vec
<u8>) -> io
::Result
<usize> {
65 self.0.read_to_end(buf
)
68 pub fn write(&self, buf
: &[u8]) -> io
::Result
<usize> {
72 pub fn fd(&self) -> &FileDesc { &self.0 }
73 pub fn into_fd(self) -> FileDesc { self.0 }
76 pub fn read2(p1
: AnonPipe
,
79 v2
: &mut Vec
<u8>) -> io
::Result
<()> {
80 // Set both pipes into nonblocking mode as we're gonna be reading from both
81 // in the `select` loop below, and we wouldn't want one to block the other!
82 let p1
= p1
.into_fd();
83 let p2
= p2
.into_fd();
84 p1
.set_nonblocking(true);
85 p2
.set_nonblocking(true);
87 let max
= cmp
::max(p1
.raw(), p2
.raw());
89 // wait for either pipe to become readable using `select`
91 let mut read
: libc
::fd_set
= mem
::zeroed();
92 libc
::FD_SET(p1
.raw(), &mut read
);
93 libc
::FD_SET(p2
.raw(), &mut read
);
94 libc
::select(max
+ 1, &mut read
, 0 as *mut _
, 0 as *mut _
,
98 // Read as much as we can from each pipe, ignoring EWOULDBLOCK or
99 // EAGAIN. If we hit EOF, then this will happen because the underlying
100 // reader will return Ok(0), in which case we'll see `Ok` ourselves. In
101 // this case we flip the other fd back into blocking mode and read
102 // whatever's leftover on that file descriptor.
103 let read
= |fd
: &FileDesc
, dst
: &mut Vec
<u8>| {
104 match fd
.read_to_end(dst
) {
107 if e
.raw_os_error() == Some(libc
::EWOULDBLOCK
) ||
108 e
.raw_os_error() == Some(libc
::EAGAIN
) {
117 p2
.set_nonblocking(false);
118 return p2
.read_to_end(v2
).map(|_
| ());
121 p1
.set_nonblocking(false);
122 return p1
.read_to_end(v1
).map(|_
| ());