First iteration improved multiplatform support

Lidgren.Network/Platform/PlatformAndroid.cs

@@ -0,0 +1,87 @@
+#if __ANDROID__
+using System;
+using System.Collections.Generic;
+using System.Net;
+
+namespace Lidgren.Network
+{
+	public static partial class NetUtility
+	{
+		private static byte[] s_randomMacBytes;
+		
+		static NetUtility()
+		{
+			s_randomMacBytes = new byte[8];
+			MWCRandom.Instance.NextBytes(s_randomMacBytes);
+		}
+
+		[CLSCompliant(false)]
+		public static ulong GetPlatformSeed(int seedInc)
+		{
+			ulong seed = (ulong)Environment.TickCount + (ulong)seedInc;
+			return seed ^ ((ulong)(new object().GetHashCode()) << 32);
+		}
+		
+		/// <summary>
+		/// Gets my local IPv4 address (not necessarily external) and subnet mask
+		/// </summary>
+		public static IPAddress GetMyAddress(out IPAddress mask)
+		{
+			mask = null;
+			try
+			{
+				Android.Net.Wifi.WifiManager wifi = (Android.Net.Wifi.WifiManager)Android.App.Application.Context.GetSystemService(Android.App.Activity.WifiService);
+				if (!wifi.IsWifiEnabled)
+					return null;
+
+				var dhcp = wifi.DhcpInfo;
+				int addr = dhcp.IpAddress;
+				byte[] quads = new byte[4];
+				for (int k = 0; k < 4; k++)
+					quads[k] = (byte)((addr >> k * 8) & 0xFF);
+				return new IPAddress(quads);
+			}
+			catch // Catch Access Denied errors
+			{
+				return null;
+			}
+		}
+
+		public static byte[] GetMacAddressBytes()
+		{
+			return s_randomMacBytes;
+		}
+
+		public static void Sleep(int milliseconds)
+		{
+			System.Threading.Thread.Sleep(milliseconds);
+		}
+
+		public static IPAddress GetBroadcastAddress()
+		{
+			return IPAddress.Broadcast;
+		}
+
+		public static IPAddress CreateAddressFromBytes(byte[] bytes)
+		{
+			return new IPAddress(bytes);
+		}
+
+		private static readonly SHA1 s_sha = SHA1.Create();
+		public static byte[] ComputeSHAHash(byte[] bytes, int offset, int count)
+		{
+			return s_sha.ComputeHash(bytes, offset, count);
+		}
+	}
+
+	public static partial class NetTime
+	{
+		private static readonly long s_timeInitialized = Environment.TickCount;
+		
+		/// <summary>
+		/// Get number of seconds since the application started
+		/// </summary>
+		public static double Now { get { return (double)((uint)Environment.TickCount - s_timeInitialized) / 1000.0; } }
+	}
+}
+#endif

Lidgren.Network/Platform/PlatformConstrained.cs

@@ -0,0 +1,72 @@
+#if __CONSTRAINED__
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Security.Cryptography;
+
+namespace Lidgren.Network
+{
+	public static partial class NetUtility
+	{
+		private static byte[] s_randomMacBytes;
+		
+		static NetUtility()
+		{
+			s_randomMacBytes = new byte[8];
+			MWCRandom.Instance.NextBytes(s_randomMacBytes);
+		}
+
+		[CLSCompliant(false)]
+		public static ulong GetPlatformSeed(int seedInc)
+		{
+			ulong seed = (ulong)Environment.TickCount + (ulong)seedInc;
+			return seed ^ ((ulong)(new object().GetHashCode()) << 32);
+		}
+		
+		/// <summary>
+		/// Gets my local IPv4 address (not necessarily external) and subnet mask
+		/// </summary>
+		public static IPAddress GetMyAddress(out IPAddress mask)
+		{
+			mask = null;
+			return null;
+		}
+
+		public static byte[] GetMacAddressBytes()
+		{
+			return s_randomMacBytes;
+		}
+
+		public static IPAddress GetBroadcastAddress()
+		{
+			return IPAddress.Broadcast;
+		}
+
+		public static void Sleep(int milliseconds)
+		{
+			System.Threading.Thread.Sleep(milliseconds);
+		}
+
+		public static IPAddress CreateAddressFromBytes(byte[] bytes)
+		{
+			return new IPAddress(bytes);
+		}
+
+		private static readonly SHA1 s_sha = SHA1.Create();
+		public static byte[] ComputeSHAHash(byte[] bytes, int offset, int count)
+		{
+			return s_sha.ComputeHash(bytes, offset, count);
+		}
+	}
+
+	public static partial class NetTime
+	{
+		private static readonly long s_timeInitialized = Environment.TickCount;
+		
+		/// <summary>
+		/// Get number of seconds since the application started
+		/// </summary>
+		public static double Now { get { return (double)((uint)Environment.TickCount - s_timeInitialized) / 1000.0; } }
+	}
+}
+#endif

Lidgren.Network/Platform/PlatformWin32.cs

@@ -0,0 +1,156 @@
+#if !__ANDROID__ && !__CONSTRAINED__ && !WINDOWS_RUNTIME
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Security.Cryptography;
+
+namespace Lidgren.Network
+{
+	public static partial class NetUtility
+	{
+		private static readonly long s_timeInitialized = Stopwatch.GetTimestamp();
+		private static readonly double s_dInvFreq = 1.0 / (double)Stopwatch.Frequency;
+		
+		[CLSCompliant(false)]
+		public static ulong GetPlatformSeed(int seedInc)
+		{
+			ulong seed = (ulong)System.Diagnostics.Stopwatch.GetTimestamp();
+			return seed ^ ((ulong)Environment.WorkingSet + (ulong)seedInc);
+		}
+
+		public static double Now { get { return (double)(Stopwatch.GetTimestamp() - s_timeInitialized) * s_dInvFreq; } }
+
+		private static NetworkInterface GetNetworkInterface()
+		{
+			var computerProperties = IPGlobalProperties.GetIPGlobalProperties();
+			if (computerProperties == null)
+				return null;
+
+			var nics = NetworkInterface.GetAllNetworkInterfaces();
+			if (nics == null || nics.Length < 1)
+				return null;
+
+			NetworkInterface best = null;
+			foreach (NetworkInterface adapter in nics)
+			{
+				if (adapter.NetworkInterfaceType == NetworkInterfaceType.Loopback || adapter.NetworkInterfaceType == NetworkInterfaceType.Unknown)
+					continue;
+				if (!adapter.Supports(NetworkInterfaceComponent.IPv4))
+					continue;
+				if (best == null)
+					best = adapter;
+				if (adapter.OperationalStatus != OperationalStatus.Up)
+					continue;
+
+				// make sure this adapter has any ipv4 addresses
+				IPInterfaceProperties properties = adapter.GetIPProperties();
+				foreach (UnicastIPAddressInformation unicastAddress in properties.UnicastAddresses)
+				{
+					if (unicastAddress != null && unicastAddress.Address != null && unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork)
+					{
+						// Yes it does, return this network interface.
+						return adapter;
+					}
+				}
+			}
+			return best;
+		}
+
+		/// <summary>
+		/// If available, returns the bytes of the physical (MAC) address for the first usable network interface
+		/// </summary>
+		public static byte[] GetMacAddressBytes()
+		{
+			var ni = GetNetworkInterface();
+			if (ni == null)
+				return null;
+			return ni.GetPhysicalAddress().GetAddressBytes();
+		}
+
+		public static IPAddress GetBroadcastAddress()
+		{
+			var ni = GetNetworkInterface();
+			if (ni == null)
+				return null;
+
+			var properties = ni.GetIPProperties();
+			foreach (UnicastIPAddressInformation unicastAddress in properties.UnicastAddresses)
+			{
+				if (unicastAddress != null && unicastAddress.Address != null && unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork)
+				{
+					var mask = unicastAddress.IPv4Mask;
+					byte[] ipAdressBytes = unicastAddress.Address.GetAddressBytes();
+					byte[] subnetMaskBytes = mask.GetAddressBytes();
+
+					if (ipAdressBytes.Length != subnetMaskBytes.Length)
+						throw new ArgumentException("Lengths of IP address and subnet mask do not match.");
+
+					byte[] broadcastAddress = new byte[ipAdressBytes.Length];
+					for (int i = 0; i < broadcastAddress.Length; i++)
+					{
+						broadcastAddress[i] = (byte)(ipAdressBytes[i] | (subnetMaskBytes[i] ^ 255));
+					}
+					return new IPAddress(broadcastAddress);
+				}
+			}
+			return IPAddress.Broadcast;
+		}
+
+		/// <summary>
+		/// Gets my local IPv4 address (not necessarily external) and subnet mask
+		/// </summary>
+		public static IPAddress GetMyAddress(out IPAddress mask)
+		{
+			var ni = GetNetworkInterface();
+			if (ni == null)
+			{
+				mask = null;
+				return null;
+			}
+
+			IPInterfaceProperties properties = ni.GetIPProperties();
+			foreach (UnicastIPAddressInformation unicastAddress in properties.UnicastAddresses)
+			{
+				if (unicastAddress != null && unicastAddress.Address != null && unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork)
+				{
+					mask = unicastAddress.IPv4Mask;
+					return unicastAddress.Address;
+				}
+			}
+
+			mask = null;
+			return null;
+		}
+
+		public static void Sleep(int milliseconds)
+		{
+			System.Threading.Thread.Sleep(milliseconds);
+		}
+
+		public static IPAddress CreateAddressFromBytes(byte[] bytes)
+		{
+			return new IPAddress(bytes);
+		}
+		
+		private static readonly SHA256 s_sha = SHA256.Create();
+		public static byte[] ComputeSHAHash(byte[] bytes, int offset, int count)
+		{
+			return s_sha.ComputeHash(bytes, offset, count);
+		}
+	}
+
+	public static partial class NetTime
+	{
+		private static readonly long s_timeInitialized = Stopwatch.GetTimestamp();
+		private static readonly double s_dInvFreq = 1.0 / (double)Stopwatch.Frequency;
+		
+		/// <summary>
+		/// Get number of seconds since the application started
+		/// </summary>
+		public static double Now { get { return (double)(Stopwatch.GetTimestamp() - s_timeInitialized) * s_dInvFreq; } }
+	}
+}
+#endif

Lidgren.Network/Platform/PlatformWinRT.cs

@@ -0,0 +1,102 @@
+#if WINDOWS_RUNTIME
+//
+//
+//
+//    Completely broken right now
+//
+//
+//
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+
+namespace Lidgren.Network
+{
+	public class NetAddress
+	{
+		public static readonly HostName Any = null;
+	}
+
+	public class NetEndPoint
+	{
+		public NetEndPoint(HostName hostname, int port) { HostName = hostname; Port = port; }
+		public NetEndPoint(HostName hostname, string port) { HostName = hostname; Port = int.Parse(port); }
+		public NetEndPoint(string hostname, int port) { HostName = (hostname == null) ? null : new HostName(hostname); Port = port; }
+		public HostName HostName;
+		public int Port;
+		public override string ToString() { return string.Format("{0}:{1}", HostName, Port); }
+		public override int GetHashCode()
+		{
+			return HostName.RawName.GetHashCode() + Port;
+		}
+		public override bool Equals(object obj)
+		{
+			var ep = obj as NetEndPoint;
+			if (ep == null) return false;
+			if (Port != ep.Port) return false;
+			return HostName.RawName.Equals(ep.HostName.RawName);
+		}
+	};
+
+	public static partial class NetUtility
+	{
+		[CLSCompliant(false)]
+		public static ulong GetPlatformSeed(int seedInc)
+		{
+			ulong seed = (ulong)Environment.TickCount + (ulong)seedInc;
+			return seed ^ ((ulong)(new object().GetHashCode()) << 32);
+		}
+
+		/// <summary>
+		/// Returns the physical (MAC) address for the first usable network interface
+		/// </summary>
+		public static PhysicalAddress GetMacAddress()
+		{
+			throw new NotImplementedException();
+		}
+
+		public static IPAddress GetBroadcastAddress()
+		{
+			throw new NotImplementedException();
+		}
+
+		/// <summary>
+		/// Gets my local IPv4 address (not necessarily external) and subnet mask
+		/// </summary>
+		public static IPAddress GetMyAddress(out IPAddress mask)
+		{
+			throw new NotImplementedException();
+		}
+
+		public static void Sleep(int milliseconds)
+		{
+			Task.Delay(50).Wait();
+		}
+
+		public static NetAddress CreateAddressFromBytes(byte[] bytes)
+		{
+			throw new NotImplementedException();
+		}
+
+		private static readonly SHA1CryptoServiceProvider s_sha = new SHA1CryptoServiceProvider();
+		public static byte[] ComputeSHAHash(byte[] bytes, int offset, int count)
+		{
+			return s_sha.ComputeHash(bytes, offset, count);
+		}
+	}
+
+	public static partial class NetTime
+	{
+		private static readonly long s_timeInitialized = Environment.TickCount;
+
+		/// <summary>
+		/// Get number of seconds since the application started
+		/// </summary>
+		public static double Now { get { return (double)((uint)Environment.TickCount - s_timeInitialized) / 1000.0; } }
+	}
+}
+#endif