1 files changed, 81 insertions, 50 deletions

diff --git a/src/lib/libc/stdlib/random.c b/src/lib/libc/stdlib/random.c
index 469b6d976a..48e892042b 100644
--- a/src/lib/libc/stdlib/random.c
+++ b/src/lib/libc/stdlib/random.c
@@ -1,3 +1,4 @@
+/*      $OpenBSD: random.c,v 1.15 2005/11/30 07:51:02 otto Exp $ */
 /*
  * Copyright (c) 1983 Regents of the University of California.
  * All rights reserved.
@@ -10,11 +11,7 @@
  * 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.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. 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.
  *
@@ -31,13 +28,13 @@
  * SUCH DAMAGE.
  */
 
-#if defined(LIBC_SCCS) && !defined(lint)
-/*static char *sccsid = "from: @(#)random.c     5.9 (Berkeley) 2/23/91";*/
-static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $";
-#endif /* LIBC_SCCS and not lint */
-
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 /*
  * random.c:
@@ -55,10 +52,10 @@ static char *rcsid = "$Id: random.c,v 1.1.1.1 1995/10/18 08:42:19 deraadt Exp $"
  * congruential generator.  If the amount of state information is less than
  * 32 bytes, a simple linear congruential R.N.G. is used.
  *
- * Internally, the state information is treated as an array of longs; the
+ * Internally, the state information is treated as an array of int32_t; the
  * zeroeth element of the array is the type of R.N.G. being used (small
  * integer); the remainder of the array is the state information for the
- * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
+ * R.N.G.  Thus, 32 bytes of state information will give 7 int32_ts worth of
  * state information, which will allow a degree seven polynomial.  (Note:
  * the zeroeth word of state information also has some other information
  * stored in it -- see setstate() for details).
@@ -134,14 +131,14 @@ static int seps [MAX_TYPES] =	{ SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
  *      MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3.
  */
 
-static long randtbl[DEG_3 + 1] = {
+static int32_t randtbl[DEG_3 + 1] = {
         TYPE_3,
-        0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 0xde3b81e0, 0xdf0a6fb5,
-        0xf103bc02, 0x48f340fb, 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
-        0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 0xda672e2a, 0x1588ca88,
-        0xe369735d, 0x904f35f7, 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
-        0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 0xf5ad9d0e, 0x8999220b,
-        0x27fb47b9,
+        0x991539b1, 0x16a5bce3, 0x6774a4cd, 0x3e01511e, 0x4e508aaa, 0x61048c05, 
+        0xf5500617, 0x846b7115, 0x6a19892c, 0x896a97af, 0xdb48f936, 0x14898454, 
+        0x37ffd106, 0xb58bff9c, 0x59e17104, 0xcf918a49, 0x09378c83, 0x52c7a471, 
+        0x8d293ea9, 0x1f4fc301, 0xc3db71be, 0x39b44e1c, 0xf8a44ef9, 0x4c8b80b1, 
+        0x19edc328, 0x87bf4bdd, 0xc9b240e5, 0xe9ee4b1b, 0x4382aee7, 0x535b6b41, 
+        0xf3bec5da,
 };
 
 /*
@@ -158,8 +155,8 @@ static long randtbl[DEG_3 + 1] = {
  * in the initialization of randtbl) because the state table pointer is set
  * to point to randtbl[1] (as explained below).
  */
-static long *fptr = &randtbl[SEP_3 + 1];
-static long *rptr = &randtbl[1];
+static int32_t *fptr = &randtbl[SEP_3 + 1];
+static int32_t *rptr = &randtbl[1];
 
 /*
  * The following things are the pointer to the state information table, the
@@ -171,11 +168,11 @@ static long *rptr = &randtbl[1];
  * this is more efficient than indexing every time to find the address of
  * the last element to see if the front and rear pointers have wrapped.
  */
-static long *state = &randtbl[1];
+static int32_t *state = &randtbl[1];
+static int32_t *end_ptr = &randtbl[DEG_3 + 1];
 static int rand_type = TYPE_3;
 static int rand_deg = DEG_3;
 static int rand_sep = SEP_3;
-static long *end_ptr = &randtbl[DEG_3 + 1];
 
 /*
  * srandom:
@@ -190,18 +187,28 @@ static long *end_ptr = &randtbl[DEG_3 + 1];
  * for default usage relies on values produced by this routine.
  */
 void
-srandom(x)
-        u_int x;
+srandom(unsigned int x)
 {
-        register int i, j;
+        int i;
+        int32_t test;
+        div_t val;
 
         if (rand_type == TYPE_0)
                 state[0] = x;
         else {
-                j = 1;
                 state[0] = x;
-                for (i = 1; i < rand_deg; i++)
-                        state[i] = 1103515245 * state[i - 1] + 12345;
+                for (i = 1; i < rand_deg; i++) {
+                        /*
+                         * Implement the following, without overflowing 31 bits:
+                         *
+                         *      state[i] = (16807 * state[i - 1]) % 2147483647;
+                         *
+                         *      2^31-1 (prime) = 2147483647 = 127773*16807+2836
+                         */
+                        val = div(state[i-1], 127773);
+                        test = 16807 * val.rem - 2836 * val.quot;
+                        state[i] = test + (test < 0 ? 2147483647 : 0);
+                }
                 fptr = &state[rand_sep];
                 rptr = &state[0];
                 for (i = 0; i < 10 * rand_deg; i++)
@@ -210,6 +217,38 @@ srandom(x)
 }
 
 /*
+ * srandomdev:
+ *
+ * Many programs choose the seed value in a totally predictable manner.
+ * This often causes problems.  We seed the generator using random
+ * data from the kernel.
+ * Note that this particular seeding procedure can generate states
+ * which are impossible to reproduce by calling srandom() with any
+ * value, since the succeeding terms in the state buffer are no longer
+ * derived from the LC algorithm applied to a fixed seed.
+ */
+void
+srandomdev(void)
+{
+        int mib[2];
+        size_t len;
+
+        if (rand_type == TYPE_0)
+                len = sizeof(state[0]);
+        else
+                len = rand_deg * sizeof(state[0]);
+
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_ARND;
+        sysctl(mib, 2, state, &len, NULL, 0);
+
+        if (rand_type != TYPE_0) {
+                fptr = &state[rand_sep];
+                rptr = &state[0];
+        }
+}
+
+/*
  * initstate:
  *
  * Initialize the state information in the given array of n bytes for future
@@ -229,22 +268,16 @@ srandom(x)
  * Returns a pointer to the old state.
  */
 char *
-initstate(seed, arg_state, n)
-        u_int seed;                     /* seed for R.N.G. */
-        char *arg_state;                /* pointer to state array */
-        int n;                          /* # bytes of state info */
+initstate(u_int seed, char *arg_state, size_t n)
 {
-        register char *ostate = (char *)(&state[-1]);
+        char *ostate = (char *)(&state[-1]);
 
         if (rand_type == TYPE_0)
                 state[-1] = rand_type;
         else
                 state[-1] = MAX_TYPES * (rptr - state) + rand_type;
-        if (n < BREAK_0) {
-                (void)fprintf(stderr,
-                    "random: not enough state (%d bytes); ignored.\n", n);
-                return(0);
-        }
+        if (n < BREAK_0)
+                return(NULL);
         if (n < BREAK_1) {
                 rand_type = TYPE_0;
                 rand_deg = DEG_0;
@@ -266,7 +299,7 @@ initstate(seed, arg_state, n)
                 rand_deg = DEG_4;
                 rand_sep = SEP_4;
         }
-        state = &(((long *)arg_state)[1]);      /* first location */
+        state = &(((int32_t *)arg_state)[1]);   /* first location */
         end_ptr = &state[rand_deg];     /* must set end_ptr before srandom */
         srandom(seed);
         if (rand_type == TYPE_0)
@@ -292,12 +325,11 @@ initstate(seed, arg_state, n)
  * Returns a pointer to the old state information.
  */
 char *
-setstate(arg_state)
-        char *arg_state;
+setstate(const char *arg_state)
 {
-        register long *new_state = (long *)arg_state;
-        register int type = new_state[0] % MAX_TYPES;
-        register int rear = new_state[0] / MAX_TYPES;
+        int32_t *new_state = (int32_t *)arg_state;
+        int32_t type = new_state[0] % MAX_TYPES;
+        int32_t rear = new_state[0] / MAX_TYPES;
         char *ostate = (char *)(&state[-1]);
 
         if (rand_type == TYPE_0)
@@ -315,8 +347,7 @@ setstate(arg_state)
                 rand_sep = seps[type];
                 break;
         default:
-                (void)fprintf(stderr,
-                    "random: state info corrupted; not changed.\n");
+                return(NULL);
         }
         state = &new_state[1];
         if (rand_type != TYPE_0) {
@@ -345,9 +376,9 @@ setstate(arg_state)
  * Returns a 31-bit random number.
  */
 long
-random()
+random(void)
 {
-        long i;
+        int32_t i;
 
         if (rand_type == TYPE_0)
                 i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
@@ -360,5 +391,5 @@ random()
                 } else if (++rptr >= end_ptr)
                         rptr = state;
         }
-        return(i);
+        return((long)i);
 }