Update to 3.5.2 and .net core 2.1

Emby.Server.Implementations/Networking/IPNetwork/BigIntegerExt.cs

@@ -0,0 +1,168 @@
+using System.Collections.Generic;
+
+namespace System.Net
+{
+    using System;
+    using System.Numerics;
+    using System.Text;
+
+    /// <summary>
+    /// Extension methods to convert <see cref="System.Numerics.BigInteger"/>
+    /// instances to hexadecimal, octal, and binary strings.
+    /// </summary>
+    public static class BigIntegerExtensions
+    {
+        /// <summary>
+        /// Converts a <see cref="BigInteger"/> to a binary string.
+        /// </summary>
+        /// <param name="bigint">A <see cref="BigInteger"/>.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> containing a binary
+        /// representation of the supplied <see cref="BigInteger"/>.
+        /// </returns>
+        public static string ToBinaryString(this BigInteger bigint)
+        {
+            var bytes = bigint.ToByteArray();
+            var idx = bytes.Length - 1;
+
+            // Create a StringBuilder having appropriate capacity.
+            var base2 = new StringBuilder(bytes.Length * 8);
+
+            // Convert first byte to binary.
+            var binary = Convert.ToString(bytes[idx], 2);
+
+            // Ensure leading zero exists if value is positive.
+            if (binary[0] != '0' && bigint.Sign == 1)
+            {
+                base2.Append('0');
+            }
+
+            // Append binary string to StringBuilder.
+            base2.Append(binary);
+
+            // Convert remaining bytes adding leading zeros.
+            for (idx--; idx >= 0; idx--)
+            {
+                base2.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
+            }
+
+            return base2.ToString();
+        }
+
+        /// <summary>
+        /// Converts a <see cref="BigInteger"/> to a hexadecimal string.
+        /// </summary>
+        /// <param name="bigint">A <see cref="BigInteger"/>.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> containing a hexadecimal
+        /// representation of the supplied <see cref="BigInteger"/>.
+        /// </returns>
+        public static string ToHexadecimalString(this BigInteger bigint)
+        {
+            return bigint.ToString("X");
+        }
+
+        /// <summary>
+        /// Converts a <see cref="BigInteger"/> to a octal string.
+        /// </summary>
+        /// <param name="bigint">A <see cref="BigInteger"/>.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> containing an octal
+        /// representation of the supplied <see cref="BigInteger"/>.
+        /// </returns>
+        public static string ToOctalString(this BigInteger bigint)
+        {
+            var bytes = bigint.ToByteArray();
+            var idx = bytes.Length - 1;
+
+            // Create a StringBuilder having appropriate capacity.
+            var base8 = new StringBuilder(((bytes.Length / 3) + 1) * 8);
+
+            // Calculate how many bytes are extra when byte array is split
+            // into three-byte (24-bit) chunks.
+            var extra = bytes.Length % 3;
+
+            // If no bytes are extra, use three bytes for first chunk.
+            if (extra == 0)
+            {
+                extra = 3;
+            }
+
+            // Convert first chunk (24-bits) to integer value.
+            int int24 = 0;
+            for (; extra != 0; extra--)
+            {
+                int24 <<= 8;
+                int24 += bytes[idx--];
+            }
+
+            // Convert 24-bit integer to octal without adding leading zeros.
+            var octal = Convert.ToString(int24, 8);
+
+            // Ensure leading zero exists if value is positive.
+            if (octal[0] != '0')
+            {
+                if (bigint.Sign == 1)
+                {
+                    base8.Append('0');
+                }
+            }
+
+            // Append first converted chunk to StringBuilder.
+            base8.Append(octal);
+
+            // Convert remaining 24-bit chunks, adding leading zeros.
+            for (; idx >= 0; idx -= 3)
+            {
+                int24 = (bytes[idx] << 16) + (bytes[idx - 1] << 8) + bytes[idx - 2];
+                base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));
+            }
+
+            return base8.ToString();
+        }
+
+        /// <summary>
+        /// 
+        /// Reverse a Positive BigInteger ONLY
+        /// Bitwise ~ operator
+        /// 
+        /// Input  : FF FF FF FF
+        /// Width  : 4
+        /// Result : 00 00 00 00 
+        /// 
+        /// 
+        /// Input  : 00 00 00 00
+        /// Width  : 4
+        /// Result : FF FF FF FF 
+        /// 
+        /// Input  : FF FF FF FF
+        /// Width  : 8
+        /// Result : FF FF FF FF 00 00 00 00
+        /// 
+        /// 
+        /// Input  : 00 00 00 00
+        /// Width  : 8
+        /// Result : FF FF FF FF FF FF FF FF
+        /// 
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="width"></param>
+        /// <returns></returns>
+        public static BigInteger PositiveReverse(this BigInteger input, int width)
+        {
+
+            var result = new List<byte>();
+            var bytes = input.ToByteArray();
+            var work = new byte[width];
+            Array.Copy(bytes, 0, work, 0, bytes.Length - 1); // Length -1 : positive BigInteger
+
+            for (int i = 0; i < work.Length; i++)
+            {
+                result.Add((byte)(~work[i]));
+            }
+            result.Add(0); // positive BigInteger
+            return new BigInteger(result.ToArray());
+
+        }
+    }
+}

Emby.Server.Implementations/Networking/IPNetwork/IPAddressCollection.cs

@@ -0,0 +1,104 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace System.Net
+{
+    public class IPAddressCollection : IEnumerable<IPAddress>, IEnumerator<IPAddress>
+    {
+
+        private IPNetwork _ipnetwork;
+        private BigInteger _enumerator;
+
+        internal IPAddressCollection(IPNetwork ipnetwork)
+        {
+            this._ipnetwork = ipnetwork;
+            this._enumerator = -1;
+        }
+
+
+        #region Count, Array, Enumerator
+
+        public BigInteger Count
+        {
+            get
+            {
+                return this._ipnetwork.Total;
+            }
+        }
+
+        public IPAddress this[BigInteger i]
+        {
+            get
+            {
+                if (i >= this.Count)
+                {
+                    throw new ArgumentOutOfRangeException("i");
+                }
+                byte width = this._ipnetwork.AddressFamily == Sockets.AddressFamily.InterNetwork ? (byte)32 : (byte)128;
+                IPNetworkCollection ipn = this._ipnetwork.Subnet(width);
+                return ipn[i].Network;
+            }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator<IPAddress> IEnumerable<IPAddress>.GetEnumerator()
+        {
+            return this;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this;
+        }
+
+        #region IEnumerator<IPNetwork> Members
+
+        public IPAddress Current
+        {
+            get { return this[this._enumerator]; }
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            // nothing to dispose
+            return;
+        }
+
+        #endregion
+
+        #region IEnumerator Members
+
+        object IEnumerator.Current
+        {
+            get { return this.Current; }
+        }
+
+        public bool MoveNext()
+        {
+            this._enumerator++;
+            if (this._enumerator >= this.Count)
+            {
+                return false;
+            }
+            return true;
+
+        }
+
+        public void Reset()
+        {
+            this._enumerator = -1;
+        }
+
+        #endregion
+
+        #endregion
+    }
+}

Emby.Server.Implementations/Networking/IPNetwork/IPNetworkCollection.cs

@@ -0,0 +1,144 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Numerics;
+
+namespace System.Net
+{
+    public class IPNetworkCollection : IEnumerable<IPNetwork>, IEnumerator<IPNetwork>
+    {
+
+        private BigInteger _enumerator;
+        private byte _cidrSubnet;
+        private IPNetwork _ipnetwork;
+
+        private byte _cidr
+        {
+            get { return this._ipnetwork.Cidr; }
+        }
+        private BigInteger _broadcast
+        {
+            get { return IPNetwork.ToBigInteger(this._ipnetwork.Broadcast); }
+        }
+        private BigInteger _lastUsable
+        {
+            get { return IPNetwork.ToBigInteger(this._ipnetwork.LastUsable); }
+        }
+        private BigInteger _network
+        {
+            get { return IPNetwork.ToBigInteger(this._ipnetwork.Network); }
+        }
+#if TRAVISCI
+        public
+#else
+        internal
+#endif
+        IPNetworkCollection(IPNetwork ipnetwork, byte cidrSubnet)
+        {
+
+            int maxCidr = ipnetwork.AddressFamily == Sockets.AddressFamily.InterNetwork ? 32 : 128;
+            if (cidrSubnet > maxCidr)
+            {
+                throw new ArgumentOutOfRangeException("cidrSubnet");
+            }
+
+            if (cidrSubnet < ipnetwork.Cidr)
+            {
+                throw new ArgumentException("cidr");
+            }
+
+            this._cidrSubnet = cidrSubnet;
+            this._ipnetwork = ipnetwork;
+            this._enumerator = -1;
+        }
+
+        #region Count, Array, Enumerator
+
+        public BigInteger Count
+        {
+            get
+            {
+                BigInteger count = BigInteger.Pow(2, this._cidrSubnet - this._cidr);
+                return count;
+            }
+        }
+
+        public IPNetwork this[BigInteger i]
+        {
+            get
+            {
+                if (i >= this.Count)
+                {
+                    throw new ArgumentOutOfRangeException("i");
+                }
+
+                BigInteger last = this._ipnetwork.AddressFamily == Sockets.AddressFamily.InterNetworkV6
+                    ? this._lastUsable : this._broadcast;
+                BigInteger increment = (last - this._network) / this.Count;
+                BigInteger uintNetwork = this._network + ((increment + 1) * i);
+                IPNetwork ipn = new IPNetwork(uintNetwork, this._ipnetwork.AddressFamily, this._cidrSubnet);
+                return ipn;
+            }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator<IPNetwork> IEnumerable<IPNetwork>.GetEnumerator()
+        {
+            return this;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this;
+        }
+
+        #region IEnumerator<IPNetwork> Members
+
+        public IPNetwork Current
+        {
+            get { return this[this._enumerator]; }
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            // nothing to dispose
+            return;
+        }
+
+        #endregion
+
+        #region IEnumerator Members
+
+        object IEnumerator.Current
+        {
+            get { return this.Current; }
+        }
+
+        public bool MoveNext()
+        {
+            this._enumerator++;
+            if (this._enumerator >= this.Count)
+            {
+                return false;
+            }
+            return true;
+
+        }
+
+        public void Reset()
+        {
+            this._enumerator = -1;
+        }
+
+        #endregion
+
+        #endregion
+
+    }
+}

Emby.Server.Implementations/Networking/IPNetwork/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2015, lduchosal
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

Emby.Server.Implementations/Networking/NetworkManager.cs

@@ -11,6 +11,8 @@ using MediaBrowser.Model.Extensions;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Net;
+using MediaBrowser.Model.System;
+using System.Numerics;
 
 namespace Emby.Server.Implementations.Networking
 {
@@ -19,27 +21,32 @@ namespace Emby.Server.Implementations.Networking
         protected ILogger Logger { get; private set; }
 
         public event EventHandler NetworkChanged;
+        public Func<string[]> LocalSubnetsFn { get; set; }
 
-        public NetworkManager(ILogger logger)
+        public NetworkManager(ILogger logger, IEnvironmentInfo environment)
         {
             Logger = logger;
 
-            try
+            // In FreeBSD these events cause a crash
+            if (environment.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.BSD)
             {
-                NetworkChange.NetworkAddressChanged += NetworkChange_NetworkAddressChanged;
-            }
-            catch (Exception ex)
-            {
-                Logger.ErrorException("Error binding to NetworkAddressChanged event", ex);
-            }
+                try
+                {
+                    NetworkChange.NetworkAddressChanged += NetworkChange_NetworkAddressChanged;
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error binding to NetworkAddressChanged event", ex);
+                }
 
-            try
-            {
-                NetworkChange.NetworkAvailabilityChanged += NetworkChange_NetworkAvailabilityChanged;
-            }
-            catch (Exception ex)
-            {
-                Logger.ErrorException("Error binding to NetworkChange_NetworkAvailabilityChanged event", ex);
+                try
+                {
+                    NetworkChange.NetworkAvailabilityChanged += NetworkChange_NetworkAvailabilityChanged;
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error binding to NetworkChange_NetworkAvailabilityChanged event", ex);
+                }
             }
         }
 
@@ -60,6 +67,7 @@ namespace Emby.Server.Implementations.Networking
             lock (_localIpAddressSyncLock)
             {
                 _localIpAddresses = null;
+                _macAddresses = null;
             }
             if (NetworkChanged != null)
             {
@@ -67,16 +75,16 @@ namespace Emby.Server.Implementations.Networking
             }
         }
 
-        private List<IpAddressInfo> _localIpAddresses;
+        private IpAddressInfo[] _localIpAddresses;
         private readonly object _localIpAddressSyncLock = new object();
 
-        public List<IpAddressInfo> GetLocalIpAddresses()
+        public IpAddressInfo[] GetLocalIpAddresses()
         {
             lock (_localIpAddressSyncLock)
             {
                 if (_localIpAddresses == null)
                 {
-                    var addresses = GetLocalIpAddressesInternal().Result.Select(ToIpAddressInfo).ToList();
+                    var addresses = GetLocalIpAddressesInternal().Result.Select(ToIpAddressInfo).ToArray();
 
                     _localIpAddresses = addresses;
 
@@ -119,6 +127,11 @@ namespace Emby.Server.Implementations.Networking
         }
 
         public bool IsInPrivateAddressSpace(string endpoint)
+        {
+            return IsInPrivateAddressSpace(endpoint, true);
+        }
+
+        private bool IsInPrivateAddressSpace(string endpoint, bool checkSubnets)
         {
             if (string.Equals(endpoint, "::1", StringComparison.OrdinalIgnoreCase))
             {
@@ -146,12 +159,24 @@ namespace Emby.Server.Implementations.Networking
                 return Is172AddressPrivate(endpoint);
             }
 
-            return endpoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) ||
+            if (endpoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) ||
                 endpoint.StartsWith("127.", StringComparison.OrdinalIgnoreCase) ||
-                endpoint.StartsWith("192.168", StringComparison.OrdinalIgnoreCase) ||
-                endpoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase) ||
-                //endpoint.StartsWith("10.", StringComparison.OrdinalIgnoreCase) ||
-                IsInPrivateAddressSpaceAndLocalSubnet(endpoint);
+                endpoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            if (checkSubnets && endpoint.StartsWith("192.168", StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            if (checkSubnets && IsInPrivateAddressSpaceAndLocalSubnet(endpoint))
+            {
+                return true;
+            }
+
+            return false;
         }
 
         public bool IsInPrivateAddressSpaceAndLocalSubnet(string endpoint)
@@ -238,9 +263,38 @@ namespace Emby.Server.Implementations.Networking
             return IsInLocalNetworkInternal(endpoint, true);
         }
 
-        public bool IsInLocalNetworkInternal(string endpoint, bool resolveHost)
+        public bool IsAddressInSubnets(string addressString, string[] subnets)
         {
-            if (string.IsNullOrWhiteSpace(endpoint))
+            return IsAddressInSubnets(IPAddress.Parse(addressString), addressString, subnets);
+        }
+
+        private bool IsAddressInSubnets(IPAddress address, string addressString, string[] subnets)
+        {
+            foreach (var subnet in subnets)
+            {
+                var normalizedSubnet = subnet.Trim();
+
+                if (string.Equals(normalizedSubnet, addressString, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+
+                if (normalizedSubnet.IndexOf('/') != -1)
+                {
+                    var ipnetwork = IPNetwork.Parse(normalizedSubnet);
+                    if (ipnetwork.Contains(address))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private bool IsInLocalNetworkInternal(string endpoint, bool resolveHost)
+        {
+            if (string.IsNullOrEmpty(endpoint))
             {
                 throw new ArgumentNullException("endpoint");
             }
@@ -250,11 +304,25 @@ namespace Emby.Server.Implementations.Networking
             {
                 var addressString = address.ToString();
 
+                var localSubnetsFn = LocalSubnetsFn;
+                if (localSubnetsFn != null)
+                {
+                    var localSubnets = localSubnetsFn();
+                    foreach (var subnet in localSubnets)
+                    {
+                        // only validate if there's at least one valid entry
+                        if (!string.IsNullOrWhiteSpace(subnet))
+                        {
+                            return IsAddressInSubnets(address, addressString, localSubnets) || IsInPrivateAddressSpace(addressString, false);
+                        }
+                    }
+                }
+
                 int lengthMatch = 100;
                 if (address.AddressFamily == AddressFamily.InterNetwork)
                 {
                     lengthMatch = 4;
-                    if (IsInPrivateAddressSpace(addressString))
+                    if (IsInPrivateAddressSpace(addressString, true))
                     {
                         return true;
                     }
@@ -262,7 +330,7 @@ namespace Emby.Server.Implementations.Networking
                 else if (address.AddressFamily == AddressFamily.InterNetworkV6)
                 {
                     lengthMatch = 9;
-                    if (IsInPrivateAddressSpace(endpoint))
+                    if (IsInPrivateAddressSpace(endpoint, true))
                     {
                         return true;
                     }
@@ -353,13 +421,7 @@ namespace Emby.Server.Implementations.Networking
                         return new List<IPAddress>();
                     }
 
-                    //if (!_validNetworkInterfaceTypes.Contains(network.NetworkInterfaceType))
-                    //{
-                    //    return new List<IPAddress>();
-                    //}
-
                     return ipProperties.UnicastAddresses
-                        //.Where(i => i.IsDnsEligible)
                         .Select(i => i.Address)
                         .Where(i => i.AddressFamily == AddressFamily.InterNetwork || i.AddressFamily == AddressFamily.InterNetworkV6)
                         .ToList();
@@ -408,16 +470,40 @@ namespace Emby.Server.Implementations.Networking
             }
         }
 
-        /// <summary>
-        /// Returns MAC Address from first Network Card in Computer
-        /// </summary>
-        /// <returns>[string] MAC Address</returns>
-        public string GetMacAddress()
+        private List<string> _macAddresses;
+        public List<string> GetMacAddresses()
+        {
+            if (_macAddresses == null)
+            {
+                _macAddresses = GetMacAddressesInternal();
+            }
+            return _macAddresses;
+        }
+
+        private List<string> GetMacAddressesInternal()
         {
             return NetworkInterface.GetAllNetworkInterfaces()
                 .Where(i => i.NetworkInterfaceType != NetworkInterfaceType.Loopback)
-                .Select(i => BitConverter.ToString(i.GetPhysicalAddress().GetAddressBytes()))
-                .FirstOrDefault();
+                .Select(i =>
+                {
+                    try
+                    {
+                        var physicalAddress = i.GetPhysicalAddress();
+
+                        if (physicalAddress == null)
+                        {
+                            return null;
+                        }
+
+                        return physicalAddress.ToString();
+                    }
+                    catch (Exception ex)
+                    {
+                        return null;
+                    }
+                })
+                .Where(i => i != null)
+                .ToList();
         }
 
         /// <summary>