log: Remove optional log dependancy

.travis.yml

@@ -91,14 +91,13 @@ matrix:
         - cargo test --benches
         # Check that setting various features does not break the build
         - cargo build --features=std
-        - cargo build --features=log
         # remove cached documentation, otherwise files from previous PRs can get included
         - rm -rf target/doc
         - cargo doc --no-deps --features=std
         - cargo deadlinks --dir target/doc
         # also test minimum dependency versions are usable
         - cargo generate-lockfile -Z minimal-versions
-        - cargo test --features=std,log
+        - cargo test --features=std
 
     - <<: *nightly_and_docs
       name: "OSX, nightly, docs"

Cargo.toml

@@ -15,7 +15,6 @@ travis-ci = { repository = "rust-random/getrandom" }
 appveyor = { repository = "rust-random/getrandom" }
 
 [dependencies]
-log = { version = "0.4", optional = true }
 cfg-if = "0.1.2"
 
 # When built as part of libstd

README.md

@@ -24,7 +24,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-getrandom = "0.1"
+getrandom = "0.2"
 ```
 
 Then invoke the `getrandom` function:
@@ -44,9 +44,6 @@ usually requires calling some external system API. This means most platforms
 will require linking against system libraries (i.e. `libc` for Unix,
 `Advapi32.dll` for Windows, Security framework on iOS, etc...).
 
-The `log` library is supported as an optional dependency. If enabled, error
-reporting will be improved on some platforms.
-
 For the `wasm32-unknown-unknown` target, one of the following features should be
 enabled:
 

src/bsd_arandom.rs

@@ -25,7 +25,6 @@ fn kern_arnd(buf: &mut [u8]) -> libc::ssize_t {
         )
     };
     if ret == -1 {
-        error!("sysctl kern.arandom: syscall failed");
         -1
     } else {
         len as libc::ssize_t

src/cloudabi.rs

@@ -17,7 +17,6 @@ extern "C" {
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
     let errno = unsafe { cloudabi_sys_random_get(dest.as_mut_ptr(), dest.len()) };
     if let Some(code) = NonZeroU32::new(errno as u32) {
-        error!("cloudabi_sys_random_get: failed with {}", errno);
         Err(Error::from(code))
     } else {
         Ok(()) // Zero means success for CloudABI

src/lib.rs

@@ -132,27 +132,6 @@
 #[macro_use]
 extern crate cfg_if;
 
-cfg_if! {
-    if #[cfg(feature = "log")] {
-        #[allow(unused)]
-        #[macro_use]
-        extern crate log;
-    } else {
-        #[allow(unused)]
-        macro_rules! error {
-            ($($x:tt)*) => {};
-        }
-        #[allow(unused)]
-        macro_rules! warn {
-            ($($x:tt)*) => {};
-        }
-        #[allow(unused)]
-        macro_rules! info {
-            ($($x:tt)*) => {};
-        }
-    }
-}
-
 mod error;
 mod util;
 

src/macos.rs

@@ -20,9 +20,7 @@ pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
         for chunk in dest.chunks_mut(256) {
             let ret = unsafe { func(chunk.as_mut_ptr(), chunk.len()) };
             if ret != 0 {
-                let err = last_os_error();
-                error!("getentropy syscall failed");
-                return Err(err);
+                return Err(last_os_error());
             }
         }
         Ok(())

src/openbsd.rs

@@ -14,9 +14,7 @@ pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
     for chunk in dest.chunks_mut(256) {
         let ret = unsafe { libc::getentropy(chunk.as_mut_ptr() as *mut libc::c_void, chunk.len()) };
         if ret == -1 {
-            let err = last_os_error();
-            error!("libc::getentropy call failed");
-            return Err(err);
+            return Err(last_os_error());
         }
     }
     Ok(())

src/rdrand.rs

@@ -32,7 +32,6 @@ unsafe fn rdrand() -> Result<[u8; WORD_SIZE], Error> {
             if el != 0 && el != !0 {
                 return Ok(el.to_ne_bytes());
             }
-            error!("RDRAND returned {:X}, CPU RNG may be broken", el);
             // Keep looping in case this was a false positive.
         }
     }

src/wasm32_stdweb.rs

@@ -13,8 +13,6 @@ use core::mem;
 use std::sync::Once;
 
 use stdweb::js;
-use stdweb::unstable::TryInto;
-use stdweb::web::error::Error as WebError;
 
 use crate::Error;
 
@@ -68,8 +66,6 @@ fn getrandom_init() -> Result<RngSource, Error> {
             unreachable!()
         }
     } else {
-        let _err: WebError = js! { return @{ result }.error }.try_into().unwrap();
-        error!("getrandom unavailable: {}", _err);
         Err(Error::STDWEB_NO_RNG)
     }
 }
@@ -104,8 +100,6 @@ fn getrandom_fill(source: RngSource, dest: &mut [u8]) -> Result<(), Error> {
         };
 
         if js! { return @{ result.as_ref() }.success } != true {
-            let _err: WebError = js! { return @{ result }.error }.try_into().unwrap();
-            error!("getrandom failed: {}", _err);
             return Err(Error::STDWEB_RNG_FAILED);
         }
     }

src/windows_uwp.rs

@@ -33,26 +33,16 @@ pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
                 BCRYPT_USE_SYSTEM_PREFERRED_RNG,
             )
         };
-        // NTSTATUS codes use two highest bits for severity status
-        match ret >> 30 {
-            0b01 => {
-                info!("BCryptGenRandom: information code 0x{:08X}", ret);
-            }
-            0b10 => {
-                warn!("BCryptGenRandom: warning code 0x{:08X}", ret);
-            }
-            0b11 => {
-                error!("BCryptGenRandom: failed with 0x{:08X}", ret);
-                // We zeroize the highest bit, so the error code will reside
-                // inside the range of designated for OS codes.
-                let code = ret ^ (1 << 31);
-                // SAFETY: the second highest bit is always equal to one,
-                // so it's impossible to get zero. Unfortunately compiler
-                // is not smart enough to figure out it yet.
-                let code = unsafe { NonZeroU32::new_unchecked(code) };
-                return Err(Error::from(code));
-            }
-            _ => (),
+        // NTSTATUS codes use the two highest bits for severity status.
+        if ret >> 30 == 0b11 {
+            // We zeroize the highest bit, so the error code will reside
+            // inside the range designated for OS codes.
+            let code = ret ^ (1 << 31);
+            // SAFETY: the second highest bit is always equal to one,
+            // so it's impossible to get zero. Unfortunately the type
+            // system does not have a way to express this yet.
+            let code = unsafe { NonZeroU32::new_unchecked(code) };
+            return Err(Error::from(code));
         }
     }
     Ok(())