31#if defined(HAVE_SYS_TIME_H)
37#elif defined HAVE_SYS_SYSCALL_H
38# include <sys/syscall.h>
49# include <sys/param.h>
52#if defined HAVE_GETRANDOM
53# include <sys/random.h>
54#elif defined __linux__ && defined __NR_getrandom
55# include <linux/random.h>
59# include <AvailabilityMacros.h>
68#include "internal/variable.h"
80genrand_real(
struct MT *mt)
83 unsigned int a = genrand_int32(mt), b = genrand_int32(mt);
84 return int_pair_to_real_exclusive(a, b);
87static const double dbl_reduce_scale =
102 return (a*(
double)(1ul<<(32-b_shift))+b)*dbl_reduce_scale;
109genrand_real2(
struct MT *mt)
112 uint32_t a = genrand_int32(mt), b = genrand_int32(mt);
113 return int_pair_to_real_inclusive(a, b);
127#define DEFAULT_SEED_CNT 4
131static void fill_random_seed(
uint32_t *seed,
size_t cnt);
152 return &rand_mt_start(r)->
base;
158default_rand_mark(
void *
ptr)
185 return rand_mt_start(default_rand());
191 struct MT *mt = &default_mt()->
mt;
192 return genrand_int32(mt);
198 struct MT *mt = &default_mt()->
mt;
199 return genrand_real(mt);
202#define SIZEOF_INT32 (31/CHAR_BIT + 1)
209 enum {dig_u = dig-32, dig_r64 = 64-dig, bmask = ~(~0u<<(dig_r64))};
210#if defined HAVE_UINT128_T
211 const uint128_t m = ((uint128_t)1 << dig) | 1;
212 uint128_t x = ((uint128_t)a << 32) | b;
213 r = (double)(
uint64_t)((x * m) >> 64);
214#elif defined HAVE_UINT64_T && !MSC_VERSION_BEFORE(1300)
216 (((
uint64_t)b + (a >> dig_u)) >> dig_r64);
220 b = (b >> dig_r64) + (((a >> dig_u) + (b & bmask)) >> dig_r64);
221 r = (double)a * (1 << dig_u) + b;
223 return r * dbl_reduce_scale;
229static ID id_rand, id_bytes;
233#define random_mark rb_random_mark
241#define random_free RUBY_TYPED_DEFAULT_FREE
244random_memsize(
const void *
ptr)
259#define random_mt_mark rb_random_mark
262random_mt_free(
void *
ptr)
270random_mt_memsize(
const void *
ptr)
283 (
void *)&random_mt_if,
292 if (RTYPEDDATA_TYPE(obj) == &random_mt_type)
306try_get_rnd(
VALUE obj)
309 return rand_start(default_rand());
312 if (RTYPEDDATA_TYPE(obj) == &random_mt_type)
317 RTYPEDDATA_TYPE(obj)->wrap_struct_name);
325 if (rnd == &default_rand()->base) {
326 return &random_mt_if;
328 return rb_rand_if(obj);
340random_alloc(
VALUE klass)
351 VALUE seed, buf0 = 0;
355 fill_random_seed(
buf,
len);
357 seed = make_seed_value(
buf,
len);
379 if (sign != 2 &&
buf[
len-1] == 1)
405 RTYPEDDATA_TYPE(obj)->wrap_struct_name);
410 rnd->
seed = rand_init_default(rng, rnd);
418#define DEFAULT_SEED_LEN (DEFAULT_SEED_CNT * (int)sizeof(int32_t))
420#if defined(S_ISCHR) && !defined(DOSISH)
421# define USE_DEV_URANDOM 1
423# define USE_DEV_URANDOM 0
447 if (fd < 0)
return -1;
449 if (
fstat(fd, &statbuf) == 0 &&
S_ISCHR(statbuf.st_mode)) {
463# define fill_random_bytes_urandom(seed, size) -1
466#if ! defined HAVE_GETRANDOM && defined __linux__ && defined __NR_getrandom
467# ifndef GRND_NONBLOCK
468# define GRND_NONBLOCK 0x0001
470# define getrandom(ptr, size, flags) \
471 (ssize_t)syscall(__NR_getrandom, (ptr), (size), (flags))
472# define HAVE_GETRANDOM 1
476#elif defined MAC_OS_X_VERSION_10_7 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_7
477#include <Security/Security.h>
482 int status = SecRandomCopyBytes(kSecRandomDefault,
size, seed);
484 if (status != errSecSuccess) {
486 CFStringRef s = SecCopyErrorMessageString(status,
NULL);
487 const char *m = s ? CFStringGetCStringPtr(s, kCFStringEncodingUTF8) :
NULL;
488 fprintf(stderr,
"SecRandomCopyBytes failed: %d: %s\n", status,
496#elif defined(HAVE_ARC4RANDOM_BUF)
500#if (defined(__OpenBSD__) && OpenBSD >= 201411) || \
501 (defined(__NetBSD__) && __NetBSD_Version__ >= 700000000) || \
502 (defined(__FreeBSD__) && __FreeBSD_version >= 1200079)
511release_crypt(
void *p)
515 CryptReleaseContext(prov, 0);
522 static HCRYPTPROV perm_prov;
523 HCRYPTPROV prov = perm_prov, old_prov;
525 if (!CryptAcquireContext(&prov,
NULL,
NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
531#undef RUBY_UNTYPED_DATA_WARNING
532#define RUBY_UNTYPED_DATA_WARNING 0
538 CryptReleaseContext(prov, 0);
544 CryptGenRandom(prov,
size, seed);
547#elif defined HAVE_GETRANDOM
551 static rb_atomic_t try_syscall = 1;
556 flags = GRND_NONBLOCK;
571# define fill_random_bytes_syscall(seed, size, need_secure) -1
578 if (ret == 0)
return ret;
582#define fill_random_bytes ruby_fill_random_bytes
589#if defined HAVE_CLOCK_GETTIME
591#elif defined HAVE_GETTIMEOFDAY
594 size_t len =
cnt *
sizeof(*seed);
596 memset(seed, 0,
len);
600#if defined HAVE_CLOCK_GETTIME
603#elif defined HAVE_GETTIMEOFDAY
605 seed[0] ^= tv.tv_usec;
608#
if SIZEOF_TIME_T > SIZEOF_INT
611 seed[2] ^= getpid() ^ (n++ << 16);
613#if SIZEOF_VOIDP > SIZEOF_INT
634#define with_random_seed(size, add) \
635 for (uint32_t seedbuf[(size)+(add)], loop = (fill_random_seed(seedbuf, (size)), 1); \
636 loop; explicit_bzero(seedbuf, (size)*sizeof(seedbuf[0])), loop = 0)
677 if (n == 0)
return buf;
698random_get_seed(
VALUE obj)
700 return get_rnd(obj)->
seed;
712 rnd1 = get_rnd_mt(obj);
713 rnd2 = get_rnd_mt(orig);
722mt_state(
const struct MT *mt)
725 sizeof(*mt->
state), 0,
731rand_mt_state(
VALUE obj)
734 return mt_state(&rnd->
mt);
739random_s_state(
VALUE klass)
741 return mt_state(&default_rand()->mt);
746rand_mt_left(
VALUE obj)
754random_s_left(
VALUE klass)
761rand_mt_dump(
VALUE obj)
778 struct MT *mt = &rnd->
mt;
796 sizeof(*mt->
state), 0,
814 init_genrand(mt,
len ?
buf[0] : 0);
817 init_by_array(mt,
buf, (
int)
len);
825 return genrand_int32(mt);
864 seed = random_seed(obj);
870 rand_init(&random_mt_if, &r->
base, seed);
877make_mask(
unsigned long x)
894 unsigned long val,
mask;
896 if (!limit)
return 0;
897 mask = make_mask(limit);
900 if (0xffffffff < limit) {
905 if ((
mask >> (i * 32)) & 0xffffffff) {
918 }
while (limit < val);
932 uint32_t *tmp, *lim_array, *rnd_array;
939 rnd_array = tmp +
len;
946 for (i =
len-1; 0 <= i; i--) {
978 return limited_rand(&random_mt_if, &mt->
base, limit);
982obj_random_bytes(
VALUE obj,
void *p,
long n)
1009 obj_random_bytes(obj, &x,
sizeof(x));
1010 return (
unsigned int)x;
1012 return random_int32(try_rand_if(obj, rnd), rnd);
1022 obj_random_bytes(obj, x,
sizeof(x));
1029 a = random_int32(rng, rnd);
1030 b = random_int32(rng, rnd);
1039 return int_pair_to_real_exclusive(a, b);
1042 return int_pair_to_real_inclusive(a, b);
1056 else if (d >= 1.0) {
1061 return random_real(obj, rnd,
TRUE);
1065ulong_to_num_plus_1(
unsigned long n)
1068 return ULL2NUM((LONG_LONG)n+1);
1070 if (n >= ULONG_MAX) {
1080 if (!limit)
return 0;
1082 const int w =
sizeof(limit) *
CHAR_BIT - nlz_long(limit);
1083 const int n = w > 32 ?
sizeof(
unsigned long) :
sizeof(
uint32_t);
1084 const unsigned long mask = ~(~0UL << w);
1085 const unsigned long full =
1086 (size_t)n >=
sizeof(
unsigned long) ? ~0UL :
1088 unsigned long val,
bits = 0, rest = 0;
1092 obj_random_bytes(obj, &
buf, n);
1100 }
while (limit < val);
1103 return limited_rand(try_rand_if(obj, rnd), rnd, limit);
1111 VALUE lim = ulong_to_num_plus_1(limit);
1122 return limited_rand(try_rand_if(obj, rnd), rnd, limit);
1139 obj_random_bytes(obj, rnd_array,
len *
sizeof(
uint32_t));
1140 rnd_array[0] &=
mask;
1141 for (i = 0; i <
len; ++i) {
1142 if (lim_array[i] < rnd_array[i])
1144 if (rnd_array[i] < lim_array[i])
1151 return limited_big_rand(try_rand_if(obj, rnd), rnd, vmax);
1209 return obj_random_bytes(obj,
NULL, n);
1211 return rand_bytes(try_rand_if(obj, rnd), rnd, n);
1228random_s_seed(
VALUE obj)
1240 if (begp) *begp = beg;
1242 if (endp) *endp = end;
1257 if (restrictive)
return Qnil;
1260 r = random_ulong_limited(obj, rnd, (
unsigned long)
max - 1);
1266 if (!BIGNUM_SIGN(vmax)) {
1267 if (restrictive)
return Qnil;
1274 r = random_ulong_limited(obj, rnd,
max);
1277 ret = random_ulong_limited_big(obj, rnd, vmax);
1292invalid_argument(
VALUE arg0)
1305 invalid_argument(
argv[0]);
1326 if ((v = vmax = range_values(
range, &beg, &end, &excl)) ==
Qfalse)
1336 unsigned long r = random_ulong_limited(obj, rnd, (
unsigned long)
max);
1346 v = random_ulong_limited_big(obj, rnd, vmax);
1364 r = random_real(obj, rnd, excl);
1370 else if (
max == 0.0 && !excl) {
1432 check_random_number(v,
argv);
1446 if (!RB_TYPE_P(vmax,
T_FLOAT)) {
1448 if (!
NIL_P(v))
return rand_int(obj, rnd, v, 1);
1452 const double max = float_value(v);
1457 double r = random_real(obj, rnd,
TRUE);
1462 return rand_range(obj, rnd, vmax);
1480 if (
NIL_P(v)) v = rand_random(0, 0, obj, rnd);
1481 else if (!v) invalid_argument(
argv[0]);
1514 r1 = get_rnd_mt(self);
1515 r2 = get_rnd_mt(other);
1517 if ((
r1->mt.next -
r1->mt.state) != (
r2->mt.next -
r2->mt.state))
return Qfalse;
1518 if (
r1->mt.left !=
r2->mt.left)
return Qfalse;
1560 VALUE v = rand_range(obj, rnd, vmax);
1561 if (v !=
Qfalse)
return v;
1564 v = rand_int(obj, rnd, vmax, 0);
1565 if (!
NIL_P(v))
return v;
1581 check_random_number(v,
argv);
1585#define SIP_HASH_STREAMING 0
1586#define sip_hash13 ruby_sip_hash13
1587#if !defined _WIN32 && !defined BYTE_ORDER
1588# ifdef WORDS_BIGENDIAN
1589# define BYTE_ORDER BIG_ENDIAN
1591# define BYTE_ORDER LITTLE_ENDIAN
1593# ifndef LITTLE_ENDIAN
1594# define LITTLE_ENDIAN 1234
1597# define BIG_ENDIAN 4321
1613init_hash_salt(
struct MT *mt)
1617 for (i = 0; i <
numberof(hash_salt.u32); ++i)
1618 hash_salt.u32[i] = genrand_int32(mt);
1659 init_hash_salt(&mt);
1700 ID id_base = rb_intern_const(
"Base");
VALUE rb_ary_push(VALUE ary, VALUE item)
int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
VALUE rb_big_minus(VALUE x, VALUE y)
int rb_bigzero_p(VALUE x)
VALUE rb_big_plus(VALUE x, VALUE y)
size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
VALUE rb_big_norm(VALUE x)
VALUE rb_big_uminus(VALUE x)
int bits(struct state *s, int need)
Internal header absorbing C compipler differences.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
#define range(low, item, hi)
#define ATOMIC_PTR_CAS(var, old, new)
#define rb_deprecate_constant(mod, name)
#define RSTRING_LEN(string)
#define RSTRING_PTR(string)
void ruby_xfree(void *x)
Deallocates a storage instance.
void rb_gc_mark(VALUE ptr)
void rb_gc_register_mark_object(VALUE obj)
Inform the garbage collector that object is a live Ruby object that should not be moved.
void rb_include_module(VALUE klass, VALUE module)
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_define_module_under(VALUE outer, const char *name)
VALUE rb_define_class_id(ID id, VALUE super)
Defines a new class.
void rb_raise(VALUE exc, const char *fmt,...)
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
void rb_check_copyable(VALUE obj, VALUE orig)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_eSystemCallError
VALUE rb_check_to_int(VALUE)
Tries to convert val into Integer.
VALUE rb_cObject
Object class.
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
VALUE rb_check_to_float(VALUE)
Tries to convert an object into Float.
VALUE rb_obj_class(VALUE)
VALUE rb_to_float(VALUE)
Converts a Numeric object into Float.
VALUE rb_equal(VALUE, VALUE)
This function is an optimized version of calling #==.
VALUE rb_to_int(VALUE)
Converts val into Integer.
Thin wrapper to ruby/config.h.
VALUE rb_funcallv_public(VALUE, ID, int, const VALUE *)
Calls a method.
#define INTEGER_PACK_NATIVE_BYTE_ORDER
#define INTEGER_PACK_MSWORD_FIRST
#define INTEGER_PACK_LSWORD_FIRST
void rb_update_max_fd(int fd)
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
#define OBJ_INIT_COPY(obj, orig)
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
#define rb_str_new(str, len)
void rb_const_set(VALUE, ID, VALUE)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
void rb_undef_alloc_func(VALUE)
ID rb_intern(const char *)
void rb_define_const(VALUE, const char *, VALUE)
void explicit_bzero(void *b, size_t len)
#define RB_RANDOM_INTERFACE_DEFINE(prefix)
struct rb_random_struct rb_random_t
#define RB_RANDOM_INTERFACE_DECLARE(prefix)
unsigned int rb_random_get_int32_func(rb_random_t *)
Internal header for Array.
Internal header for Numeric.
int rb_num_negative_p(VALUE)
Internal header for Random.
VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE)
#define type_roomof(x, y)
typedef long(ZCALLBACK *tell_file_func) OF((voidpf opaque
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
#define INVALID_HANDLE_VALUE
Historical shim for <limits.h>.
#define domain_error(msg)
Internal header for Math.
int memcmp(const void *s1, const void *s2, size_t len)
#define genrand_initialized(mt)
#define uninit_genrand(mt)
#define RARRAY_AREF(a, i)
void * rb_ractor_local_storage_ptr(rb_ractor_local_key_t key)
void rb_ractor_local_storage_ptr_set(rb_ractor_local_key_t key, void *ptr)
rb_ractor_local_key_t rb_ractor_local_storage_ptr_newkey(const struct rb_ractor_local_storage_type *type)
#define fill_random_bytes_syscall(seed, size, need_secure)
double rb_random_real(VALUE obj)
const rb_data_type_t rb_random_data_type
void Init_RandomSeedCore(void)
st_index_t rb_memhash(const void *ptr, long len)
void rb_reset_random_seed(void)
VALUE rb_random_bytes(VALUE obj, long n)
unsigned long rb_genrand_ulong_limited(unsigned long limit)
double rb_genrand_real(void)
unsigned long rb_random_ulong_limited(VALUE obj, unsigned long limit)
#define with_random_seed(size, add)
int ruby_fill_random_bytes(void *seed, size_t size, int need_secure)
double rb_int_pair_to_real(uint32_t a, uint32_t b, int excl)
unsigned int rb_genrand_int32(void)
uint32_t u32[type_roomof(hash_salt_t, uint32_t)]
st_index_t rb_hash_start(st_index_t h)
int int_must_be_32bit_at_least[sizeof(int) *CHAR_BIT< 32 ? -1 :1]
#define fill_random_bytes_urandom(seed, size)
void rb_rand_bytes_int32(rb_random_get_int32_func *get_int32, rb_random_t *rnd, void *p, size_t n)
unsigned int rb_random_int32(VALUE obj)
void rb_random_base_init(rb_random_t *rnd)
#define fill_random_bytes
#define Data_Wrap_Struct(klass, mark, free, sval)
#define TypedData_Get_Struct(obj, type, data_type, sval)
@ RUBY_TYPED_FREE_IMMEDIATELY
#define TypedData_Make_Struct(klass, type, data_type, sval)
#define ATOMIC_PTR_EXCHANGE(var, val)
#define ATOMIC_SET(var, val)
Internal header for ASAN / MSAN / etc.
#define NO_SANITIZE(x, y)
unsigned long long uint64_t
rb_atomic_t cnt[RUBY_NSIG]
rb_random_init_func * init
rb_random_get_int32_func * get_int32
rb_random_get_real_func * get_real
void error(const char *msg)
int gettimeofday(struct timeval *, struct timezone *)
int clock_gettime(clockid_t, struct timespec *)
int read(izstream &zs, T *x, Items items)
#define ZALLOC(strm, items, size)