return Err(UvError(uvll::EBADF));
}
+ // libuv was recently changed to not close the stdio file descriptors,
+ // but it did not change the behavior for windows. Until this issue is
+ // fixed, we need to dup the stdio file descriptors because otherwise
+ // uv_close will close them
+ let fd = if cfg!(windows) && fd <= libc::STDERR_FILENO {
+ unsafe { libc::dup(fd) }
+ } else { fd };
+
// If this file descriptor is indeed guessed to be a tty, then go ahead
// with attempting to open it as a tty.
let handle = UvHandle::alloc(None::<TtyWatcher>, uvll::UV_TTY);
}
fn tty_open(&mut self, fd: c_int, _readable: bool) -> IoResult<~RtioTTY> {
if unsafe { libc::isatty(fd) } != 0 {
- Ok(~file::FileDesc::new(fd, true) as ~RtioTTY)
+ // Don't ever close the stdio file descriptors, nothing good really
+ // comes of that.
+ Ok(~file::FileDesc::new(fd, fd > libc::STDERR_FILENO) as ~RtioTTY)
} else {
Err(IoError {
kind: io::MismatchedFileTypeForOperation,
use option::{Option, Some, None};
use result::{Ok, Err};
use io::buffered::LineBufferedWriter;
-use rt::rtio::{IoFactory, RtioTTY, RtioFileStream, with_local_io,
- CloseAsynchronously};
+use rt::rtio::{IoFactory, RtioTTY, RtioFileStream, with_local_io, DontClose};
use super::{Reader, Writer, io_error, IoError, OtherIoError,
standard_error, EndOfFile};
fn src<T>(fd: libc::c_int, readable: bool, f: |StdSource| -> T) -> T {
with_local_io(|io| {
- let fd = unsafe { libc::dup(fd) };
match io.tty_open(fd, readable) {
Ok(tty) => Some(f(TTY(tty))),
- Err(_) => {
- // It's not really that desirable if these handles are closed
- // synchronously, and because they're squirreled away in a task
- // structure the destructors will be run when the task is
- // attempted to get destroyed. This means that if we run a
- // synchronous destructor we'll attempt to do some scheduling
- // operations which will just result in sadness.
- Some(f(File(io.fs_from_raw_fd(fd, CloseAsynchronously))))
- }
+ Err(_) => Some(f(File(io.fs_from_raw_fd(fd, DontClose)))),
}
}).unwrap()
}