diff --git a/Server/Random.cs b/Server/Random.cs
index 89d1f2c66..57b9070aa 100644
--- a/Server/Random.cs
+++ b/Server/Random.cs
@@ -1,466 +1,466 @@
-/***************************************************************************
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- ***************************************************************************/
-
-using System;
-using System.IO;
-using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using System.Threading;
-
-namespace Server {
- ///
- /// Handles random number generation.
- ///
- public static class RandomImpl {
- private static readonly IRandomImpl _Random;
-
- static RandomImpl() {
- if ( Core.Unix ) {
- _Random = new CSPRandom();
- } else if (Core.Is64Bit && File.Exists("rdrand64.dll")) {
- _Random = new RDRand64();
- } else if ( !Core.Is64Bit && File.Exists("rdrand32.dll") ) {
- _Random = new RDRand32();
- } else {
- _Random = new CSPRandom();
- }
-
- if (_Random is IHardwareRNG) {
- if (!((IHardwareRNG)_Random).IsSupported()) {
- _Random = new CSPRandom();
- }
- }
- }
-
- public static bool IsHardwareRNG {
- get { return _Random is IHardwareRNG; }
- }
-
- public static Type Type {
- get { return _Random.GetType(); }
- }
-
- public static int Next(int c) {
- return _Random.Next(c);
- }
-
- public static bool NextBool() {
- return _Random.NextBool();
- }
-
- public static void NextBytes(byte[] b) {
- _Random.NextBytes(b);
- }
-
- public static double NextDouble() {
- return _Random.NextDouble();
- }
- }
-
- public interface IRandomImpl {
- int Next(int c);
- bool NextBool();
- void NextBytes(byte[] b);
- double NextDouble();
- }
-
- public interface IHardwareRNG {
- bool IsSupported();
- }
-
- public sealed class SimpleRandom : IRandomImpl {
- private Random m_Random = new Random();
-
- public SimpleRandom() {
- }
-
- public int Next(int c) {
- int r;
- lock (m_Random)
- r = m_Random.Next(c);
- return r;
- }
-
- public bool NextBool() {
- return NextDouble() >= .5;
- }
-
- public void NextBytes(byte[] b) {
- lock (m_Random)
- m_Random.NextBytes(b);
- }
-
- public double NextDouble() {
- double r;
- lock (m_Random)
- r = m_Random.NextDouble();
- return r;
- }
- }
-
- public sealed class CSPRandom : IRandomImpl {
- private RNGCryptoServiceProvider _CSP = new RNGCryptoServiceProvider();
-
- private static int BUFFER_SIZE = 0x4000;
- private static int LARGE_REQUEST = 0x40;
-
- private byte[] _Working = new byte[BUFFER_SIZE];
- private byte[] _Buffer = new byte[BUFFER_SIZE];
-
- private int _Index = 0;
-
+/***************************************************************************
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ ***************************************************************************/
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Threading;
+
+namespace Server {
+ ///
+ /// Handles random number generation.
+ ///
+ public static class RandomImpl {
+ private static readonly IRandomImpl _Random;
+
+ static RandomImpl() {
+ if ( Core.Unix ) {
+ _Random = new CSPRandom();
+ } else if (Core.Is64Bit && File.Exists("rdrand64.dll")) {
+ _Random = new RDRand64();
+ } else if ( !Core.Is64Bit && File.Exists("rdrand32.dll") ) {
+ _Random = new RDRand32();
+ } else {
+ _Random = new CSPRandom();
+ }
+
+ if (_Random is IHardwareRNG) {
+ if (!((IHardwareRNG)_Random).IsSupported()) {
+ _Random = new CSPRandom();
+ }
+ }
+ }
+
+ public static bool IsHardwareRNG {
+ get { return _Random is IHardwareRNG; }
+ }
+
+ public static Type Type {
+ get { return _Random.GetType(); }
+ }
+
+ public static int Next(int c) {
+ return _Random.Next(c);
+ }
+
+ public static bool NextBool() {
+ return _Random.NextBool();
+ }
+
+ public static void NextBytes(byte[] b) {
+ _Random.NextBytes(b);
+ }
+
+ public static double NextDouble() {
+ return _Random.NextDouble();
+ }
+ }
+
+ public interface IRandomImpl {
+ int Next(int c);
+ bool NextBool();
+ void NextBytes(byte[] b);
+ double NextDouble();
+ }
+
+ public interface IHardwareRNG {
+ bool IsSupported();
+ }
+
+ public sealed class SimpleRandom : IRandomImpl {
+ private Random m_Random = new Random();
+
+ public SimpleRandom() {
+ }
+
+ public int Next(int c) {
+ int r;
+ lock (m_Random)
+ r = m_Random.Next(c);
+ return r;
+ }
+
+ public bool NextBool() {
+ return NextDouble() >= .5;
+ }
+
+ public void NextBytes(byte[] b) {
+ lock (m_Random)
+ m_Random.NextBytes(b);
+ }
+
+ public double NextDouble() {
+ double r;
+ lock (m_Random)
+ r = m_Random.NextDouble();
+ return r;
+ }
+ }
+
+ public sealed class CSPRandom : IRandomImpl {
+ private RNGCryptoServiceProvider _CSP = new RNGCryptoServiceProvider();
+
+ private static int BUFFER_SIZE = 0x4000;
+ private static int LARGE_REQUEST = 0x40;
+
+ private byte[] _Working = new byte[BUFFER_SIZE];
+ private byte[] _Buffer = new byte[BUFFER_SIZE];
+
+ private int _Index = 0;
+
private object _sync = new object();
- private ManualResetEvent _filled = new ManualResetEvent(false);
-
- public CSPRandom() {
- _CSP.GetBytes(_Working);
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- private void CheckSwap(int c) {
- if (_Index + c < BUFFER_SIZE)
+ private ManualResetEvent _filled = new ManualResetEvent(false);
+
+ public CSPRandom() {
+ _CSP.GetBytes(_Working);
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ private void CheckSwap(int c) {
+ if (_Index + c < BUFFER_SIZE)
return;
- _filled.WaitOne();
-
- byte[] b = _Working;
- _Working = _Buffer;
- _Buffer = b;
+ _filled.WaitOne();
+
+ byte[] b = _Working;
+ _Working = _Buffer;
+ _Buffer = b;
_Index = 0;
- _filled.Reset();
-
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- private void Fill(object o) {
- lock (_CSP)
+ _filled.Reset();
+
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ private void Fill(object o) {
+ lock (_CSP)
_CSP.GetBytes(_Buffer);
- _filled.Set();
- }
-
- private void _GetBytes(byte[] b) {
- int c = b.Length;
-
- lock (_sync) {
- CheckSwap(c);
- Buffer.BlockCopy(_Working, _Index, b, 0, c);
- _Index += c;
- }
- }
-
- private void _GetBytes(byte[] b, int offset, int count) {
- lock (_sync) {
- CheckSwap(count);
- Buffer.BlockCopy(_Working, _Index, b, offset, count);
- _Index += count;
- }
- }
-
- public int Next(int c) {
- return (int)(c * NextDouble());
- }
-
- public bool NextBool() {
- return (NextByte() & 1) == 1;
- }
-
- private byte NextByte() {
- lock (_sync) {
- CheckSwap(1);
- return _Working[_Index++];
- }
- }
-
- public void NextBytes(byte[] b) {
- int c = b.Length;
-
- if (c >= LARGE_REQUEST) {
- lock (_CSP)
- _CSP.GetBytes(b);
- return;
- }
- _GetBytes(b);
- }
-
- public unsafe double NextDouble() {
- byte[] b = new byte[8];
-
- if (BitConverter.IsLittleEndian) {
- b[7] = 0;
- _GetBytes(b, 0, 7);
- } else {
- b[0] = 0;
- _GetBytes(b, 1, 7);
- }
-
- ulong r = 0;
- fixed(byte* buf = b)
- r = *(ulong*)(&buf[0]) >> 3;
-
- /* double: 53 bits of significand precision
- * ulong.MaxValue >> 11 = 9007199254740991
- * 2^53 = 9007199254740992
- */
-
- return (double)r / 9007199254740992;
- }
- }
-
- public sealed class RDRand32 : IRandomImpl, IHardwareRNG {
- internal class SafeNativeMethods {
- [DllImport("rdrand32")]
- internal static extern RDRandError rdrand_32(ref uint rand, bool retry);
-
- [DllImport("rdrand32")]
- internal static extern RDRandError rdrand_get_bytes(int n, byte[] buffer);
- }
-
- private static int BUFFER_SIZE = 0x10000;
- private static int LARGE_REQUEST = 0x40;
-
- private byte[] _Working = new byte[BUFFER_SIZE];
- private byte[] _Buffer = new byte[BUFFER_SIZE];
-
- private int _Index = 0;
-
+ _filled.Set();
+ }
+
+ private void _GetBytes(byte[] b) {
+ int c = b.Length;
+
+ lock (_sync) {
+ CheckSwap(c);
+ Buffer.BlockCopy(_Working, _Index, b, 0, c);
+ _Index += c;
+ }
+ }
+
+ private void _GetBytes(byte[] b, int offset, int count) {
+ lock (_sync) {
+ CheckSwap(count);
+ Buffer.BlockCopy(_Working, _Index, b, offset, count);
+ _Index += count;
+ }
+ }
+
+ public int Next(int c) {
+ return (int)(c * NextDouble());
+ }
+
+ public bool NextBool() {
+ return (NextByte() & 1) == 1;
+ }
+
+ private byte NextByte() {
+ lock (_sync) {
+ CheckSwap(1);
+ return _Working[_Index++];
+ }
+ }
+
+ public void NextBytes(byte[] b) {
+ int c = b.Length;
+
+ if (c >= LARGE_REQUEST) {
+ lock (_CSP)
+ _CSP.GetBytes(b);
+ return;
+ }
+ _GetBytes(b);
+ }
+
+ public unsafe double NextDouble() {
+ byte[] b = new byte[8];
+
+ if (BitConverter.IsLittleEndian) {
+ b[7] = 0;
+ _GetBytes(b, 0, 7);
+ } else {
+ b[0] = 0;
+ _GetBytes(b, 1, 7);
+ }
+
+ ulong r = 0;
+ fixed(byte* buf = b)
+ r = *(ulong*)(&buf[0]) >> 3;
+
+ /* double: 53 bits of significand precision
+ * ulong.MaxValue >> 11 = 9007199254740991
+ * 2^53 = 9007199254740992
+ */
+
+ return (double)r / 9007199254740992;
+ }
+ }
+
+ public sealed class RDRand32 : IRandomImpl, IHardwareRNG {
+ internal class SafeNativeMethods {
+ [DllImport("rdrand32")]
+ internal static extern RDRandError rdrand_32(ref uint rand, bool retry);
+
+ [DllImport("rdrand32")]
+ internal static extern RDRandError rdrand_get_bytes(int n, byte[] buffer);
+ }
+
+ private static int BUFFER_SIZE = 0x10000;
+ private static int LARGE_REQUEST = 0x40;
+
+ private byte[] _Working = new byte[BUFFER_SIZE];
+ private byte[] _Buffer = new byte[BUFFER_SIZE];
+
+ private int _Index = 0;
+
private object _sync = new object();
- private ManualResetEvent _filled = new ManualResetEvent(false);
-
- public RDRand32() {
- SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Working);
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- public bool IsSupported() {
- uint r = 0;
- return SafeNativeMethods.rdrand_32(ref r, true) == RDRandError.Success;
- }
-
- private void CheckSwap(int c) {
- if (_Index + c < BUFFER_SIZE)
- return;
-
- _filled.WaitOne();
-
- byte[] b = _Working;
- _Working = _Buffer;
- _Buffer = b;
+ private ManualResetEvent _filled = new ManualResetEvent(false);
+
+ public RDRand32() {
+ SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Working);
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ public bool IsSupported() {
+ uint r = 0;
+ return SafeNativeMethods.rdrand_32(ref r, true) == RDRandError.Success;
+ }
+
+ private void CheckSwap(int c) {
+ if (_Index + c < BUFFER_SIZE)
+ return;
+
+ _filled.WaitOne();
+
+ byte[] b = _Working;
+ _Working = _Buffer;
+ _Buffer = b;
_Index = 0;
- _filled.Reset();
-
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- private void Fill(object o) {
+ _filled.Reset();
+
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ private void Fill(object o) {
SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Buffer);
- _filled.Set();
- }
-
- private void _GetBytes(byte[] b) {
- int c = b.Length;
-
- lock (_sync) {
- CheckSwap(c);
- Buffer.BlockCopy(_Working, _Index, b, 0, c);
- _Index += c;
- }
- }
-
- private void _GetBytes(byte[] b, int offset, int count) {
- lock (_sync) {
- CheckSwap(count);
- Buffer.BlockCopy(_Working, _Index, b, offset, count);
- _Index += count;
- }
- }
-
- public int Next(int c) {
- return (int)(c * NextDouble());
- }
-
- public bool NextBool() {
- return (NextByte() & 1) == 1;
- }
-
- private byte NextByte() {
- lock (_sync) {
- CheckSwap(1);
- return _Working[_Index++];
- }
- }
-
- public void NextBytes(byte[] b) {
- int c = b.Length;
-
- if (c >= LARGE_REQUEST) {
- SafeNativeMethods.rdrand_get_bytes(c, b);
- return;
- }
- _GetBytes(b);
- }
-
- public unsafe double NextDouble() {
- byte[] b = new byte[8];
-
- if (BitConverter.IsLittleEndian) {
- b[7] = 0;
- _GetBytes(b, 0, 7);
- } else {
- b[0] = 0;
- _GetBytes(b, 1, 7);
- }
-
- ulong r = 0;
- fixed(byte* buf = b)
- r = *(ulong*)(&buf[0]) >> 3;
-
- /* double: 53 bits of significand precision
- * ulong.MaxValue >> 11 = 9007199254740991
- * 2^53 = 9007199254740992
- */
-
- return (double)r / 9007199254740992;
- }
- }
-
- public sealed class RDRand64 : IRandomImpl, IHardwareRNG {
- internal class SafeNativeMethods {
- [DllImport("rdrand64")]
- internal static extern RDRandError rdrand_64(ref ulong rand, bool retry);
-
- [DllImport("rdrand64")]
- internal static extern RDRandError rdrand_get_bytes(int n, byte[] buffer);
- }
-
- private static int BUFFER_SIZE = 0x10000;
- private static int LARGE_REQUEST = 0x40;
-
- private byte[] _Working = new byte[BUFFER_SIZE];
- private byte[] _Buffer = new byte[BUFFER_SIZE];
-
- private int _Index = 0;
-
+ _filled.Set();
+ }
+
+ private void _GetBytes(byte[] b) {
+ int c = b.Length;
+
+ lock (_sync) {
+ CheckSwap(c);
+ Buffer.BlockCopy(_Working, _Index, b, 0, c);
+ _Index += c;
+ }
+ }
+
+ private void _GetBytes(byte[] b, int offset, int count) {
+ lock (_sync) {
+ CheckSwap(count);
+ Buffer.BlockCopy(_Working, _Index, b, offset, count);
+ _Index += count;
+ }
+ }
+
+ public int Next(int c) {
+ return (int)(c * NextDouble());
+ }
+
+ public bool NextBool() {
+ return (NextByte() & 1) == 1;
+ }
+
+ private byte NextByte() {
+ lock (_sync) {
+ CheckSwap(1);
+ return _Working[_Index++];
+ }
+ }
+
+ public void NextBytes(byte[] b) {
+ int c = b.Length;
+
+ if (c >= LARGE_REQUEST) {
+ SafeNativeMethods.rdrand_get_bytes(c, b);
+ return;
+ }
+ _GetBytes(b);
+ }
+
+ public unsafe double NextDouble() {
+ byte[] b = new byte[8];
+
+ if (BitConverter.IsLittleEndian) {
+ b[7] = 0;
+ _GetBytes(b, 0, 7);
+ } else {
+ b[0] = 0;
+ _GetBytes(b, 1, 7);
+ }
+
+ ulong r = 0;
+ fixed(byte* buf = b)
+ r = *(ulong*)(&buf[0]) >> 3;
+
+ /* double: 53 bits of significand precision
+ * ulong.MaxValue >> 11 = 9007199254740991
+ * 2^53 = 9007199254740992
+ */
+
+ return (double)r / 9007199254740992;
+ }
+ }
+
+ public sealed class RDRand64 : IRandomImpl, IHardwareRNG {
+ internal class SafeNativeMethods {
+ [DllImport("rdrand64")]
+ internal static extern RDRandError rdrand_64(ref ulong rand, bool retry);
+
+ [DllImport("rdrand64")]
+ internal static extern RDRandError rdrand_get_bytes(int n, byte[] buffer);
+ }
+
+ private static int BUFFER_SIZE = 0x10000;
+ private static int LARGE_REQUEST = 0x40;
+
+ private byte[] _Working = new byte[BUFFER_SIZE];
+ private byte[] _Buffer = new byte[BUFFER_SIZE];
+
+ private int _Index = 0;
+
private object _sync = new object();
- private ManualResetEvent _filled = new ManualResetEvent(false);
-
- public RDRand64() {
- SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Working);
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- public bool IsSupported() {
- ulong r = 0;
- return SafeNativeMethods.rdrand_64(ref r, true) == RDRandError.Success;
- }
-
- private void CheckSwap(int c) {
- if (_Index + c < BUFFER_SIZE)
- return;
-
- _filled.WaitOne();
-
- byte[] b = _Working;
- _Working = _Buffer;
- _Buffer = b;
+ private ManualResetEvent _filled = new ManualResetEvent(false);
+
+ public RDRand64() {
+ SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Working);
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ public bool IsSupported() {
+ ulong r = 0;
+ return SafeNativeMethods.rdrand_64(ref r, true) == RDRandError.Success;
+ }
+
+ private void CheckSwap(int c) {
+ if (_Index + c < BUFFER_SIZE)
+ return;
+
+ _filled.WaitOne();
+
+ byte[] b = _Working;
+ _Working = _Buffer;
+ _Buffer = b;
_Index = 0;
- _filled.Reset();
-
- ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
- }
-
- private void Fill(object o) {
+ _filled.Reset();
+
+ ThreadPool.QueueUserWorkItem(new WaitCallback(Fill));
+ }
+
+ private void Fill(object o) {
SafeNativeMethods.rdrand_get_bytes(BUFFER_SIZE, _Buffer);
- _filled.Set();
- }
-
- private void _GetBytes(byte[] b) {
- int c = b.Length;
-
- lock (_sync) {
- CheckSwap(c);
- Buffer.BlockCopy(_Working, _Index, b, 0, c);
- _Index += c;
- }
- }
-
- private void _GetBytes(byte[] b, int offset, int count) {
- lock (_sync) {
- CheckSwap(count);
- Buffer.BlockCopy(_Working, _Index, b, offset, count);
- _Index += count;
- }
- }
-
- public int Next(int c) {
- return (int)(c * NextDouble());
- }
-
- public bool NextBool() {
- return (NextByte() & 1) == 1;
- }
-
- private byte NextByte() {
- lock (_sync) {
- CheckSwap(1);
- return _Working[_Index++];
- }
- }
-
- public void NextBytes(byte[] b) {
- int c = b.Length;
-
- if (c >= LARGE_REQUEST) {
- SafeNativeMethods.rdrand_get_bytes(c, b);
- return;
- }
- _GetBytes(b);
- }
-
- public unsafe double NextDouble() {
- byte[] b = new byte[8];
-
- if (BitConverter.IsLittleEndian) {
- b[7] = 0;
- _GetBytes(b, 0, 7);
- } else {
- b[0] = 0;
- _GetBytes(b, 1, 7);
- }
-
- ulong r = 0;
- fixed(byte* buf = b)
- r = *(ulong*)(&buf[0]) >> 3;
-
- /* double: 53 bits of significand precision
- * ulong.MaxValue >> 11 = 9007199254740991
- * 2^53 = 9007199254740992
- */
-
- return (double)r / 9007199254740992;
- }
- }
-
- public enum RDRandError : int {
- Unknown = -4,
- Unsupported = -3,
- Supported = -2,
- NotReady = -1,
-
- Failure = 0,
-
- Success = 1,
- }
+ _filled.Set();
+ }
+
+ private void _GetBytes(byte[] b) {
+ int c = b.Length;
+
+ lock (_sync) {
+ CheckSwap(c);
+ Buffer.BlockCopy(_Working, _Index, b, 0, c);
+ _Index += c;
+ }
+ }
+
+ private void _GetBytes(byte[] b, int offset, int count) {
+ lock (_sync) {
+ CheckSwap(count);
+ Buffer.BlockCopy(_Working, _Index, b, offset, count);
+ _Index += count;
+ }
+ }
+
+ public int Next(int c) {
+ return (int)(c * NextDouble());
+ }
+
+ public bool NextBool() {
+ return (NextByte() & 1) == 1;
+ }
+
+ private byte NextByte() {
+ lock (_sync) {
+ CheckSwap(1);
+ return _Working[_Index++];
+ }
+ }
+
+ public void NextBytes(byte[] b) {
+ int c = b.Length;
+
+ if (c >= LARGE_REQUEST) {
+ SafeNativeMethods.rdrand_get_bytes(c, b);
+ return;
+ }
+ _GetBytes(b);
+ }
+
+ public unsafe double NextDouble() {
+ byte[] b = new byte[8];
+
+ if (BitConverter.IsLittleEndian) {
+ b[7] = 0;
+ _GetBytes(b, 0, 7);
+ } else {
+ b[0] = 0;
+ _GetBytes(b, 1, 7);
+ }
+
+ ulong r = 0;
+ fixed(byte* buf = b)
+ r = *(ulong*)(&buf[0]) >> 3;
+
+ /* double: 53 bits of significand precision
+ * ulong.MaxValue >> 11 = 9007199254740991
+ * 2^53 = 9007199254740992
+ */
+
+ return (double)r / 9007199254740992;
+ }
+ }
+
+ public enum RDRandError : int {
+ Unknown = -4,
+ Unsupported = -3,
+ Supported = -2,
+ NotReady = -1,
+
+ Failure = 0,
+
+ Success = 1,
+ }
}
\ No newline at end of file