1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include "random.h"
#include <errno.h>
#include <stdlib.h>
#include <sys/time.h>
#include "entropy.h"
#include "hash.h"
#include "ovs-thread.h"
#include "timeval.h"
#include "util.h"
/* This is the 32-bit PRNG recommended in G. Marsaglia, "Xorshift RNGs",
* _Journal of Statistical Software_ 8:14 (July 2003). According to the paper,
* it has a period of 2**32 - 1 and passes almost all tests of randomness.
*
* We use this PRNG instead of libc's rand() because rand() varies in quality
* and because its maximum value also varies between 32767 and INT_MAX, whereas
* we often want random numbers in the full range of uint32_t.
*
* This random number generator is intended for purposes that do not require
* cryptographic-quality randomness. */
/* Current random state. */
DEFINE_STATIC_PER_THREAD_DATA(uint32_t, seed, 0);
static uint32_t random_next(void);
void
random_init(void)
{
uint32_t *seedp = seed_get();
while (!*seedp) {
struct timeval tv;
uint32_t entropy;
pthread_t self;
xgettimeofday(&tv);
get_entropy_or_die(&entropy, 4);
self = pthread_self();
*seedp = (tv.tv_sec ^ tv.tv_usec ^ entropy
^ hash_bytes(&self, sizeof self, 0));
}
}
void
random_set_seed(uint32_t seed_)
{
ovs_assert(seed_);
*seed_get() = seed_;
}
void
random_bytes(void *p_, size_t n)
{
uint8_t *p = p_;
random_init();
for (; n > 4; p += 4, n -= 4) {
uint32_t x = random_next();
memcpy(p, &x, 4);
}
if (n) {
uint32_t x = random_next();
memcpy(p, &x, n);
}
}
uint8_t
random_uint8(void)
{
return random_uint32();
}
uint16_t
random_uint16(void)
{
return random_uint32();
}
uint32_t
random_uint32(void)
{
random_init();
return random_next();
}
uint64_t
random_uint64(void)
{
uint64_t x;
random_init();
x = random_next();
x |= (uint64_t) random_next() << 32;
return x;
}
int
random_range(int max)
{
return random_uint32() % max;
}
static uint32_t
random_next(void)
{
uint32_t *seedp = seed_get_unsafe();
*seedp ^= *seedp << 13;
*seedp ^= *seedp >> 17;
*seedp ^= *seedp << 5;
return *seedp;
}
|
