Changeset 11523 in vbox for trunk

Timestamp:

Aug 20, 2008 8:48:52 PM (16 years ago)

Author:

vboxsync

Message:

iprt: Implemented the /dev/urandom base random generator as a RTRAND opaque. Made the simple RTRand API just serve as a wrapper using the RTRandAdv API with a global RTRAND handle.

Location:

trunk

Files:

• include/iprt/rand.h (modified) (2 diffs)
• src/VBox/Runtime/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/common/rand/rand.cpp (modified) (3 diffs)
• src/VBox/Runtime/common/rand/randadv.cpp (modified) (2 diffs)
• src/VBox/Runtime/common/rand/randparkmiller.cpp (modified) (5 diffs)
• src/VBox/Runtime/generic/RTRandAdvCreateNonPseudo-generic.cpp (added)
• src/VBox/Runtime/generic/RTRandAdvCreatePureNonPseudo-generic.cpp (added)
• src/VBox/Runtime/generic/rand-stubs-generic.cpp (deleted)
• src/VBox/Runtime/include/internal/rand.h (modified) (3 diffs)
• src/VBox/Runtime/r3/posix/rand-posix.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstRand.cpp (modified) (1 diff)

trunk/include/iprt/rand.h

@@ -140 +140 @@
 
 /**
+ * Create an instance of the default non-pseudo random number generator.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_NOT_SUPPORTED on platforms which doesn't have this feature
+ *          (Windows & OS/2).
+ * @param   phRand      Where to store the handle to the generator.
+ *
+ * @remarks Think /dev/urandom.
+ */
+RTDECL(int) RTRandAdvCreateNonPseudo(PRTRAND phRand) RT_NO_THROW;
+
+/**
+ * Create an instance of the default pure non-pseudo random number generator.
+ *
+ * Don't use this unless you seriously need good random numbers because most
+ * systems will have will have problems producing sufficient randomness for this
+ * and you'll end up blocking.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_NOT_SUPPORTED on platforms which doesn't have this feature
+ *          (Windows & OS/2).
+ * @param   phRand      Where to store the handle to the generator.
+ *
+ * @remarks Think /dev/random.
+ */
+RTDECL(int) RTRandAdvCreatePureNonPseudo(PRTRAND phRand) RT_NO_THROW;
+
+/**
  * Destroys a random number generator.
  *
@@ -155 +183 @@
  *
  * @returns IPRT status code.
+ * @retval  VERR_NOT_SUPPORTED if it isn't a pseudo generator.
+ *
  * @param   hRand       Handle to the random number generator.
  * @param   u64Seed     Seed.
  */
 RTDECL(int) RTRandAdvSeed(RTRAND hRand, uint64_t u64Seed) RT_NO_THROW;
+
+/**
+ * Save the current state of a pseudo generator.
+ *
+ * This can be use to save the state so it can later be resumed at the same
+ * position.
+ *
+ * @returns IPRT status code.
+ * @retval  VINF_SUCCESS on success. *pcbState contains the length of the
+ *          returned string and pszState contains the state string.
+ * @retval  VERR_BUFFER_OVERFLOW if the supplied buffer is too small. *pcbState
+ *          will contain the necessary buffer size.
+ * @retval  VERR_NOT_SUPPORTED by non-psuedo generators.
+ *
+ * @param   hRand       Handle to the random number generator.
+ * @param   pszState    Where to store the state. The returned string will be
+ *                      null terminated and printable.
+ * @param   pcbState    The size of the buffer pszState points to on input, the
+ *                      size required / used on return (including the
+ *                      terminator, thus the 'cb' instead of 'cch').
+ */
+RTDECL(int) RTRandAdvSaveState(RTRAND hRand, char *pszState, size_t *pcbState) RT_NO_THROW;
+
+/**
+ * Restores the state of a pseudo generator.
+ *
+ * The state must've been obtained using RTRandAdvGetState.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_PARSE_ERROR if the state string is malformed.
+ * @retval  VERR_NOT_SUPPORTED by non-psuedo generators.
+ *
+ * @param   hRand       Handle to the random number generator.
+ * @param   pszState    The state to load.
+ */
+RTDECL(int) RTRandAdvRestoreState(RTRAND hRand, char const *pszState) RT_NO_THROW;
 
 /**

trunk/src/VBox/Runtime/Makefile.kmk

@@ -282 +282 @@
 
 RuntimeR3_SOURCES.win = \
-        generic/rand-stubs-generic.cpp \
         generic/RTDirQueryInfo-generic.cpp \
         generic/RTDirSetTimes-generic.cpp \
+        generic/RTMpGetCurFrequency-generic.cpp \
+        generic/RTMpGetMaxFrequency-generic.cpp \
+        generic/RTRandAdvCreateNonPseudo-generic.cpp \
+        generic/RTRandAdvCreatePureNonPseudo-generic.cpp \
         generic/semnoint-generic.cpp \
         generic/semsrw-generic.cpp \
-        generic/RTMpGetCurFrequency-generic.cpp \
-        generic/RTMpGetMaxFrequency-generic.cpp \
         nt/RTErrConvertFromNtStatus.cpp \
         r3/posix/env-posix.cpp \
@@ -366 +367 @@
 RuntimeR3_SOURCES.os2   = \
         generic/pathhost-generic.cpp \
-        generic/rand-stubs-generic.cpp \
         generic/RTDirQueryInfo-generic.cpp \
         generic/RTDirSetTimes-generic.cpp \
         generic/RTFileMove-generic.cpp \
         generic/RTLogWriteDebugger-generic.cpp \
+        generic/RTRandAdvCreateNonPseudo-generic.cpp \
+        generic/RTRandAdvCreatePureNonPseudo-generic.cpp \
         generic/RTTimeLocalNow-generic.cpp \
         generic/RTTimerCreate-generic.cpp \

trunk/src/VBox/Runtime/common/rand/rand.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Random Number
+ * IPRT - Random Numbers.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -39 +39 @@
 #include <iprt/assert.h>
 #include <iprt/thread.h>
+#include <iprt/once.h>
 #include "internal/rand.h"
 
@@ -45 +46 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-/** Lazy init. */
-static volatile bool    g_fInitialized = false;
-/** The context variable for the fallback path. */
-static uint32_t         g_u32Ctx;
-
-
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static uint32_t rtRandGenBytesFallbackU31(uint32_t *pCtx);
+/** For lazily initializating of the random generator. */
+static RTONCE g_rtRandOnce = RTONCE_INITIALIZER;
+/** The default random generator. */
+static RTRAND g_hRand = NIL_RTRAND;
 
 
 /**
- * Lazy initialization of the native and fallback random byte sources.
+ * Perform lazy initialization.
  *
+ * @returns IPRT status code.
+ * @param   pvUser1     Ignored.
+ * @param   pvUser2     Ignored.
  */
-static void rtRandLazyInit(void)
+static DECLCALLBACK(int) rtRandInitOnce(void *pvUser1, void *pvUser2)
 {
-    /*
-     * Seed the fallback random code.
-     */
-    g_u32Ctx = (uint32_t)(ASMReadTSC() >> 8);
+    NOREF(pvUser1);
+    NOREF(pvUser2);
 
-    /*
-     * Call host specific init.
-     */
-    rtRandLazyInitNative();
-    g_fInitialized = true;
+    RTRAND hRand;
+    int rc = RTRandAdvCreateNonPseudo(&hRand);
+    if (RT_FAILURE(rc))
+        rc = RTRandAdvCreateParkMiller(&hRand);
+    if (RT_SUCCESS(rc))
+    {
+        RTRandAdvSeed(hRand, ASMReadTSC() >> 8);
+        g_hRand = hRand;
+    }
+    else
+        AssertRC(rc);
+
+    return rc;
 }
 
 
-/**
- * Internal wrapper for the native and generic random byte methods.
- *
- * @param   pv  Where to store the random bytes.
- * @param   cb  Number of bytes to generate.
- */
-static void rtRandGenBytes(void *pv, size_t cb)
+RTDECL(void) RTRandBytes(void *pv, size_t cb) RT_NO_THROW
 {
-    Assert(cb);
-    if (RT_UNLIKELY(!g_fInitialized))
-        rtRandLazyInit();
-
-    int rc = rtRandGenBytesNative(pv, cb);
-    if (RT_FAILURE(rc))
-        rtRandGenBytesFallback(pv, cb);
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    RTRandAdvBytes(g_hRand, pv, cb);
 }
 
 
-/**
- * Fills a buffer with random bytes.
- *
- * @param   pv  Where to store the random bytes.
- * @param   cb  Number of bytes to generate.
- */
-RTDECL(void) RTRandBytes(void *pv, size_t cb) RT_NO_THROW
+RTDECL(uint32_t) RTRandU32Ex(uint32_t u32First, uint32_t u32Last) RT_NO_THROW
 {
-    if (cb)
-        rtRandGenBytes(pv, cb);
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvU32Ex(g_hRand, u32First, u32Last);
 }
 
 
-/**
- * Generate a 32-bit unsigned random number in the set [u32First..u32Last].
- *
- * @returns The random number.
- * @param   u32First    First number in the set.
- * @param   u32Last     Last number in the set.
- */
-RTDECL(uint32_t) RTRandU32Ex(uint32_t u32First, uint32_t u32Last) RT_NO_THROW
+RTDECL(uint32_t) RTRandU32(void) RT_NO_THROW
 {
-    union
-    {
-        uint32_t    off;
-        uint8_t     ab[5];
-    } u;
-
-    const uint32_t offLast = u32Last - u32First;
-    if (offLast == UINT32_MAX)
-        /* get 4 random bytes and return them raw. */
-        rtRandGenBytes(&u.ab[0], sizeof(u.off));
-    else if (!(offLast & UINT32_C(0xf0000000)))
-    {
-        /* get 4 random bytes and do simple squeeze. */
-        rtRandGenBytes(&u.ab[0], sizeof(u.off));
-        u.off %= offLast + 1;
-        u.off += u32First;
-    }
-    else
-    {
-        /* get 5 random bytes and do shifted squeeze. (this ain't perfect) */
-        rtRandGenBytes(&u.ab[0], sizeof(u.ab));
-        u.off %= (offLast >> 4) + 1;
-        u.off <<= 4;
-        u.off |= u.ab[4] & 0xf;
-        if (u.off > offLast)
-            u.off = offLast;
-        u.off += u32First;
-    }
-    return u.off;
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvU32(g_hRand);
 }
 
 
-/**
- * Generate a 32-bit unsigned random number.
- *
- * @returns The random number.
- */
-RTDECL(uint32_t) RTRandU32(void) RT_NO_THROW
+RTDECL(int32_t) RTRandS32Ex(int32_t i32First, int32_t i32Last) RT_NO_THROW
 {
-    return RTRandU32Ex(0, UINT32_MAX);
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvS32Ex(g_hRand, i32First, i32Last);
 }
 
 
-/**
- * Generate a 32-bit signed random number in the set [i32First..i32Last].
- *
- * @returns The random number.
- * @param   i32First    First number in the set.
- * @param   i32Last     Last number in the set.
- */
-RTDECL(int32_t) RTRandS32Ex(int32_t i32First, int32_t i32Last) RT_NO_THROW
+RTDECL(int32_t) RTRandS32(void) RT_NO_THROW
 {
-    if (i32First == INT32_MIN && i32Last == INT32_MAX)
-        return (int32_t)RTRandU32Ex(0, UINT32_MAX);
-    return RTRandU32Ex(0, i32Last - i32First) + i32First;
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvS32(g_hRand);
 }
 
 
-/**
- * Generate a 32-bit signed random number.
- *
- * @returns The random number.
- */
-RTDECL(int32_t) RTRandS32(void) RT_NO_THROW
+RTDECL(uint64_t) RTRandU64Ex(uint64_t u64First, uint64_t u64Last) RT_NO_THROW
 {
-    return (int32_t)RTRandU32Ex(0, UINT32_MAX);
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvU64Ex(g_hRand, u64First, u64Last);
 }
 
 
-/**
- * Generate a 64-bit unsigned random number in the set [u64First..u64Last].
- *
- * @returns The random number.
- * @param   u64First    First number in the set.
- * @param   u64Last     Last number in the set.
- */
-RTDECL(uint64_t) RTRandU64Ex(uint64_t u64First, uint64_t u64Last) RT_NO_THROW
+RTDECL(uint64_t) RTRandU64(void) RT_NO_THROW
 {
-    union
-    {
-        uint64_t    off;
-        uint32_t    off32;
-        uint8_t     ab[9];
-    } u;
-
-    const uint64_t offLast = u64Last - u64First;
-    if (offLast == UINT64_MAX)
-        /* get 8 random bytes and return them raw. */
-        rtRandGenBytes(&u.ab[0], sizeof(u.off));
-    else if (!(offLast & UINT64_C(0xf000000000000000)))
-    {
-        /* get 8 random bytes and do simple squeeze. */
-        rtRandGenBytes(&u.ab[0], sizeof(u.off));
-        u.off %= offLast + 1;
-        u.off += u64First;
-    }
-    else
-    {
-        /* get 9 random bytes and do shifted squeeze. (this ain't perfect) */
-        rtRandGenBytes(&u.ab[0], sizeof(u.ab));
-        u.off %= (offLast >> 4) + 1;
-        u.off <<= 4;
-        u.off |= u.ab[8] & 0xf;
-        if (u.off > offLast)
-            u.off = offLast;
-        u.off += u64First;
-    }
-    return u.off;
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvU64(g_hRand);
 }
 
 
-/**
- * Generate a 64-bit unsigned random number.
- *
- * @returns The random number.
- */
-RTDECL(uint64_t) RTRandU64(void) RT_NO_THROW
+RTDECL(int64_t) RTRandS64Ex(int64_t i64First, int64_t i64Last) RT_NO_THROW
 {
-    return RTRandU64Ex(0, UINT64_MAX);
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvS64Ex(g_hRand, i64First, i64Last);
 }
 
 
-/**
- * Generate a 64-bit signed random number in the set [i64First..i64Last].
- *
- * @returns The random number.
- * @param   i64First    First number in the set.
- * @param   i64Last     Last number in the set.
- */
-RTDECL(int64_t) RTRandS64Ex(int64_t i64First, int64_t i64Last) RT_NO_THROW
+RTDECL(int64_t) RTRandS64(void) RT_NO_THROW
 {
-    if (i64First == INT64_MIN && i64Last == INT64_MAX)
-        return (int64_t)RTRandU64Ex(0, UINT64_MAX);
-    return (int64_t)RTRandU64Ex(0, i64Last - i64First) + i64First;
+    RTOnce(&g_rtRandOnce, rtRandInitOnce, NULL, NULL);
+    return RTRandAdvS32(g_hRand);
 }
 
-
-/**
- * Generate a 64-bit signed random number.
- *
- * @returns The random number.
- */
-RTDECL(int64_t) RTRandS64(void) RT_NO_THROW
-{
-    return (int64_t)RTRandU64Ex(0, UINT64_MAX);
-}
-
-
-/**
- * Fallback random byte source.
- *
- * @param   pv  Where to store the random bytes.
- * @param   cb  Number of bytes to generate.
- */
-void rtRandGenBytesFallback(void *pv, size_t cb) RT_NO_THROW
-{
-    uint64_t u64Last = 0;
-    uint8_t *pb = (uint8_t *)pv;
-    for (unsigned i = 0;; i++)
-    {
-        uint32_t u32 = rtRandGenBytesFallbackU31(&g_u32Ctx);
-
-        *pb++ = (uint8_t)u32;
-        if (!--cb)
-            break;
-
-        u32 >>= 8;
-        *pb++ = (uint8_t)u32;
-        if (!--cb)
-            break;
-
-        u32 >>= 8;
-        *pb++ = (uint8_t)u32;
-        if (!--cb)
-            break;
-
-        /*
-         * Is this really a good idea? Looks like we cannot
-         * quite trust the lower bits here for instance...
-         */
-        if (!(i % 3))
-        {
-            uint64_t u64 = ASMReadTSC();
-            uint64_t u64Delta = u64 - u64Last;
-            if (u64Delta > 0xff)
-            {
-                u32 >>= 8;
-                *pb++ = ((uint8_t)u64 >> 5) | (u32 << 3);
-                if (!--cb)
-                    break;
-                u64Last = u64;
-            }
-        }
-    }
-}
-
-
-/*-
- * Copyright (c) 1990, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/* The core of:
-__FBSDID("$FreeBSD: /repoman/r/ncvs/src/lib/libc/stdlib/rand.c,v 1.16 2007/01/09 00:28:10 imp Exp $");
-*/
-
-/**
- * Generates an unsigned 31 bit pseudo random number.
- *
- * @returns pseudo random number.
- * @param   pCtx    The context.
- */
-static uint32_t rtRandGenBytesFallbackU31(uint32_t *pCtx)
-{
-    /*
-     * Compute x = (7^5 * x) mod (2^31 - 1)
-     * without overflowing 31 bits:
-     *      (2^31 - 1) = 127773 * (7^5) + 2836
-     *
-     * From "Random number generators: good ones are hard to find",  Park and
-     * Miller, Communications of the ACM, vol. 31, no. 10, October 1988, p. 1195.
-     */
-    uint32_t Ctx = *pCtx;
-    if (!Ctx) /* must not be zero. */
-        Ctx = 0x20070212;
-    uint32_t Hi = Ctx / 127773;
-    uint32_t Lo = Ctx % 127773;
-    int32_t x = 16807 * Lo  -  2836 * Hi;
-    if (x < 0)
-        x += INT32_MAX;
-    *pCtx = x;
-    return x % INT32_MAX;
-}
-

trunk/src/VBox/Runtime/common/rand/randadv.cpp

@@ -67 +67 @@
 
 
+RTDECL(int) RTRandAdvSaveState(RTRAND hRand, char *pszState, size_t *pcbState) RT_NO_THROW
+{
+    /* Validate. */
+    PRTRANDINT pThis = hRand;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTRANDINT_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtrNull(pszState);
+    AssertPtr(pcbState);
+
+    /* forward the call */
+    return pThis->pfnSaveState(pThis, pszState, pcbState);
+}
+
+
+RTDECL(int) RTRandAdvRestoreState(RTRAND hRand, char const *pszState) RT_NO_THROW
+{
+    /* Validate. */
+    PRTRANDINT pThis = hRand;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTRANDINT_MAGIC, VERR_INVALID_HANDLE);
+    AssertPtr(pszState);
+
+    /* forward the call */
+    return pThis->pfnRestoreState(pThis, pszState);
+}
+
+
 RTDECL(void) RTRandAdvBytes(RTRAND hRand, void *pv, size_t cb) RT_NO_THROW
 {
@@ -338 +365 @@
 }
 
+
+/** @copydoc RTRANDINT::pfnSeed */
+DECLCALLBACK(int) rtRandAdvStubSeed(PRTRANDINT pThis, uint64_t u64Seed)
+{
+    NOREF(pThis);
+    NOREF(u64Seed);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/** @copydoc RTRANDINT::pfnSaveState */
+DECLCALLBACK(int) rtRandAdvStubSaveState(PRTRANDINT pThis, char *pszState, size_t *pcbState)
+{
+    NOREF(pThis);
+    NOREF(pszState);
+    NOREF(pcbState);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/** @copydoc RTRANDINT::pfnRestoreState */
+DECLCALLBACK(int) rtRandAdvStubRestoreState(PRTRANDINT pThis, char const *pszState)
+{
+    NOREF(pThis);
+    NOREF(pszState);
+    return VERR_NOT_SUPPORTED;
+}
+
+
+/** @copydoc RTRANDINT::pfnDestroy */
+DECLCALLBACK(int) rtRandAdvDefaultDestroy(PRTRANDINT pThis)
+{
+    pThis->u32Magic = ~RTRANDINT_MAGIC;
+    RTMemFree(pThis);
+    return VINF_SUCCESS;
+}
+
+

trunk/src/VBox/Runtime/common/rand/randparkmiller.cpp

@@ -35 +35 @@
 #include <iprt/asm.h>
 #include <iprt/mem.h>
+#include <iprt/string.h>
 #include <iprt/err.h>
 #include "internal/rand.h"
@@ -65 +66 @@
 
 /** @copydoc RTRANDINT::pfnGetU32 */
-static uint32_t rtRandParkMillerGetU32(PRTRANDINT pThis, uint32_t u32First, uint32_t u32Last)
+static DECLCALLBACK(uint32_t) rtRandParkMillerGetU32(PRTRANDINT pThis, uint32_t u32First, uint32_t u32Last)
 {
     uint32_t off;
@@ -115 +116 @@
 
 /** @copydoc RTRANDINT::pfnSeed */
-static int rtRandParkMillerSeed(PRTRANDINT pThis, uint64_t u64Seed)
+static DECLCALLBACK(int) rtRandParkMillerSeed(PRTRANDINT pThis, uint64_t u64Seed)
 {
     pThis->u.ParkMiller.u32Ctx = u64Seed;
@@ -124 +125 @@
 
 
-/** @copydoc RTRANDINT::pfnDestroy */
-static int rtRandParkMillerDestroy(PRTRANDINT pThis)
-{
-    pThis->u32Magic = ~RTRANDINT_MAGIC;
-    RTMemFree(pThis);
+/** @copydoc RTRANDINT::pfnSaveState */
+static DECLCALLBACK(int) rtRandParkMillerSaveState(PRTRANDINT pThis, char *pszState, size_t *pcbState)
+{
+#define RTRAND_PARKMILLER_STATE_SIZE (3+8+1+8+1+2+1+1)
+
+    if (*pcbState < RTRAND_PARKMILLER_STATE_SIZE)
+    {
+        *pcbState = RTRAND_PARKMILLER_STATE_SIZE;
+        return VERR_BUFFER_OVERFLOW;
+    }
+    RTStrPrintf(pszState, *pcbState, "PM:%08RX32,%08RX32,%02x;",
+                pThis->u.ParkMiller.u32Ctx,
+                pThis->u.ParkMiller.u32Bits,
+                pThis->u.ParkMiller.cBits);
+    return VINF_SUCCESS;
+}
+
+
+/** @copydoc RTRANDINT::pfnRestoreState */
+static DECLCALLBACK(int) rtRandParkMillerRestoreState(PRTRANDINT pThis, char const *pszState)
+{
+    /* marker */
+    if (    pszState[0] != 'P'
+        ||  pszState[1] != 'M'
+        ||  pszState[2] != ':')
+        return VERR_PARSE_ERROR;
+    pszState += 3;
+
+    /* u32Ctx */
+    char *pszNext = NULL;
+    uint32_t u32Ctx;
+    int rc = RTStrToUInt32Ex(pszState, &pszNext, 16, &u32Ctx);
+    if (    rc != VWRN_TRAILING_CHARS
+        ||  pszNext !=  pszState + 8
+        ||  *pszNext != ',')
+        return VERR_PARSE_ERROR;
+    pszState += 8 + 1;
+
+    /* u32Bits */
+    uint32_t u32Bits;
+    rc = RTStrToUInt32Ex(pszState, &pszNext, 16, &u32Bits);
+    if (    rc != VWRN_TRAILING_CHARS
+        ||  pszNext !=  pszState + 8
+        ||  *pszNext != ',')
+        return VERR_PARSE_ERROR;
+    pszState += 8 + 1;
+
+    /* cBits */
+    uint32_t cBits;
+    rc = RTStrToUInt32Ex(pszState, &pszNext, 16, &cBits);
+    if (    rc != VWRN_TRAILING_CHARS
+        ||  pszNext !=  pszState + 2
+        ||  *pszNext != ';'
+        ||  pszNext[1] != '\0')
+        return VERR_PARSE_ERROR;
+
+    /* commit */
+    pThis->u.ParkMiller.u32Ctx  = u32Ctx;
+    pThis->u.ParkMiller.u32Bits = u32Bits;
+    pThis->u.ParkMiller.cBits   = cBits;
     return VINF_SUCCESS;
 }
@@ -143 +199 @@
     pThis->pfnGetU64  = rtRandAdvSynthesizeU64FromU32;
     pThis->pfnSeed    = rtRandParkMillerSeed;
-    pThis->pfnDestroy = rtRandParkMillerDestroy;
+    pThis->pfnSaveState = rtRandParkMillerSaveState;
+    pThis->pfnRestoreState = rtRandParkMillerRestoreState;
+    pThis->pfnDestroy = rtRandAdvDefaultDestroy;
     pThis->u.ParkMiller.u32Ctx = 0x20080806;
     pThis->u.ParkMiller.u32Bits = 0;

trunk/src/VBox/Runtime/include/internal/rand.h

@@ -85 +85 @@
      *
      * @returns IPRT status code.
+     * @retval  VERR_NOT_SUPPORTED if it isn't a pseudo generator.
+     *
      * @param   pThis       Pointer to the instance data.
      * @param   u64Seed     The seed.
      */
     DECLCALLBACKMEMBER(int, pfnSeed)(PRTRANDINT pThis, uint64_t u64Seed);
+
+    /**
+     * Save the current state of a pseudo generator.
+     *
+     * This can be use to save the state so it can later be resumed at the same
+     * position.
+     *
+     * @returns IPRT status code.
+     * @retval  VINF_SUCCESS on success. *pcbState contains the length of the
+     *          returned string and pszState contains the state string.
+     * @retval  VERR_BUFFER_OVERFLOW if the supplied buffer is too small. *pcbState
+     *          will contain the necessary buffer size.
+     * @retval  VERR_NOT_SUPPORTED by non-psuedo generators.
+     *
+     * @param   hRand       Handle to the random number generator.
+     * @param   pszState    Where to store the state. The returned string will be
+     *                      null terminated and printable.
+     * @param   pcbState    The size of the buffer pszState points to on input, the
+     *                      size required / used on return (including the
+     *                      terminator, thus the 'cb' instead of 'cch').
+     */
+    DECLCALLBACKMEMBER(int, pfnSaveState)(RTRAND hRand, char *pszState, size_t *pcbState);
+
+    /**
+     * Restores the state of a pseudo generator.
+     *
+     * The state must've been obtained using pfnGetState.
+     *
+     * @returns IPRT status code.
+     * @retval  VERR_PARSE_ERROR if the state string is malformed.
+     * @retval  VERR_NOT_SUPPORTED by non-psuedo generators.
+     *
+     * @param   hRand       Handle to the random number generator.
+     * @param   pszState    The state to load.
+     */
+    DECLCALLBACKMEMBER(int, pfnRestoreState)(RTRAND hRand, char const *pszState);
 
     /**
@@ -113 +151 @@
             uint32_t    cBits;
         } ParkMiller;
+
+        struct RTRandFile
+        {
+            /** The file handle. */
+            RTFILE      hFile;
+        } File;
     } u;
 } RTRANDINT;
@@ -141 +185 @@
 DECLCALLBACK(uint64_t)  rtRandAdvSynthesizeU64FromBytes(PRTRANDINT pThis, uint64_t u64First, uint64_t u64Last);
 DECLCALLBACK(uint64_t)  rtRandAdvSynthesizeU64FromU32(PRTRANDINT pThis, uint64_t u64First, uint64_t u64Last);
+DECLCALLBACK(int)       rtRandAdvStubSeed(PRTRANDINT pThis, uint64_t u64Seed);
+DECLCALLBACK(int)       rtRandAdvStubSaveState(PRTRANDINT pThis, char *pszState, size_t *pcbState);
+DECLCALLBACK(int)       rtRandAdvStubRestoreState(PRTRANDINT pThis, char const *pszState);
+DECLCALLBACK(int)       rtRandAdvDefaultDestroy(PRTRANDINT pThis);
 
 __END_DECLS

trunk/src/VBox/Runtime/r3/posix/rand-posix.cpp

@@ -48 +48 @@
 
 #include <iprt/rand.h>
+#include <iprt/mem.h>
 #include <iprt/err.h>
 #include <iprt/assert.h>
 #include "internal/rand.h"
+#include "internal/magics.h"
 
 
-/*******************************************************************************
-*   Global Variables                                                           *
-*******************************************************************************/
-/** File handle of /dev/random. */
-static int g_fhDevRandom = -1;
 
-
-void rtRandLazyInitNative(void)
+/** @copydoc RTRANDINT::pfnGetBytes */
+static DECLCALLBACK(void) rtRandAdvPosixGetBytes(PRTRANDINT pThis, uint8_t *pb, size_t cb)
 {
-    if (g_fhDevRandom != -1)
-        return;
-
-    int fh = open("/dev/urandom", O_RDONLY);
-    if (fh <= 0)
-        fh = open("/dev/random", O_RDONLY | O_NONBLOCK);
-    if (fh >= 0)
+    ssize_t cbRead = read(pThis->u.File.hFile, pb, cb);
+    if ((size_t)cbRead != cb)
     {
-        fcntl(fh, F_SETFD, FD_CLOEXEC);
-        g_fhDevRandom = fh;
+        ssize_t cTries = RT_MIN(cb, 256);
+        do
+        {
+            if (cbRead > 0)
+            {
+                cb -= cbRead;
+                pb += cbRead;
+            }
+            cbRead = read(pThis->u.File.hFile, pb, cb);
+        } while (   (size_t)cbRead != cb
+                 && cTries-- > 0);
+        AssertReleaseMsg((size_t)cbRead == cb, ("%zu != %zu, cTries=%zd errno=%d\n", cbRead, cb, cTries, errno));
     }
 }
 
 
-int rtRandGenBytesNative(void *pv, size_t cb)
+/** @copydoc RTRANDINT::pfnDestroy */
+static DECLCALLBACK(int) rtRandAdvPosixDestroy(PRTRANDINT pThis)
 {
-    int fh = g_fhDevRandom;
-    if (fh == -1)
-        return VERR_NOT_SUPPORTED;
-
-    ssize_t cbRead = read(fh, pv, cb);
-    if ((size_t)cbRead != cb)
-    {
-        /* 
-         * Use the fallback for the remainder if /dev/urandom / /dev/random 
-         * is out to lunch. 
-         */
-        if (cbRead <= 0)
-            rtRandGenBytesFallback(pv, cb);
-        else 
-        {
-            AssertRelease((size_t)cbRead < cb);
-            rtRandGenBytesFallback((uint8_t *)pv + cbRead, cb - cbRead);
-        }
-    }
+    pThis->u32Magic = ~RTRANDINT_MAGIC;
+    int fd = pThis->u.File.hFile;
+    pThis->u.File.hFile = NIL_RTFILE;
+    RTMemFree(pThis);
+    close(fd);
     return VINF_SUCCESS;
 }
 
+
+static int rtRandAdvPosixCreateNonPseudo(PRTRAND phRand, const char *pszDev) RT_NO_THROW
+{
+    /*
+     * Try open it first and then setup the handle structure.
+     */
+    int fd = open(pszDev, O_RDONLY);
+    if (fd < 0)
+        return RTErrConvertFromErrno(errno);
+    int rc;
+    if (fcntl(fd, F_SETFD, FD_CLOEXEC) != -1)
+    {
+        PRTRANDINT pThis = (PRTRANDINT)RTMemAlloc(sizeof(*pThis));
+        if (pThis)
+        {
+            pThis->u32Magic     = RTRANDINT_MAGIC;
+            pThis->pfnGetBytes  = rtRandAdvPosixGetBytes;
+            pThis->pfnGetU32    = rtRandAdvSynthesizeU32FromBytes;
+            pThis->pfnGetU64    = rtRandAdvSynthesizeU64FromBytes;
+            pThis->pfnSeed      = rtRandAdvStubSeed;
+            pThis->pfnSaveState = rtRandAdvStubSaveState;
+            pThis->pfnRestoreState = rtRandAdvStubRestoreState;
+            pThis->pfnDestroy   = rtRandAdvPosixDestroy;
+            pThis->u.File.hFile = fd;
+
+            *phRand = pThis;
+            return VINF_SUCCESS;
+        }
+
+        /* bail out */
+        rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = RTErrConvertFromErrno(errno);
+    close(fd);
+    return rc;
+}
+
+
+RTDECL(int) RTRandAdvCreateNonPseudo(PRTRAND phRand) RT_NO_THROW
+{
+    return rtRandAdvPosixCreateNonPseudo(phRand, "/dev/urandom");
+}
+
+
+RTDECL(int) RTRandAdvCreatePureNonPseudo(PRTRAND phRand) RT_NO_THROW
+{
+    return rtRandAdvPosixCreateNonPseudo(phRand, "/dev/random");
+}
+
+

trunk/src/VBox/Runtime/testcase/tstRand.cpp

@@ -317 +317 @@
 
     /*
+     * Test saving and restoring the state.
+     */
+    RTPrintf("tstRand:   TESTING RTRandAdvSave/RestoreSave\n");
+    char szState[256];
+    size_t cbState = sizeof(szState);
+    int rc = RTRandAdvSaveState(hRand, szState, &cbState);
+    if (rc != VERR_NOT_SUPPORTED)
+    {
+        CHECK_EXPR_MSG(rc == VINF_SUCCESS,  ("RTRandAdvSaveState(%p,,256) -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
+        uint32_t const u32A1 = RTRandAdvU32(hRand);
+        uint32_t const u32B1 = RTRandAdvU32(hRand);
+        RTPrintf("tstRand:   state:\"%s\"  A=%RX32 B=%RX32\n", szState, u32A1, u32B1);
+
+        rc = RTRandAdvRestoreState(hRand, szState);
+        CHECK_EXPR_MSG(rc == VINF_SUCCESS,  ("RTRandAdvRestoreState(%p,\"%s\") -> %Rrc (%d)\n", (uintptr_t)hRand, szState, rc, rc));
+        uint32_t const u32A2 = RTRandAdvU32(hRand);
+        uint32_t const u32B2 = RTRandAdvU32(hRand);
+        CHECK_EXPR_MSG(u32A1 == u32A2, ("u32A1=%RX32 u32A2=%RX32\n", u32A1, u32A2));
+        CHECK_EXPR_MSG(u32B1 == u32B2, ("u32B1=%RX32 u32B2=%RX32\n", u32B1, u32B2));
+    }
+    else
+    {
+        szState[0] = '\0';
+        rc = RTRandAdvRestoreState(hRand, szState);
+        CHECK_EXPR_MSG(rc == VERR_NOT_SUPPORTED,  ("RTRandAdvRestoreState(%p,\"\") -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));
+    }
+
+
+    /*
      * Destroy it.
      */
-    int rc = RTRandAdvDestroy(hRand);
+    rc = RTRandAdvDestroy(hRand);
     CHECK_EXPR_MSG(rc == VINF_SUCCESS,  ("RTRandAdvDestroy(%p) -> %Rrc (%d)\n", (uintptr_t)hRand, rc, rc));