Move sys_fill_exact from util_libc to util_unix.

Prepare for removing the libc dependency from it.

Author: briansmith

src/getrandom.rs

@@ -15,7 +15,7 @@
 //! GRND_RANDOM is not recommended. On NetBSD/FreeBSD/Dragonfly/3ds, it does
 //! nothing. On illumos, the default pool is used to implement getentropy(2),
 //! so we assume it is acceptable here.
-use crate::{util_libc::sys_fill_exact, Error};
+use crate::{util_unix::sys_fill_exact, Error};
 use core::{ffi::c_void, mem::MaybeUninit};
 
 pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {

src/lib.rs

@@ -217,6 +217,8 @@ use core::mem::MaybeUninit;
 
 mod error;
 mod util;
+#[cfg(unix)]
+mod util_unix;
 // To prevent a breaking change when targets are added, we always export the
 // register_custom_getrandom macro, so old Custom RNG crates continue to build.
 #[cfg(feature = "custom")]

src/linux_android.rs

@@ -1,9 +1,9 @@
 //! Implementation for Linux / Android without `/dev/urandom` fallback
-use crate::{util_libc, Error};
+use crate::{util_unix::sys_fill_exact, Error};
 use core::mem::MaybeUninit;
 
 pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    util_libc::sys_fill_exact(dest, getrandom_syscall)
+    sys_fill_exact(dest, getrandom_syscall)
 }
 
 // Also used by linux_android_with_fallback to check if the syscall is available.

src/netbsd.rs

@@ -1,5 +1,5 @@
 //! Implementation for NetBSD
-use crate::{lazy::LazyPtr, util_libc::sys_fill_exact, Error};
+use crate::{lazy::LazyPtr, util_unix::sys_fill_exact, Error};
 use core::{ffi::c_void, mem::MaybeUninit, ptr};
 
 fn kern_arnd(buf: &mut [MaybeUninit<u8>]) -> libc::ssize_t {

src/use_file.rs

@@ -1,8 +1,5 @@
 //! Implementations that just need to read from a file
-use crate::{
-    util_libc::{open_readonly, sys_fill_exact},
-    Error,
-};
+use crate::{util_libc::open_readonly, util_unix::sys_fill_exact, Error};
 use core::{
     cell::UnsafeCell,
     ffi::c_void,

src/util_libc.rs

@@ -1,6 +1,5 @@
 #![allow(dead_code)]
 use crate::Error;
-use core::mem::MaybeUninit;
 
 cfg_if! {
     if #[cfg(any(target_os = "netbsd", target_os = "openbsd", target_os = "android"))] {
@@ -46,33 +45,6 @@ pub fn last_os_error() -> Error {
     }
 }
 
-// Fill a buffer by repeatedly invoking a system call. The `sys_fill` function:
-//   - should return -1 and set errno on failure
-//   - should return the number of bytes written on success
-pub fn sys_fill_exact(
-    mut buf: &mut [MaybeUninit<u8>],
-    sys_fill: impl Fn(&mut [MaybeUninit<u8>]) -> libc::ssize_t,
-) -> Result<(), Error> {
-    while !buf.is_empty() {
-        let res = sys_fill(buf);
-        match res {
-            res if res > 0 => buf = buf.get_mut(res as usize..).ok_or(Error::UNEXPECTED)?,
-            -1 => {
-                let err = last_os_error();
-                // We should try again if the call was interrupted.
-                if err.raw_os_error() != Some(libc::EINTR) {
-                    return Err(err);
-                }
-            }
-            // Negative return codes not equal to -1 should be impossible.
-            // EOF (ret = 0) should be impossible, as the data we are reading
-            // should be an infinite stream of random bytes.
-            _ => return Err(Error::UNEXPECTED),
-        }
-    }
-    Ok(())
-}
-
 /// Open a file in read-only mode.
 ///
 /// # Panics

src/util_unix.rs

@@ -0,0 +1,30 @@
+#![allow(dead_code)]
+use crate::{util_libc::last_os_error, Error};
+use core::mem::MaybeUninit;
+
+// Fill a buffer by repeatedly invoking a system call. The `sys_fill` function:
+//   - should return -1 and set errno on failure
+//   - should return the number of bytes written on success
+pub fn sys_fill_exact(
+    mut buf: &mut [MaybeUninit<u8>],
+    sys_fill: impl Fn(&mut [MaybeUninit<u8>]) -> libc::ssize_t,
+) -> Result<(), Error> {
+    while !buf.is_empty() {
+        let res = sys_fill(buf);
+        match res {
+            res if res > 0 => buf = buf.get_mut(res as usize..).ok_or(Error::UNEXPECTED)?,
+            -1 => {
+                let err = last_os_error();
+                // We should try again if the call was interrupted.
+                if err.raw_os_error() != Some(libc::EINTR) {
+                    return Err(err);
+                }
+            }
+            // Negative return codes not equal to -1 should be impossible.
+            // EOF (ret = 0) should be impossible, as the data we are reading
+            // should be an infinite stream of random bytes.
+            _ => return Err(Error::UNEXPECTED),
+        }
+    }
+    Ok(())
+}