libc++: add NaCl and PNaCl support for std::random_device

Summary:
The NaCl sandbox doesn't allow opening files under /dev, but it offers an API which provides the same capabilities. This is the same random device emulation that nacl_io performs for POSIX support, but nacl_io is an optional library so libc++ can't assume that device emulation will be performed. Note that NaCl only supports /dev/urandom, not /dev/random.

This patch also cleans up some of the preprocessor #endif, and fixes the test for Win32 (it accepts any token, and would therefore never throw regardless of the token provided).

Test Plan: ninja check-libcxx

Reviewers: dschuff, mclow.lists, danalbert

Subscribers: jfb, cfe-commits

Differential Revision: http://reviews.llvm.org/D6442

llvm-svn: 223068

4 files changed, 118 insertions, 38 deletions

diff --git a/libcxx/include/__config b/libcxx/include/__config
index e1e23594b32..df0bb77c04d 100644
--- a/libcxx/include/__config
+++ b/libcxx/include/__config
@@ -111,6 +111,13 @@
 # endif
 #endif // __sun__
 
+#if defined(__native_client__)
+  // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
+  // including accesses to the special files under /dev. C++11's
+  // std::random_device is instead exposed through a NaCl syscall.
+# define _LIBCPP_USING_NACL_RANDOM
+#endif // defined(__native_client__)
+
 #if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
 # include <endian.h>
 # if __BYTE_ORDER == __LITTLE_ENDIAN
diff --git a/libcxx/include/random b/libcxx/include/random
index e7053ce4ecf..a8d21a224df 100644
--- a/libcxx/include/random
+++ b/libcxx/include/random
@@ -3475,9 +3475,9 @@ typedef shuffle_order_engine<minstd_rand0, 256>                         knuth_b;
 
 class _LIBCPP_TYPE_VIS random_device
 {
-#if !defined(_WIN32)
+#if !(defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM))
     int __f_;
-#endif // defined(_WIN32)
+#endif // !(defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM))
 public:
     // types
     typedef unsigned result_type;
diff --git a/libcxx/src/random.cpp b/libcxx/src/random.cpp
index 86017ef0d46..15ed65b58cf 100644
--- a/libcxx/src/random.cpp
+++ b/libcxx/src/random.cpp
@@ -11,23 +11,27 @@
 // Must be defined before including stdlib.h to enable rand_s().
 #define _CRT_RAND_S
 #include <stdio.h>
-#endif
+#endif // defined(_WIN32)
 
 #include "random"
 #include "system_error"
 
-#ifdef __sun__
+#if defined(__sun__)
 #define rename solaris_headers_are_broken
-#endif
+#endif // defined(__sun__)
 #if !defined(_WIN32)
 #include <fcntl.h>
 #include <unistd.h>
-#endif // defined(_WIN32)
+#endif // !defined(_WIN32)
 #include <errno.h>
+#if defined(_LIBCPP_USING_NACL_RANDOM)
+#include <nacl/nacl_random.h>
+#endif // defined(_LIBCPP_USING_NACL_RANDOM)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_WIN32)
+
 random_device::random_device(const string&)
 {
 }
@@ -45,7 +49,39 @@ random_device::operator()()
         __throw_system_error(err, "random_device rand_s failed.");
     return r;
 }
-#else
+
+#elif defined(_LIBCPP_USING_NACL_RANDOM)
+
+random_device::random_device(const string& __token)
+{
+    if (__token != "/dev/urandom")
+        __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+    int error = nacl_secure_random_init();
+    if (error)
+        __throw_system_error(error, ("random device failed to open " + __token).c_str());
+}
+
+random_device::~random_device()
+{
+}
+
+unsigned
+random_device::operator()()
+{
+    unsigned r;
+    size_t n = sizeof(r);
+    char* p = reinterpret_cast<char*>(&r);
+    size_t bytes_written;
+    int error = nacl_secure_random(&r, n, &bytes_written);
+    if (error != 0)
+        __throw_system_error(error, "random_device failed getting bytes");
+    else if (bytes_written != n)
+        __throw_runtime_error("random_device failed to obtain enough bytes");
+    return r;
+}
+
+#else // !defined(_WIN32) && !defined(_LIBCPP_USING_NACL_RANDOM)
+
 random_device::random_device(const string& __token)
     : __f_(open(__token.c_str(), O_RDONLY))
 {
@@ -80,7 +116,8 @@ random_device::operator()()
     }
     return r;
 }
-#endif // defined(_WIN32)
+
+#endif // defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM)
 
 double
 random_device::entropy() const _NOEXCEPT
diff --git a/libcxx/test/numerics/rand/rand.device/ctor.pass.cpp b/libcxx/test/numerics/rand/rand.device/ctor.pass.cpp
index dfa546be709..2d9bc2ff8f1 100644
--- a/libcxx/test/numerics/rand/rand.device/ctor.pass.cpp
+++ b/libcxx/test/numerics/rand/rand.device/ctor.pass.cpp
@@ -11,39 +11,75 @@
 
 // class random_device;
 
-// explicit random_device(const string& token = "/dev/urandom");
+// explicit random_device(const string& token = implementation-defined);
+
+// For the following ctors, the standard states: "The semantics and default
+// value of the token parameter are implementation-defined". Implementations
+// therefore aren't required to accept any string, but the default shouldn't
+// throw.
 
 #include <random>
 #include <cassert>
 #include <unistd.h>
 
-int main()
-{
-    try
-    {
-        std::random_device r("wrong file");
-        assert(false);
-    }
-    catch (const std::system_error& e)
-    {
-    }
-    {
-        std::random_device r;
-    }
-    {
-        int ec;
-        ec = close(STDIN_FILENO);
-        assert(!ec);
-        ec = close(STDOUT_FILENO);
-        assert(!ec);
-        ec = close(STDERR_FILENO);
-        assert(!ec);
-        std::random_device r;
-    }
-    {
-        std::random_device r("/dev/urandom");;
-    }
-    {
-        std::random_device r("/dev/random");;
-    }
+bool is_valid_random_device(const std::string &token) {
+#if defined(_WIN32)
+  return true;
+#elif defined(_LIBCPP_USING_NACL_RANDOM)
+  return token == "/dev/urandom";
+#else  // !defined(_WIN32) && !defined(_LIBCPP_USING_NACL_RANDOM)
+  // Not an exhaustive list: they're the only tokens that are tested below.
+  return token == "/dev/urandom" || token == "/dev/random";
+#endif // defined(_WIN32) || defined(_LIBCPP_USING_NACL_RANDOM)
+}
+
+void check_random_device_valid(const std::string &token) {
+  std::random_device r(token);
+}
+
+void check_random_device_invalid(const std::string &token) {
+  try {
+    std::random_device r(token);
+    assert(false);
+  } catch (const std::system_error &e) {
+  }
+}
+
+int main() {
+  { std::random_device r; }
+
+  {
+    int ec;
+    ec = close(STDIN_FILENO);
+    assert(!ec);
+    ec = close(STDOUT_FILENO);
+    assert(!ec);
+    ec = close(STDERR_FILENO);
+    assert(!ec);
+    std::random_device r;
+  }
+
+  {
+    std::string token = "wrong file";
+    if (is_valid_random_device(token))
+      check_random_device_valid(token);
+    else
+      check_random_device_invalid(token);
+  }
+
+  {
+    std::string token = "/dev/urandom";
+    if (is_valid_random_device(token))
+      check_random_device_valid(token);
+    else
+      check_random_device_invalid(token);
+  }
+
+  {
+    std::string token = "/dev/random";
+    if (is_valid_random_device(token))
+      check_random_device_valid(token);
+    else
+      check_random_device_invalid(token);
+  }
 }