Merge pull request rust-random#10 from dhardy/ci

Add CI config and implement on WASM

Author: dhardy

.gitignore

@@ -1,3 +1,6 @@
 /target
 **/*.rs.bk
 Cargo.lock
+*.ts
+*.js
+*.wasm

.travis.yml

@@ -0,0 +1,145 @@
+language: rust
+sudo: false
+
+matrix:
+  include:
+    - rust: 1.28.0
+      env: DESCRIPTION="Linux, 1.28.0"
+      os: linux
+
+    - rust: 1.28.0
+      env: DESCRIPTION="OSX, 1.22.0"
+      os: osx
+
+    - rust: stable
+      env: DESCRIPTION="Linux, stable"
+
+    - rust: stable
+      env: DESCRIPTION="OSX+iOS, stable"
+      os: osx
+      install:
+        - rustup target add aarch64-apple-ios
+
+    - rust: beta
+      env: DESCRIPTION="Linux, beta"
+
+    - rust: nightly
+      os: linux
+      env: DESCRIPTION="Linux, nightly, docs"
+      install:
+        - cargo --list | egrep "^\s*deadlinks$" -q || cargo install cargo-deadlinks
+        - cargo deadlinks -V
+      script:
+        - cargo test
+        - cargo test --benches
+        - cargo test --examples
+        # remove cached documentation, otherwise files from previous PRs can get included
+        - rm -rf target/doc
+        - cargo doc --no-deps --all --all-features
+        - cargo deadlinks --dir target/doc
+
+    - rust: nightly
+      os: osx
+      env: DESCRIPTION="OSX, nightly, docs"
+      install:
+        - cargo --list | egrep "^\s*deadlinks$" -q || cargo install cargo-deadlinks
+        - cargo deadlinks -V
+      script:
+        - cargo test
+        - cargo test --benches
+        - cargo test --examples
+        # remove cached documentation, otherwise files from previous PRs can get included
+        - rm -rf target/doc
+        - cargo doc --no-deps --all --all-features
+        - cargo deadlinks --dir target/doc
+
+    - rust: nightly
+      env: DESCRIPTION="WASM via emscripten, stdweb and wasm-bindgen"
+      install:
+        - rustup target add wasm32-unknown-unknown
+        - rustup target add wasm32-unknown-emscripten
+        - nvm install 9
+        - ./utils/ci/install_cargo_web.sh
+        - cargo web prepare-emscripten
+        - cargo web -V
+        - cargo list | grep install-update || cargo install -f cargo-update
+        - cargo install-update -i cargo-update wasm-bindgen-cli wasm-pack
+      addons:
+        chrome: stable
+      script:
+        # Testing wasm32-unknown-emscripten fails because of rust-lang/rust#49877
+        # However, we can still build and link all tests to make sure that works.
+        # This is actually useful as it finds stuff such as rust-random/rand#669
+        - EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0" cargo web test --target wasm32-unknown-emscripten --no-run
+        #- cargo web test --target wasm32-unknown-emscripten
+        #- cargo web test --nodejs --target wasm32-unknown-emscripten
+        #- cargo build --target wasm32-unknown-unknown # without any features
+        - cargo build --target wasm32-unknown-unknown --features=wasm-bindgen
+        - cargo web test --target wasm32-unknown-unknown --features=stdweb
+        - cargo build --manifest-path tests/wasm_bindgen/Cargo.toml --target wasm32-unknown-unknown
+        - wasm-bindgen --nodejs target/wasm32-unknown-unknown/debug/getrandom_wasm_bindgen_test.wasm --out-dir tests/wasm_bindgen/js
+        - node tests/wasm_bindgen/js/index.js
+        - wasm-pack test --node tests/wasm_bindgen
+
+    - rust: nightly
+      env: DESCRIPTION="cross-platform build only"
+      install:
+        - rustup target add x86_64-sun-solaris
+        - rustup target add x86_64-unknown-cloudabi
+        - rustup target add x86_64-unknown-freebsd
+        #- rustup target add x86_64-unknown-fuchsia
+        - rustup target add x86_64-unknown-netbsd
+        - rustup target add x86_64-unknown-redox
+      script:
+        - cargo build --target=x86_64-sun-solaris --all-features
+        - cargo build --target=x86_64-unknown-cloudabi --all-features
+        - cargo build --target=x86_64-unknown-freebsd --all-features
+        #- cargo build --target=x86_64-unknown-fuchsia --all-features
+        - cargo build --target=x86_64-unknown-netbsd --all-features
+        - cargo build --target=x86_64-unknown-redox --all-features
+
+    # Trust cross-built/emulated targets. We must repeat all non-default values.
+    - rust: stable
+      sudo: required
+      dist: trusty
+      services: docker
+      env: DESCRIPTION="Linux (MIPS, big-endian)" TARGET=mips-unknown-linux-gnu
+      install:
+        - sh utils/ci/install.sh
+        - source ~/.cargo/env || true
+      script:
+        - bash utils/ci/script.sh
+    
+    - rust: stable
+      sudo: required
+      dist: trusty
+      services: docker
+      env: DESCRIPTION="Android (ARMv7)" TARGET=armv7-linux-androideabi
+      install:
+        - sh utils/ci/install.sh
+        - source ~/.cargo/env || true
+      script:
+        - bash utils/ci/script.sh
+
+before_install:
+  - set -e
+  - rustup self update
+
+script:
+  - cargo test
+  - cargo test --examples
+
+after_script: set +e
+
+cache:
+  cargo: true
+  directories:
+    - .local/share/cargo-web
+
+before_cache:
+  # Travis can't cache files that are not readable by "others"
+  - chmod -R a+r $HOME/.cargo
+
+notifications:
+  email:
+    on_success: never

Cargo.toml

@@ -9,12 +9,20 @@ description = "A small cross-platform library to securely get random data (entro
 travis-ci = { repository = "rust-random/getrandom" }
 appveyor = { repository = "rust-random/getrandom" }
 
+[workspace]
+members = [
+    "tests/wasm_bindgen",
+]
+
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = ["minwindef", "ntsecapi", "winnt"] }
 
+[target.'cfg(target_os = "cloudabi")'.dependencies]
+cloudabi = "0.0.3"
+
 [target.'cfg(fuchsia)'.dependencies]
 fuchsia-cprng = "0.1"
 

README.md

@@ -44,6 +44,10 @@ one of the following features must be enabled:
 -   [`wasm-bindgen`](https://crates.io/crates/wasm_bindgen)
 -   [`stdweb`](https://crates.io/crates/stdweb)
 
+## Versions
+
+This crate requires Rustc version 1.28.0 or later due to usage of `NonZeroU32`.
+
 
 # License
 

appveyor.yml

@@ -0,0 +1,36 @@
+environment:
+
+  # At the time this was added AppVeyor was having troubles with checking
+  # revocation of SSL certificates of sites like static.rust-lang.org and what
+  # we think is crates.io. The libcurl HTTP client by default checks for
+  # revocation on Windows and according to a mailing list [1] this can be
+  # disabled.
+  #
+  # The `CARGO_HTTP_CHECK_REVOKE` env var here tells cargo to disable SSL
+  # revocation checking on Windows in libcurl. Note, though, that rustup, which
+  # we're using to download Rust here, also uses libcurl as the default backend.
+  # Unlike Cargo, however, rustup doesn't have a mechanism to disable revocation
+  # checking. To get rustup working we set `RUSTUP_USE_HYPER` which forces it to
+  # use the Hyper instead of libcurl backend. Both Hyper and libcurl use
+  # schannel on Windows but it appears that Hyper configures it slightly
+  # differently such that revocation checking isn't turned on by default.
+  #
+  # [1]: https://curl.haxx.se/mail/lib-2016-03/0202.html
+  RUSTUP_USE_HYPER: 1
+  CARGO_HTTP_CHECK_REVOKE: false
+
+  matrix:
+  - TARGET: x86_64-pc-windows-msvc
+  - TARGET: i686-pc-windows-msvc
+install:
+  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - rustup-init.exe -y --default-host %TARGET%
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - rustc -V
+  - cargo -V
+
+build: false
+
+test_script:
+  - cargo test
+  - cargo test --examples

src/cloudabi.rs

@@ -5,19 +5,20 @@
 // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use error::Error;
 
-extern "C" {
-    fn cloudabi_sys_random_get(buf: *mut u8, len: usize) -> u16;
-}
+//! Implementation for CloudABI
+
+extern crate cloudabi;
+
+use core::num::NonZeroU32;
+use error::Error;
 
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    let errno = unsafe { cloudabi_sys_random_get(dest.as_ptr(), dest.len()) };
-    if errno == 0 {
+    let errno = unsafe { cloudabi::random_get(dest) };
+    if errno == cloudabi::errno::SUCCESS {
         Ok(())
     } else {
-        Err(Error(unsafe {
-            NonZeroU32::new_unchecked(errno as u32)
-        }))
+        let code = NonZeroU32::new(errno as u32).unwrap();
+        Err(Error::from(code))
     }
 }

src/error.rs

@@ -50,6 +50,12 @@ impl fmt::Display for Error {
     }
 }
 
+impl From<NonZeroU32> for Error {
+    fn from(code: NonZeroU32) -> Self {
+        Error(code)
+    }
+}
+
 #[cfg(not(target_env = "sgx"))]
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Self {

src/lib.rs

@@ -91,11 +91,26 @@
 //! [15]: https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback
 //! [16]: #support-for-webassembly-and-amsjs
 
+#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+       html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+       html_root_url = "https://rust-random.github.io/rand/")]
+
 #![no_std]
 
+#![cfg_attr(feature = "stdweb", recursion_limit="128")]
+
 #[cfg(not(target_env = "sgx"))]
 #[macro_use] extern crate std;
 
+// We have to do it here because we load macros
+#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten"),
+          feature = "wasm-bindgen"))]
+extern crate wasm_bindgen;
+#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten"),
+          not(feature = "wasm-bindgen"),
+          feature = "stdweb"))]
+#[macro_use] extern crate stdweb;
+
 #[cfg(any(
     target_os = "android",
     target_os = "netbsd",
@@ -104,8 +119,8 @@
     target_os = "redox",
     target_os = "dragonfly",
     target_os = "haiku",
-    target_os = "emscripten",
     target_os = "linux",
+    target_arch = "wasm32",
 ))]
 mod utils;
 mod error;
@@ -209,3 +224,58 @@ mod_use!(
 pub fn getrandom(dest: &mut [u8]) -> Result<(), Error> {
     getrandom_inner(dest)
 }
+
+// Due to rustwasm/wasm-bindgen#201 this can't be defined in the inner os
+// modules, so hack around it for now and place it at the root.
+#[cfg(all(feature = "wasm-bindgen", target_arch = "wasm32"))]
+#[doc(hidden)]
+#[allow(missing_debug_implementations)]
+pub mod __wbg_shims {
+
+    // `extern { type Foo; }` isn't supported on 1.22 syntactically, so use a
+    // macro to work around that.
+    macro_rules! rust_122_compat {
+        ($($t:tt)*) => ($($t)*)
+    }
+
+    rust_122_compat! {
+        extern crate wasm_bindgen;
+
+        pub use wasm_bindgen::prelude::*;
+
+        #[wasm_bindgen]
+        extern "C" {
+            pub type Function;
+            #[wasm_bindgen(constructor)]
+            pub fn new(s: &str) -> Function;
+            #[wasm_bindgen(method)]
+            pub fn call(this: &Function, self_: &JsValue) -> JsValue;
+
+            pub type This;
+            #[wasm_bindgen(method, getter, structural, js_name = self)]
+            pub fn self_(me: &This) -> JsValue;
+            #[wasm_bindgen(method, getter, structural)]
+            pub fn crypto(me: &This) -> JsValue;
+
+            #[derive(Clone, Debug)]
+            pub type BrowserCrypto;
+
+            // TODO: these `structural` annotations here ideally wouldn't be here to
+            // avoid a JS shim, but for now with feature detection they're
+            // unavoidable.
+            #[wasm_bindgen(method, js_name = getRandomValues, structural, getter)]
+            pub fn get_random_values_fn(me: &BrowserCrypto) -> JsValue;
+            #[wasm_bindgen(method, js_name = getRandomValues, structural)]
+            pub fn get_random_values(me: &BrowserCrypto, buf: &mut [u8]);
+
+            #[wasm_bindgen(js_name = require)]
+            pub fn node_require(s: &str) -> NodeCrypto;
+
+            #[derive(Clone, Debug)]
+            pub type NodeCrypto;
+
+            #[wasm_bindgen(method, js_name = randomFillSync, structural)]
+            pub fn random_fill_sync(me: &NodeCrypto, buf: &mut [u8]);
+        }
+    }
+}

src/linux_android.rs

@@ -15,9 +15,9 @@ use std::fs::File;
 use std::io;
 use std::io::Read;
 use std::cell::RefCell;
-use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 
-static RNG_INIT: AtomicBool = ATOMIC_BOOL_INIT;
+static RNG_INIT: AtomicBool = AtomicBool::new(false);
 
 enum RngSource {
     GetRandom,
@@ -32,7 +32,7 @@ fn syscall_getrandom(dest: &mut [u8]) -> Result<(), io::Error> {
     let ret = unsafe {
         libc::syscall(libc::SYS_getrandom, dest.as_mut_ptr(), dest.len(), 0)
     };
-    if ret == -1 || ret != dest.len() as i64 {
+    if ret < 0 || (ret as usize) != dest.len() {
         return Err(io::Error::last_os_error());
     }
     Ok(())
@@ -67,7 +67,7 @@ fn is_getrandom_available() -> bool {
     use std::sync::{Once, ONCE_INIT};
 
     static CHECKER: Once = ONCE_INIT;
-    static AVAILABLE: AtomicBool = ATOMIC_BOOL_INIT;
+    static AVAILABLE: AtomicBool = AtomicBool::new(false);
 
     CHECKER.call_once(|| {
         let mut buf: [u8; 0] = [];