/* Get random numbers from OS. Returns 1 if it succeeded and otherwise 0

 * Does not block. Designed for getting small amounts of random data at a time */

#include <stddef.h>

/* Solaris has both getrandom and getentropy. We use getrandom since getentropy

 * can block. Solaris has had getrandom() and getentropy() since 11.3 */

#if defined(__sun)

    #include <sys/random.h>

    /* On solaris, _GRND_ENTROPY is defined if getentropy/getrandom are available */

    #if defined(_GRND_ENTROPY)

        #define MVM_random_use_getrandom 1

    #endif

#endif

/* Linux added getrandom to the kernel in 3.17 */

#if defined(__linux__)

    #include <sys/syscall.h>

    #if defined(SYS_getrandom)

    /* With glibc you are supposed to declare _GNU_SOURCE to use the

     * syscall function */

        #define _GNU_SOURCE

        #define GRND_NONBLOCK 0x01

        #include <unistd.h>

        #define MVM_random_use_getrandom_syscall 1

    #else

        #define MVM_random_use_urandom 1

    #endif

#endif

/* FreeBSD added it with SVN revision 331279 Wed Mar 21, 2018

 * This corresponds to __FreeBSD_version version identifier: 1200061.

 * https://svnweb.freebsd.org/base?view=revision&revision=r331279 */

#if defined(__FreeBSD__)

    #include <osreldate.h>

    #if __FreeBSD_version >= 1200061

        #include <sys/random.h>

        #define MVM_random_use_getrandom

    #endif

#endif

/* OpenBSD's getentropy never blocks and always succeeds. OpenBSD has had

 * getentropy() since 5.6 */

#if defined(__OpenBSD__)

    #include <sys/param.h>

    #if OpenBSD >= 201301

        #define MVM_random_use_getentropy

    #endif

#endif

/* MacOS has had getentropy() since 10.12 */

#if defined(__APPLE__)

    #include <AvailabilityMacros.h>

    #include <Availability.h>

    #if !defined(MAC_OS_X_VERSION_10_12)

        #define MAC_OS_X_VERSION_10_12 101200

    #endif

    #if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_12

        #include <sys/random.h>

        #define MVM_random_use_getentropy 1

    #endif

#endif

/* Other info:

 * - All BSD's should support arc4random

 * - AIX is a Unix but has no arc4random, does have /dev/urandom.

 * - NetBSD: I have not found evidence it has getentropy() or getrandom()

 *     Note: Uses __NetBSD_Version__ included from file <sys/param.h>. */

#include "moar.h"

/* On Unix like platforms that don't support getrandom() or getentropy()

 * we defualt to /dev/urandom. On platforms that do support these calls, we

 * only use /dev/urandom if those calls fail. This is also important on Linux,

 * since if MoarVM was compiled on a kernel >= 3.17 it will be set to use the

 * syscall. If the syscall doesn't exist, the syscall wrapper will gracefully

 * return a false return value and we will fallback to /dev/urandom */

#if !defined(_WIN32)

    #include <unistd.h>

    MVMint32 MVM_getrandom_urandom (MVMThreadContext *tc, void *out, size_t size) {

        int fd = open("/dev/urandom", O_RDONLY);

        ssize_t num_read = 0;

        if (fd < 0 || (num_read = read(fd, out, size) <= 0)) {

            if (fd) close(fd);

            /* If using /dev/urandom fails (maybe we're in a chroot), on BSD's

             * use arc4random, which is likely seeded from the system's random

             * number generator */

            #if defined(BSD)

                #include <stdlib.h>

                arc4random_buf(out, size);

                return 1;

            #else

                return 0;

            #endif

        }

        return 1;

    }

#endif

#if defined(MVM_random_use_getrandom_syscall)

/* getrandom() was added to glibc much later than it was added to the kernel. Since

 * we detect the presence of the system call to decide whether to use this,

 * just use the syscall instead since the wrapper is not guaranteed to exist.*/

    MVMint32 MVM_getrandom (MVMThreadContext *tc, void *out, size_t size) {

        long rtrn = syscall(SYS_getrandom, out, size, GRND_NONBLOCK);

        return rtrn <= 0 ? MVM_getrandom_urandom(tc, out, size) : 1;

    }

#elif defined(MVM_random_use_getrandom)

    /* Call the getrandom() wrapper in Solaris and FreeBSD since they were

     * added at the same time as getentropy() and this allows us to avoid blocking. */

    MVMint32 MVM_getrandom (MVMThreadContext *tc, void *out, size_t size) {

        ssize_t rtrn = getrandom(out, size, GRND_NONBLOCK);

        return rtrn <= 0 ? MVM_getrandom_urandom(tc, out, size) : 1;

    }

#elif defined(MVM_random_use_getentropy)

    MVMint32 MVM_getrandom (MVMThreadContext *tc, void *out, size_t size) {

        int rtrn = getentropy(out, size);

        return rtrn <= 0 ? MVM_getrandom_urandom(tc, out, size) : 1;

    }

#elif defined(_WIN32)

    #include <windows.h>

    #include <wincrypt.h>

    /* Signatures for pCryptAcquireContext() and pCryptGenRandom() */

    typedef BOOL (WINAPI *CRYPTACQUIRECONTEXTA)(HCRYPTPROV *phProv,\

                  LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType,\

                  DWORD dwFlags );

    typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen,\

                  BYTE *pbBuffer );

    /* The functions themselves */

    static CRYPTGENRANDOM pCryptGenRandom = NULL;

    static HCRYPTPROV       hCryptContext = 0;

    static int win32_urandom_init(void) {

        /* Get Module Handle to CryptoAPI */

        HINSTANCE hAdvAPI32 = GetModuleHandle("advapi32.dll");

        if (hAdvAPI32) {

            CRYPTACQUIRECONTEXTA pCryptAcquireContext =

                              GetProcAddress(hAdvAPI32, "CryptAcquireContextA");

            pCryptGenRandom = GetProcAddress(hAdvAPI32, "CryptGenRandom");

            /* Check the pointers to the CryptoAPI functions. These shouldn't fail

             * but makes sure we won't have problems getting the context or getting

             * random. If those aren't NULL then get the pCrypt context */

            return pCryptAcquireContext && pCryptGenRandom &&

                pCryptAcquireContext(&hCryptContext, NULL, NULL, PROV_RSA_FULL,

                CRYPT_VERIFYCONTEXT) ? 1 : 0;

        }

        return 0;

    }

    MVMint32 MVM_getrandom (MVMThreadContext *tc, void *out, size_t size) {

        /* Return 0 if the context doesn't exist and we are unable to create it */

        if (!hCryptContext && !win32_urandom_init())

            return 0;

        return pCryptGenRandom(hCryptContext, (DWORD)size, (BYTE*)out) ? 1 : 0;

    }

#else

    MVMint32 MVM_getrandom (MVMThreadContext *tc, void *out, size_t size) {

        return MVM_getrandom_urandom(tc, out, size);

    }

#endif