Add a way to use io-lifetimes without depending on libc.

Add a "close" feature, enabled by default, and only call `close` when
this feature is enabled. If anyone attempts to drop an `OwnedFd` without
this feature enabled, issue a link-time error.

Author: sunfishcode

Cargo.toml

@@ -36,10 +36,14 @@ mio = { version = "0.7.11", features = ["net", "os-ext"], optional = true }
 fs-err = { version = "2.6.0", optional = true }
 
 [target.'cfg(not(windows))'.dependencies]
-libc = "0.2.96"
+libc = { version = "0.2.96", optional = true }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.9", features = ["handleapi", "std", "winsock2"] }
 
+[features]
+default = ["close"]
+close = ["libc"]
+
 [badges]
 maintenance = { status = "actively-developed" }

examples/flexible-apis.rs

@@ -4,7 +4,7 @@
 //! The following uses the POSIX-ish `Fd` types; similar considerations
 //! apply to the Windows and portable types.
 
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 use io_lifetimes::{AsFd, BorrowedFd, IntoFd, OwnedFd};
 
 /// The simplest way to accept a borrowed I/O resource is to simply use a
@@ -15,7 +15,7 @@ use io_lifetimes::{AsFd, BorrowedFd, IntoFd, OwnedFd};
 ///
 /// Callers with an `AsFd`-implementing type would call `.as_fd()` and pass
 /// the result.
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 fn use_fd_a(fd: BorrowedFd<'_>) {
     let _ = fd;
 }
@@ -24,7 +24,7 @@ fn use_fd_a(fd: BorrowedFd<'_>) {
 /// verbose at the function definition site, and entails monomorphization, but
 /// it has the advantage of allowing users to pass in any type implementing
 /// `AsFd` directly, without having to call `.as_fd()` themselves.
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 fn use_fd_b<Fd: AsFd>(fd: &Fd) {
     let _ = fd.as_fd();
 }
@@ -35,7 +35,7 @@ fn use_fd_b<Fd: AsFd>(fd: &Fd) {
 ///
 /// Callers with an `IntoFd`-implementing type would call `.into_fd()` and pass
 /// the result.
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 fn consume_fd_a(fd: OwnedFd) {
     let _ = fd;
 }
@@ -44,13 +44,13 @@ fn consume_fd_a(fd: OwnedFd) {
 /// `use_fd_b`, this is more verbose here and entails monomorphization, but it
 /// has the advantage of allowing users to pass in any type implementing
 /// `IntoFd` directly.
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 fn consume_fd_b<Fd: IntoFd>(fd: Fd) {
     let _ = fd.into_fd();
 }
 
 /// Now let's see how the APIs look for users.
-#[cfg(not(windows))]
+#[cfg(all(feature = "close", not(windows)))]
 fn main() {
     let f = std::fs::File::open("Cargo.toml").unwrap();
 
@@ -77,3 +77,8 @@ fn main() {
 fn main() {
     println!("This example uses non-Windows APIs.");
 }
+
+#[cfg(all(not(feature = "close"), not(windows)))]
+fn main() {
+    println!("This example requires the \"close\" feature.");
+}

examples/hello.rs

@@ -3,19 +3,23 @@
 
 #![cfg_attr(not(rustc_attrs), allow(unused_imports))]
 
+#[cfg(feature = "close")]
 use io_lifetimes::example_ffi::*;
-use std::fs::File;
-use std::io::{self, Write};
+#[cfg(feature = "close")]
+use std::{
+    fs::File,
+    io::{self, Write},
+};
 
-#[cfg(unix)]
+#[cfg(all(unix, feature = "close"))]
 use io_lifetimes::{AsFd, FromFd, IntoFd, OwnedFd};
 
 #[cfg(windows)]
 use io_lifetimes::{AsHandle, FromHandle, IntoHandle, OwnedHandle};
 #[cfg(windows)]
 use std::{convert::TryInto, ptr::null_mut};
 
-#[cfg(all(rustc_attrs, unix))]
+#[cfg(all(rustc_attrs, unix, feature = "close"))]
 fn main() -> io::Result<()> {
     let fd = unsafe {
         // Open a file, which returns an `Option<OwnedFd>`, which we can
@@ -131,7 +135,7 @@ fn main() -> io::Result<()> {
     Ok(())
 }
 
-#[cfg(not(any(windows, rustc_attrs)))]
+#[cfg(all(not(all(rustc_attrs, unix, feature = "close")), not(windows)))]
 fn main() {
-    println!("On Unix, this example requires Rust nightly (for `rustc_attrs`).");
+    println!("On Unix, this example requires Rust nightly (for `rustc_attrs`) and the \"close\" feature.");
 }

examples/owning-wrapper.rs

@@ -71,6 +71,7 @@ impl FromHandle for Thing {
     }
 }
 
+#[cfg(feature = "close")]
 fn main() {
     use io_lifetimes::{AsFilelike, FromFilelike, IntoFilelike};
 
@@ -101,3 +102,8 @@ fn main() {
         let _ = thing.into_filelike();
     }
 }
+
+#[cfg(not(feature = "close"))]
+fn main() {
+    println!("This example requires the \"close\" feature.");
+}

src/lib.rs

@@ -50,6 +50,7 @@ pub use portability::{
     IntoFilelike, IntoSocketlike, OwnedFilelike, OwnedSocketlike,
 };
 
+#[cfg(feature = "close")]
 pub mod example_ffi;
 pub mod views;
 

src/types.rs

@@ -440,9 +440,20 @@ impl FromRawHandle for OptionFileHandle {
 impl Drop for OwnedFd {
     #[inline]
     fn drop(&mut self) {
+        #[cfg(feature = "close")]
         unsafe {
             let _ = libc::close(self.raw as std::os::raw::c_int);
         }
+
+        // If the `close` feature is disabled, we expect users to avoid letting
+        // `OwnedFd` instances drop, so that we don't have to call `close`.
+        #[cfg(not(feature = "close"))]
+        unsafe {
+            extern "C" {
+                fn __drop_called_without_the_close_feature();
+            }
+            __drop_called_without_the_close_feature();
+        }
     }
 }
 

tests/api.rs

@@ -1,4 +1,5 @@
 #![cfg_attr(target_os = "wasi", feature(wasi_ext))]
+#![cfg(feature = "close")]
 
 use io_lifetimes::{
     AsFilelike, AsSocketlike, BorrowedFilelike, FromFilelike, FromSocketlike, IntoFilelike,

tests/ffi.rs

@@ -1,4 +1,5 @@
 #![cfg_attr(not(rustc_attrs), allow(unused_imports))]
+#![cfg(feature = "close")]
 
 #[cfg(any(unix, windows))]
 use io_lifetimes::example_ffi::*;