new error

Author: newpavlov

Cargo.toml

@@ -21,3 +21,7 @@ fuchsia-cprng = "0.1"
 [target.wasm32-unknown-unknown.dependencies]
 wasm-bindgen = { version = "0.2.12", optional = true }
 stdweb = { version = "0.4", optional = true }
+
+[features]
+# Forces syscall usage on Linux, Android and Solaris
+force_syscall = []

src/cloudabi.rs

@@ -16,6 +16,8 @@ pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
     if errno == 0 {
         Ok(())
     } else {
-        Err(Error::Unknown)
+        Err(Error(unsafe {
+            NonZeroU32::new_unchecked(errno as u32)
+        }))
     }
 }

src/dragonfly_haiku.rs

@@ -17,6 +17,9 @@ thread_local!(static RNG_FILE: RefCell<Option<File>> = RefCell::new(None));
 
 pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
     RNG_FILE.with(|f| {
-        use_init(f, || File::open("/dev/random"), |f| f.read_exact(dest))
-    }).map_err(|_| Error::Unknown)
+        use_init(f,
+            || File::open("/dev/random").map_err(From::from),
+            |f| f.read_exact(dest).map_err(From::from),
+        )
+    })
 }

src/dummy.rs

@@ -7,9 +7,9 @@
 // except according to those terms.
 
 //! A dummy implementation for unsupported targets which always returns
-//! `Err(Error::Unavailable)`
-use super::Error;
+//! `Err(UNAVAILABLE_ERROR)`
+use super::UNAVAILABLE_ERROR;
 
 pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
-    Err(Error::Unavailable)
+    Err(UNAVAILABLE_ERROR)
 }

src/emscripten.rs

@@ -21,11 +21,11 @@ pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
     // task length variation, partition large randomBytes requests when
     // doing so as part of fulfilling a client request.
     RNG_FILE.with(|f| {
-        use_init(f, || File::open("/dev/random"), |f| {
+        use_init(f, || File::open("/dev/random").map_err(From::from), |f| {
             for chunk in dest.chunks_mut(65536) {
                 f.read_exact(chunk)?;
             }
             Ok(())
         })
-    }).map_err(|_| Error::Unknown)
+    })
 }

src/error.rs

@@ -6,16 +6,64 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::num::NonZeroU32;
+use core::convert::From;
+use core::fmt;
+#[cfg(not(target_env = "sgx"))]
+use std::{io, error};
+
+pub const UNKNOWN_ERROR: Error = Error(unsafe {
+    NonZeroU32::new_unchecked(0x756e6b6e) // "unkn"
+});
+
+pub const UNAVAILABLE_ERROR: Error = Error(unsafe {
+    NonZeroU32::new_unchecked(0x4e416e61) // "NAna"
+});
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Error {
-    /// Call was interrupted.
-    ///
-    /// Typically it can be retried.
-    Interrupted,
-    /// RNG source is unavailable on a given system.
-    Unavailable,
-    /// Unknown error.
-    Unknown,
-    #[doc(hidden)]
-    __Nonexhaustive,
+pub struct Error(NonZeroU32);
+
+impl Error {
+    pub fn code(&self) -> NonZeroU32 {
+        self.0
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            UNKNOWN_ERROR => write!(f, "Getrandom Error: unknown"),
+            UNAVAILABLE_ERROR => write!(f, "Getrandom Error: unavailable"),
+            code => write!(f, "Getrandom Error: {}", code.0.get()),
+        }
+    }
 }
+
+#[cfg(not(target_env = "sgx"))]
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Self {
+        err.raw_os_error()
+            .map(|code| Error(unsafe {
+                // all supported targets use 0 as success code
+                NonZeroU32::new_unchecked(code as u32)
+            }))
+            // in practice this should never happen
+            .unwrap_or(UNKNOWN_ERROR)
+    }
+}
+
+#[cfg(not(target_env = "sgx"))]
+impl Into<io::Error> for Error {
+    fn into(self) -> io::Error {
+        match self {
+            UNKNOWN_ERROR => io::Error::new(io::ErrorKind::Other,
+                "getrandom error: unknown"),
+            UNAVAILABLE_ERROR => io::Error::new(io::ErrorKind::Other,
+                "getrandom error: entropy source is unavailable"),
+            code => io::Error::from_raw_os_error(code.0.get() as i32),
+        }
+    }
+}
+
+#[cfg(not(target_env = "sgx"))]
+impl error::Error for Error { }

src/freebsd.rs

@@ -11,6 +11,7 @@ extern crate libc;
 
 use super::Error;
 use core::ptr;
+use std::io;
 
 pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
     let mib = [libc::CTL_KERN, libc::KERN_ARND];
@@ -24,7 +25,7 @@ pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
             )
         };
         if ret == -1 || len != chunk.len() {
-            return Err(Error::Unknown);
+            return Err(io::Error::last_os_error().into());
         }
     }
     Ok(())

src/lib.rs

@@ -7,16 +7,7 @@
 // except according to those terms.
 #![no_std]
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "netbsd",
-    target_os = "solaris",
-    target_os = "redox",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "emscripten",
-    target_os = "linux",
-))]
+#[cfg(not(target_env = "sgx"))]
 #[macro_use] extern crate std;
 
 #[cfg(any(
@@ -31,7 +22,7 @@
 ))]
 mod utils;
 mod error;
-pub use error::Error;
+pub use error::{Error, UNKNOWN_ERROR, UNAVAILABLE_ERROR};
 
 macro_rules! mod_use {
     ($cond:meta, $module:ident) => {

src/linux_android.rs

@@ -58,8 +58,8 @@ pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
             match f {
                 RngSource::GetRandom => syscall_getrandom(dest),
                 RngSource::Device(f) => f.read_exact(dest),
-            }
-        }).map_err(|_| Error::Unknown)
+            }.map_err(From::from)
+        })
     })
 }
 

src/macos.rs

@@ -8,6 +8,7 @@
 
 //! Implementation for MacOS / iOS
 use super::Error;
+use std::io;
 
 // TODO: check correctness
 #[allow(non_upper_case_globals)]
@@ -29,7 +30,7 @@ pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
         )
     };
     if ret == -1 {
-        Err(Error::Unknown)
+        Err(io::Error::last_os_error().into())
     } else {
         Ok(())
     }