feat: I/O safety for 'sys/termios' & 'pty'

9 files changed, 99 insertions, 193 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f6ee0fc5..c75e875e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,9 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   ([#1862](https://github.com/nix-rust/nix/pull/1862))
 - The epoll interface now uses a type.
   ([#1882](https://github.com/nix-rust/nix/pull/1882))
+- With I/O-safe type applied in `pty::OpenptyResult` and `pty::ForkptyResult`,
+  users no longer need to manually close the file descriptors in these types.
+  ([#1921](https://github.com/nix-rust/nix/pull/1921))
 
 ### Fixed
 ### Removed
diff --git a/Cargo.toml b/Cargo.toml
index ad9d29fc..e0cfac14 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -108,7 +108,3 @@ path = "test/test_clearenv.rs"
 name = "test-mount"
 path = "test/test_mount.rs"
 harness = false
-
-[[test]]
-name = "test-ptymaster-drop"
-path = "test/test_ptymaster_drop.rs"
diff --git a/src/pty.rs b/src/pty.rs
index 28ae5e92..2866c6df 100644
--- a/src/pty.rs
+++ b/src/pty.rs
@@ -16,26 +16,24 @@ use crate::{fcntl, unistd, Result};
 
 /// Representation of a master/slave pty pair
 ///
-/// This is returned by `openpty`.  Note that this type does *not* implement `Drop`, so the user
-/// must manually close the file descriptors.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+/// This is returned by [`openpty`].
+#[derive(Debug)]
 pub struct OpenptyResult {
     /// The master port in a virtual pty pair
-    pub master: RawFd,
+    pub master: OwnedFd,
     /// The slave port in a virtual pty pair
-    pub slave: RawFd,
+    pub slave: OwnedFd,
 }
 
 feature! {
 #![feature = "process"]
 /// Representation of a master with a forked pty
 ///
-/// This is returned by `forkpty`. Note that this type does *not* implement `Drop`, so the user
-/// must manually close the file descriptors.
-#[derive(Clone, Copy, Debug)]
+/// This is returned by [`forkpty`].
+#[derive(Debug)]
 pub struct ForkptyResult {
     /// The master port in a virtual pty pair
-    pub master: RawFd,
+    pub master: OwnedFd,
     /// Metadata about forked process
     pub fork_result: ForkResult,
 }
@@ -43,51 +41,33 @@ pub struct ForkptyResult {
 
 /// Representation of the Master device in a master/slave pty pair
 ///
-/// While this datatype is a thin wrapper around `RawFd`, it enforces that the available PTY
-/// functions are given the correct file descriptor. Additionally this type implements `Drop`,
-/// so that when it's consumed or goes out of scope, it's automatically cleaned-up.
-#[derive(Debug, Eq, Hash, PartialEq)]
-pub struct PtyMaster(RawFd);
+/// While this datatype is a thin wrapper around `OwnedFd`, it enforces that the available PTY
+/// functions are given the correct file descriptor.
+#[derive(Debug)]
+pub struct PtyMaster(OwnedFd);
 
 impl AsRawFd for PtyMaster {
     fn as_raw_fd(&self) -> RawFd {
-        self.0
+        self.0.as_raw_fd()
     }
 }
 
 impl IntoRawFd for PtyMaster {
     fn into_raw_fd(self) -> RawFd {
         let fd = self.0;
-        mem::forget(self);
-        fd
-    }
-}
-
-impl Drop for PtyMaster {
-    fn drop(&mut self) {
-        // On drop, we ignore errors like EINTR and EIO because there's no clear
-        // way to handle them, we can't return anything, and (on FreeBSD at
-        // least) the file descriptor is deallocated in these cases.  However,
-        // we must panic on EBADF, because it is always an error to close an
-        // invalid file descriptor.  That frequently indicates a double-close
-        // condition, which can cause confusing errors for future I/O
-        // operations.
-        let e = unistd::close(self.0);
-        if e == Err(Errno::EBADF) {
-            panic!("Closing an invalid file descriptor!");
-        };
+        fd.into_raw_fd()
     }
 }
 
 impl io::Read for PtyMaster {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        unistd::read(self.0, buf).map_err(io::Error::from)
+        unistd::read(self.0.as_raw_fd(), buf).map_err(io::Error::from)
     }
 }
 
 impl io::Write for PtyMaster {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        unistd::write(self.0, buf).map_err(io::Error::from)
+        unistd::write(self.0.as_raw_fd(), buf).map_err(io::Error::from)
     }
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
@@ -96,13 +76,13 @@ impl io::Write for PtyMaster {
 
 impl io::Read for &PtyMaster {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        unistd::read(self.0, buf).map_err(io::Error::from)
+        unistd::read(self.0.as_raw_fd(), buf).map_err(io::Error::from)
     }
 }
 
 impl io::Write for &PtyMaster {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        unistd::write(self.0, buf).map_err(io::Error::from)
+        unistd::write(self.0.as_raw_fd(), buf).map_err(io::Error::from)
     }
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
@@ -164,7 +144,7 @@ pub fn posix_openpt(flags: fcntl::OFlag) -> Result<PtyMaster> {
         return Err(Errno::last());
     }
 
-    Ok(PtyMaster(fd))
+    Ok(PtyMaster(unsafe { OwnedFd::from_raw_fd(fd) }))
 }
 
 /// Get the name of the slave pseudoterminal (see
@@ -308,8 +288,8 @@ pub fn openpty<
 
     unsafe {
         Ok(OpenptyResult {
-            master: master.assume_init(),
-            slave: slave.assume_init(),
+            master: OwnedFd::from_raw_fd(master.assume_init()),
+            slave: OwnedFd::from_raw_fd(slave.assume_init()),
         })
     }
 }
@@ -364,7 +344,7 @@ pub unsafe fn forkpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b T
     })?;
 
     Ok(ForkptyResult {
-        master: master.assume_init(),
+        master: OwnedFd::from_raw_fd(master.assume_init()),
         fork_result,
     })
 }
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
index fba2cd82..4cc635bc 100644
--- a/src/sys/termios.rs
+++ b/src/sys/termios.rs
@@ -222,7 +222,7 @@ use libc::{self, c_int, tcflag_t};
 use std::cell::{Ref, RefCell};
 use std::convert::From;
 use std::mem;
-use std::os::unix::io::RawFd;
+use std::os::unix::io::{AsFd, AsRawFd};
 
 #[cfg(feature = "process")]
 use crate::unistd::Pid;
@@ -1143,10 +1143,12 @@ pub fn cfmakesane(termios: &mut Termios) {
 /// `tcgetattr()` returns a `Termios` structure with the current configuration for a port. Modifying
 /// this structure *will not* reconfigure the port, instead the modifications should be done to
 /// the `Termios` structure and then the port should be reconfigured using `tcsetattr()`.
-pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
+pub fn tcgetattr<Fd: AsFd>(fd: &Fd) -> Result<Termios> {
     let mut termios = mem::MaybeUninit::uninit();
 
-    let res = unsafe { libc::tcgetattr(fd, termios.as_mut_ptr()) };
+    let res = unsafe {
+        libc::tcgetattr(fd.as_fd().as_raw_fd(), termios.as_mut_ptr())
+    };
 
     Errno::result(res)?;
 
@@ -1159,18 +1161,26 @@ pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
 /// `tcsetattr()` reconfigures the given port based on a given `Termios` structure. This change
 /// takes affect at a time specified by `actions`. Note that this function may return success if
 /// *any* of the parameters were successfully set, not only if all were set successfully.
-pub fn tcsetattr(fd: RawFd, actions: SetArg, termios: &Termios) -> Result<()> {
+pub fn tcsetattr<Fd: AsFd>(
+    fd: &Fd,
+    actions: SetArg,
+    termios: &Termios,
+) -> Result<()> {
     let inner_termios = termios.get_libc_termios();
     Errno::result(unsafe {
-        libc::tcsetattr(fd, actions as c_int, &*inner_termios)
+        libc::tcsetattr(
+            fd.as_fd().as_raw_fd(),
+            actions as c_int,
+            &*inner_termios,
+        )
     })
     .map(drop)
 }
 
 /// Block until all output data is written (see
 /// [tcdrain(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcdrain.html)).
-pub fn tcdrain(fd: RawFd) -> Result<()> {
-    Errno::result(unsafe { libc::tcdrain(fd) }).map(drop)
+pub fn tcdrain<Fd: AsFd>(fd: &Fd) -> Result<()> {
+    Errno::result(unsafe { libc::tcdrain(fd.as_fd().as_raw_fd()) }).map(drop)
 }
 
 /// Suspend or resume the transmission or reception of data (see
@@ -1178,8 +1188,11 @@ pub fn tcdrain(fd: RawFd) -> Result<()> {
 ///
 /// `tcflow()` suspends of resumes the transmission or reception of data for the given port
 /// depending on the value of `action`.
-pub fn tcflow(fd: RawFd, action: FlowArg) -> Result<()> {
-    Errno::result(unsafe { libc::tcflow(fd, action as c_int) }).map(drop)
+pub fn tcflow<Fd: AsFd>(fd: &Fd, action: FlowArg) -> Result<()> {
+    Errno::result(unsafe {
+        libc::tcflow(fd.as_fd().as_raw_fd(), action as c_int)
+    })
+    .map(drop)
 }
 
 /// Discard data in the output or input queue (see
@@ -1187,8 +1200,11 @@ pub fn tcflow(fd: RawFd, action: FlowArg) -> Result<()> {
 ///
 /// `tcflush()` will discard data for a terminal port in the input queue, output queue, or both
 /// depending on the value of `action`.
-pub fn tcflush(fd: RawFd, action: FlushArg) -> Result<()> {
-    Errno::result(unsafe { libc::tcflush(fd, action as c_int) }).map(drop)
+pub fn tcflush<Fd: AsFd>(fd: &Fd, action: FlushArg) -> Result<()> {
+    Errno::result(unsafe {
+        libc::tcflush(fd.as_fd().as_raw_fd(), action as c_int)
+    })
+    .map(drop)
 }
 
 /// Send a break for a specific duration (see
@@ -1196,16 +1212,19 @@ pub fn tcflush(fd: RawFd, action: FlushArg) -> Result<()> {
 ///
 /// When using asynchronous data transmission `tcsendbreak()` will transmit a continuous stream
 /// of zero-valued bits for an implementation-defined duration.
-pub fn tcsendbreak(fd: RawFd, duration: c_int) -> Result<()> {
-    Errno::result(unsafe { libc::tcsendbreak(fd, duration) }).map(drop)
+pub fn tcsendbreak<Fd: AsFd>(fd: &Fd, duration: c_int) -> Result<()> {
+    Errno::result(unsafe {
+        libc::tcsendbreak(fd.as_fd().as_raw_fd(), duration)
+    })
+    .map(drop)
 }
 
 feature! {
 #![feature = "process"]
 /// Get the session controlled by the given terminal (see
 /// [tcgetsid(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetsid.html)).
-pub fn tcgetsid(fd: RawFd) -> Result<Pid> {
-    let res = unsafe { libc::tcgetsid(fd) };
+pub fn tcgetsid<Fd: AsFd>(fd: &Fd) -> Result<Pid> {
+    let res = unsafe { libc::tcgetsid(fd.as_fd().as_raw_fd()) };
 
     Errno::result(res).map(Pid::from_raw)
 }
diff --git a/test/sys/test_termios.rs b/test/sys/test_termios.rs
index aaf00084..cf55b10c 100644
--- a/test/sys/test_termios.rs
+++ b/test/sys/test_termios.rs
@@ -1,17 +1,17 @@
-use std::os::unix::prelude::*;
+use std::os::unix::io::{AsFd, AsRawFd};
 use tempfile::tempfile;
 
 use nix::errno::Errno;
 use nix::fcntl;
 use nix::pty::openpty;
 use nix::sys::termios::{self, tcgetattr, LocalFlags, OutputFlags};
-use nix::unistd::{close, read, write};
+use nix::unistd::{read, write};
 
-/// Helper function analogous to `std::io::Write::write_all`, but for `RawFd`s
-fn write_all(f: RawFd, buf: &[u8]) {
+/// Helper function analogous to `std::io::Write::write_all`, but for `Fd`s
+fn write_all<Fd: AsFd>(f: &Fd, buf: &[u8]) {
     let mut len = 0;
     while len < buf.len() {
-        len += write(f, &buf[len..]).unwrap();
+        len += write(f.as_fd().as_raw_fd(), &buf[len..]).unwrap();
     }
 }
 
@@ -22,25 +22,14 @@ fn test_tcgetattr_pty() {
     let _m = crate::PTSNAME_MTX.lock();
 
     let pty = openpty(None, None).expect("openpty failed");
-    termios::tcgetattr(pty.slave).unwrap();
-    close(pty.master).expect("closing the master failed");
-    close(pty.slave).expect("closing the slave failed");
+    termios::tcgetattr(&pty.slave).unwrap();
 }
 
 // Test tcgetattr on something that isn't a terminal
 #[test]
 fn test_tcgetattr_enotty() {
     let file = tempfile().unwrap();
-    assert_eq!(
-        termios::tcgetattr(file.as_raw_fd()).err(),
-        Some(Errno::ENOTTY)
-    );
-}
-
-// Test tcgetattr on an invalid file descriptor
-#[test]
-fn test_tcgetattr_ebadf() {
-    assert_eq!(termios::tcgetattr(-1).err(), Some(Errno::EBADF));
+    assert_eq!(termios::tcgetattr(&file).err(), Some(Errno::ENOTTY));
 }
 
 // Test modifying output flags
@@ -52,12 +41,7 @@ fn test_output_flags() {
     // Open one pty to get attributes for the second one
     let mut termios = {
         let pty = openpty(None, None).expect("openpty failed");
-        assert!(pty.master > 0);
-        assert!(pty.slave > 0);
-        let termios = tcgetattr(pty.slave).expect("tcgetattr failed");
-        close(pty.master).unwrap();
-        close(pty.slave).unwrap();
-        termios
+        tcgetattr(&pty.slave).expect("tcgetattr failed")
     };
 
     // Make sure postprocessing '\r' isn't specified by default or this test is useless.
@@ -73,19 +57,15 @@ fn test_output_flags() {
 
     // Open a pty
     let pty = openpty(None, &termios).unwrap();
-    assert!(pty.master > 0);
-    assert!(pty.slave > 0);
 
     // Write into the master
     let string = "foofoofoo\r";
-    write_all(pty.master, string.as_bytes());
+    write_all(&pty.master, string.as_bytes());
 
     // Read from the slave verifying that the output has been properly transformed
     let mut buf = [0u8; 10];
-    crate::read_exact(pty.slave, &mut buf);
+    crate::read_exact(&pty.slave, &mut buf);
     let transformed_string = "foofoofoo\n";
-    close(pty.master).unwrap();
-    close(pty.slave).unwrap();
     assert_eq!(&buf, transformed_string.as_bytes());
 }
 
@@ -98,12 +78,7 @@ fn test_local_flags() {
     // Open one pty to get attributes for the second one
     let mut termios = {
         let pty = openpty(None, None).unwrap();
-        assert!(pty.master > 0);
-        assert!(pty.slave > 0);
-        let termios = tcgetattr(pty.slave).unwrap();
-        close(pty.master).unwrap();
-        close(pty.slave).unwrap();
-        termios
+        tcgetattr(&pty.slave).unwrap()
     };
 
     // Make sure echo is specified by default or this test is useless.
@@ -114,23 +89,19 @@ fn test_local_flags() {
 
     // Open a new pty with our modified termios settings
     let pty = openpty(None, &termios).unwrap();
-    assert!(pty.master > 0);
-    assert!(pty.slave > 0);
 
     // Set the master is in nonblocking mode or reading will never return.
-    let flags = fcntl::fcntl(pty.master, fcntl::F_GETFL).unwrap();
+    let flags = fcntl::fcntl(pty.master.as_raw_fd(), fcntl::F_GETFL).unwrap();
     let new_flags =
         fcntl::OFlag::from_bits_truncate(flags) | fcntl::OFlag::O_NONBLOCK;
-    fcntl::fcntl(pty.master, fcntl::F_SETFL(new_flags)).unwrap();
+    fcntl::fcntl(pty.master.as_raw_fd(), fcntl::F_SETFL(new_flags)).unwrap();
 
     // Write into the master
     let string = "foofoofoo\r";
-    write_all(pty.master, string.as_bytes());
+    write_all(&pty.master, string.as_bytes());
 
     // Try to read from the master, which should not have anything as echoing was disabled.
     let mut buf = [0u8; 10];
-    let read = read(pty.master, &mut buf).unwrap_err();
-    close(pty.master).unwrap();
-    close(pty.slave).unwrap();
+    let read = read(pty.master.as_raw_fd(), &mut buf).unwrap_err();
     assert_eq!(read, Errno::EAGAIN);
 }
diff --git a/test/test.rs b/test/test.rs
index 6b42aad9..b139ec3a 100644
--- a/test/test.rs
+++ b/test/test.rs
@@ -66,16 +66,16 @@ mod test_unistd;
 
 use nix::unistd::{chdir, getcwd, read};
 use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
-use std::os::unix::io::RawFd;
+use std::os::unix::io::{AsFd, AsRawFd};
 use std::path::PathBuf;
 
-/// Helper function analogous to `std::io::Read::read_exact`, but for `RawFD`s
-fn read_exact(f: RawFd, buf: &mut [u8]) {
+/// Helper function analogous to `std::io::Read::read_exact`, but for `Fd`s
+fn read_exact<Fd: AsFd>(f: &Fd, buf: &mut [u8]) {
     let mut len = 0;
     while len < buf.len() {
         // get_mut would be better than split_at_mut, but it requires nightly
         let (_, remaining) = buf.split_at_mut(len);
-        len += read(f, remaining).unwrap();
+        len += read(f.as_fd().as_raw_fd(), remaining).unwrap();
     }
 }
 
diff --git a/test/test_pty.rs b/test/test_pty.rs
index 5c27e2d6..e1286e55 100644
--- a/test/test_pty.rs
+++ b/test/test_pty.rs
@@ -2,28 +2,13 @@ use std::fs::File;
 use std::io::{Read, Write};
 use std::os::unix::prelude::*;
 use std::path::Path;
-use tempfile::tempfile;
 
 use libc::{_exit, STDOUT_FILENO};
 use nix::fcntl::{open, OFlag};
 use nix::pty::*;
 use nix::sys::stat;
 use nix::sys::termios::*;
-use nix::unistd::{close, pause, write};
-
-/// Regression test for Issue #659
-/// This is the correct way to explicitly close a `PtyMaster`
-#[test]
-fn test_explicit_close() {
-    let mut f = {
-        let m = posix_openpt(OFlag::O_RDWR).unwrap();
-        close(m.into_raw_fd()).unwrap();
-        tempfile().unwrap()
-    };
-    // This should work.  But if there's been a double close, then it will
-    // return EBADF
-    f.write_all(b"whatever").unwrap();
-}
+use nix::unistd::{pause, write};
 
 /// Test equivalence of `ptsname` and `ptsname_r`
 #[test]
@@ -50,7 +35,6 @@ fn test_ptsname_copy() {
 
     // Open a new PTTY master
     let master_fd = posix_openpt(OFlag::O_RDWR).unwrap();
-    assert!(master_fd.as_raw_fd() > 0);
 
     // Get the name of the slave
     let slave_name1 = unsafe { ptsname(&master_fd) }.unwrap();
@@ -67,7 +51,6 @@ fn test_ptsname_copy() {
 fn test_ptsname_r_copy() {
     // Open a new PTTY master
     let master_fd = posix_openpt(OFlag::O_RDWR).unwrap();
-    assert!(master_fd.as_raw_fd() > 0);
 
     // Get the name of the slave
     let slave_name1 = ptsname_r(&master_fd).unwrap();
@@ -84,11 +67,9 @@ fn test_ptsname_unique() {
 
     // Open a new PTTY master
     let master1_fd = posix_openpt(OFlag::O_RDWR).unwrap();
-    assert!(master1_fd.as_raw_fd() > 0);
 
     // Open a second PTTY master
     let master2_fd = posix_openpt(OFlag::O_RDWR).unwrap();
-    assert!(master2_fd.as_raw_fd() > 0);
 
     // Get the name of the slave
     let slave_name1 = unsafe { ptsname(&master1_fd) }.unwrap();
@@ -147,16 +128,14 @@ fn open_ptty_pair() -> (PtyMaster, File) {
 ///
 /// This uses a common `open_ptty_pair` because much of these functions aren't useful by
 /// themselves. So for this test we perform the basic act of getting a file handle for a
-/// master/slave PTTY pair, then just sanity-check the raw values.
+/// master/slave PTTY pair.
 #[test]
 fn test_open_ptty_pair() {
-    let (master, slave) = open_ptty_pair();
-    assert!(master.as_raw_fd() > 0);
-    assert!(slave.as_raw_fd() > 0);
+    let (_, _) = open_ptty_pair();
 }
 
 /// Put the terminal in raw mode.
-fn make_raw(fd: RawFd) {
+fn make_raw<Fd: AsFd>(fd: &Fd) {
     let mut termios = tcgetattr(fd).unwrap();
     cfmakeraw(&mut termios);
     tcsetattr(fd, SetArg::TCSANOW, &termios).unwrap();
@@ -166,7 +145,7 @@ fn make_raw(fd: RawFd) {
 #[test]
 fn test_read_ptty_pair() {
     let (mut master, mut slave) = open_ptty_pair();
-    make_raw(slave.as_raw_fd());
+    make_raw(&slave);
 
     let mut buf = [0u8; 5];
     slave.write_all(b"hello").unwrap();
@@ -183,7 +162,7 @@ fn test_read_ptty_pair() {
 #[test]
 fn test_write_ptty_pair() {
     let (mut master, mut slave) = open_ptty_pair();
-    make_raw(slave.as_raw_fd());
+    make_raw(&slave);
 
     let mut buf = [0u8; 5];
     master.write_all(b"adios").unwrap();
@@ -202,33 +181,28 @@ fn test_openpty() {
     let _m = crate::PTSNAME_MTX.lock();
 
     let pty = openpty(None, None).unwrap();
-    assert!(pty.master > 0);
-    assert!(pty.slave > 0);
 
     // Writing to one should be readable on the other one
     let string = "foofoofoo\n";
     let mut buf = [0u8; 10];
-    write(pty.master, string.as_bytes()).unwrap();
-    crate::read_exact(pty.slave, &mut buf);
+    write(pty.master.as_raw_fd(), string.as_bytes()).unwrap();
+    crate::read_exact(&pty.slave, &mut buf);
 
     assert_eq!(&buf, string.as_bytes());
 
     // Read the echo as well
     let echoed_string = "foofoofoo\r\n";
     let mut buf = [0u8; 11];
-    crate::read_exact(pty.master, &mut buf);
+    crate::read_exact(&pty.master, &mut buf);
     assert_eq!(&buf, echoed_string.as_bytes());
 
     let string2 = "barbarbarbar\n";
     let echoed_string2 = "barbarbarbar\r\n";
     let mut buf = [0u8; 14];
-    write(pty.slave, string2.as_bytes()).unwrap();
-    crate::read_exact(pty.master, &mut buf);
+    write(pty.slave.as_raw_fd(), string2.as_bytes()).unwrap();
+    crate::read_exact(&pty.master, &mut buf);
 
     assert_eq!(&buf, echoed_string2.as_bytes());
-
-    close(pty.master).unwrap();
-    close(pty.slave).unwrap();
 }
 
 #[test]
@@ -239,44 +213,34 @@ fn test_openpty_with_termios() {
     // Open one pty to get attributes for the second one
     let mut termios = {
         let pty = openpty(None, None).unwrap();
-        assert!(pty.master > 0);
-        assert!(pty.slave > 0);
-        let termios = tcgetattr(pty.slave).unwrap();
-        close(pty.master).unwrap();
-        close(pty.slave).unwrap();
-        termios
+        tcgetattr(&pty.slave).unwrap()
     };
     // Make sure newlines are not transformed so the data is preserved when sent.
     termios.output_flags.remove(OutputFlags::ONLCR);
 
     let pty = openpty(None, &termios).unwrap();
     // Must be valid file descriptors
-    assert!(pty.master > 0);
-    assert!(pty.slave > 0);
 
     // Writing to one should be readable on the other one
     let string = "foofoofoo\n";
     let mut buf = [0u8; 10];
-    write(pty.master, string.as_bytes()).unwrap();
-    crate::read_exact(pty.slave, &mut buf);
+    write(pty.master.as_raw_fd(), string.as_bytes()).unwrap();
+    crate::read_exact(&pty.slave, &mut buf);
 
     assert_eq!(&buf, string.as_bytes());
 
     // read the echo as well
     let echoed_string = "foofoofoo\n";
-    crate::read_exact(pty.master, &mut buf);
+    crate::read_exact(&pty.master, &mut buf);
     assert_eq!(&buf, echoed_string.as_bytes());
 
     let string2 = "barbarbarbar\n";
     let echoed_string2 = "barbarbarbar\n";
     let mut buf = [0u8; 13];
-    write(pty.slave, string2.as_bytes()).unwrap();
-    crate::read_exact(pty.master, &mut buf);
+    write(pty.slave.as_raw_fd(), string2.as_bytes()).unwrap();
+    crate::read_exact(&pty.master, &mut buf);
 
     assert_eq!(&buf, echoed_string2.as_bytes());
-
-    close(pty.master).unwrap();
-    close(pty.slave).unwrap();
 }
 
 #[test]
@@ -303,11 +267,10 @@ fn test_forkpty() {
         Parent { child } => {
             let mut buf = [0u8; 10];
             assert!(child.as_raw() > 0);
-            crate::read_exact(pty.master, &mut buf);
+            crate::read_exact(&pty.master, &mut buf);
             kill(child, SIGTERM).unwrap();
             wait().unwrap(); // keep other tests using generic wait from getting our child
             assert_eq!(&buf, echoed_string.as_bytes());
-            close(pty.master).unwrap();
         }
     }
 }
diff --git a/test/test_ptymaster_drop.rs b/test/test_ptymaster_drop.rs
deleted file mode 100644
index ffbaa569..00000000
--- a/test/test_ptymaster_drop.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-mod t {
-    use nix::fcntl::OFlag;
-    use nix::pty::*;
-    use nix::unistd::close;
-    use std::os::unix::io::AsRawFd;
-
-    /// Regression test for Issue #659
-    ///
-    /// `PtyMaster` should panic rather than double close the file descriptor
-    /// This must run in its own test process because it deliberately creates a
-    /// race condition.
-    #[test]
-    #[should_panic(expected = "Closing an invalid file descriptor!")]
-    fn test_double_close() {
-        let m = posix_openpt(OFlag::O_RDWR).unwrap();
-        close(m.as_raw_fd()).unwrap();
-        drop(m); // should panic here
-    }
-}
diff --git a/test/test_unistd.rs b/test/test_unistd.rs
index 6619262e..1d50c5fa 100644
--- a/test/test_unistd.rs
+++ b/test/test_unistd.rs
@@ -555,16 +555,13 @@ fn test_lseek() {
     const CONTENTS: &[u8] = b"abcdef123456";
     let mut tmp = tempfile().unwrap();
     tmp.write_all(CONTENTS).unwrap();
-    let tmpfd = tmp.into_raw_fd();
 
     let offset: off_t = 5;
-    lseek(tmpfd, offset, Whence::SeekSet).unwrap();
+    lseek(tmp.as_raw_fd(), offset, Whence::SeekSet).unwrap();
 
     let mut buf = [0u8; 7];
-    crate::read_exact(tmpfd, &mut buf);
+    crate::read_exact(&tmp, &mut buf);
     assert_eq!(b"f123456", &buf);
-
-    close(tmpfd).unwrap();
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -573,15 +570,12 @@ fn test_lseek64() {
     const CONTENTS: &[u8] = b"abcdef123456";
     let mut tmp = tempfile().unwrap();
     tmp.write_all(CONTENTS).unwrap();
-    let tmpfd = tmp.into_raw_fd();
 
-    lseek64(tmpfd, 5, Whence::SeekSet).unwrap();
+    lseek64(tmp.as_raw_fd(), 5, Whence::SeekSet).unwrap();
 
     let mut buf = [0u8; 7];
-    crate::read_exact(tmpfd, &mut buf);
+    crate::read_exact(&tmp, &mut buf);
     assert_eq!(b"f123456", &buf);
-
-    close(tmpfd).unwrap();
 }
 
 cfg_if! {