From 6d250c4050ceb0bda33aad6a484fd05e508c4e27 Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Fri, 4 Nov 2016 04:31:05 -0400
Subject: make dlna project portable

---
 MediaBrowser.Model/Net/ISocketFactory.cs | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 MediaBrowser.Model/Net/ISocketFactory.cs

(limited to 'MediaBrowser.Model/Net/ISocketFactory.cs')

diff --git a/MediaBrowser.Model/Net/ISocketFactory.cs b/MediaBrowser.Model/Net/ISocketFactory.cs
new file mode 100644
index 000000000..c0e0440c2
--- /dev/null
+++ b/MediaBrowser.Model/Net/ISocketFactory.cs
@@ -0,0 +1,26 @@
+
+namespace MediaBrowser.Model.Net
+{
+    /// <summary>
+    /// Implemented by components that can create a platform specific UDP socket implementation, and wrap it in the cross platform <see cref="IUdpSocket"/> interface.
+    /// </summary>
+    public interface ISocketFactory
+	{
+
+		/// <summary>
+		/// Createa a new unicast socket using the specified local port number.
+		/// </summary>
+		/// <param name="localPort">The local port to bind to.</param>
+		/// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
+		IUdpSocket CreateUdpSocket(int localPort);
+
+		/// <summary>
+		/// Createa a new multicast socket using the specified multicast IP address, multicast time to live and local port.
+		/// </summary>
+		/// <param name="ipAddress">The multicast IP address to bind to.</param>
+		/// <param name="multicastTimeToLive">The multicast time to live value. Actually a maximum number of network hops for UDP packets.</param>
+		/// <param name="localPort">The local port to bind to.</param>
+		/// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
+		IUdpSocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort);
+	}
+}
-- 
cgit v1.2.3


From 72aaecb27930e04aa356febf35db2372bc417166 Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Fri, 4 Nov 2016 14:56:47 -0400
Subject: move classes to new server project

---
 Emby.Common.Implementations/Net/SocketFactory.cs   |   30 +-
 Emby.Common.Implementations/Net/UdpSocket.cs       |   38 +-
 .../Networking/BaseNetworkManager.cs               |   31 +
 Emby.Server.Implementations/Connect/ConnectData.cs |   36 +
 .../Connect/ConnectEntryPoint.cs                   |  199 ++++
 .../Connect/ConnectManager.cs                      | 1189 +++++++++++++++++++
 Emby.Server.Implementations/Connect/Responses.cs   |   85 ++
 Emby.Server.Implementations/Connect/Validator.cs   |   29 +
 .../Emby.Server.Implementations.csproj             |    9 +
 .../EntryPoints/UdpServerEntryPoint.cs             |   85 ++
 Emby.Server.Implementations/IO/FileRefresher.cs    |  323 ++++++
 .../Security/EncryptionManager.cs                  |   51 +
 Emby.Server.Implementations/Udp/UdpServer.cs       |  247 ++++
 MediaBrowser.Common/Net/INetworkManager.cs         |    4 +
 MediaBrowser.Model/MediaBrowser.Model.csproj       |    2 +-
 MediaBrowser.Model/Net/ISocketFactory.cs           |   21 +-
 MediaBrowser.Model/Net/IUdpSocket.cs               |    6 +-
 MediaBrowser.Model/Net/ReceivedUdpData.cs          |   24 -
 MediaBrowser.Model/Net/SocketReceiveResult.cs      |   24 +
 .../Connect/ConnectData.cs                         |   36 -
 .../Connect/ConnectEntryPoint.cs                   |  203 ----
 .../Connect/ConnectManager.cs                      | 1192 --------------------
 .../Connect/Responses.cs                           |   85 --
 .../Connect/Validator.cs                           |   29 -
 .../EntryPoints/UdpServerEntryPoint.cs             |   92 --
 .../SocketSharp/WebSocketSharpListener.cs          |    2 +-
 .../IO/FileRefresher.cs                            |  323 ------
 .../IO/LibraryMonitor.cs                           |   14 +-
 .../Logging/PatternsLogger.cs                      |   63 --
 .../MediaBrowser.Server.Implementations.csproj     |   11 -
 .../Security/EncryptionManager.cs                  |   51 -
 .../Udp/UdpMessageReceivedEventArgs.cs             |   21 -
 .../Udp/UdpServer.cs                               |  328 ------
 .../ApplicationHost.cs                             |    7 +-
 RSSDP/SsdpCommunicationsServer.cs                  |    6 +-
 35 files changed, 2387 insertions(+), 2509 deletions(-)
 create mode 100644 Emby.Server.Implementations/Connect/ConnectData.cs
 create mode 100644 Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
 create mode 100644 Emby.Server.Implementations/Connect/ConnectManager.cs
 create mode 100644 Emby.Server.Implementations/Connect/Responses.cs
 create mode 100644 Emby.Server.Implementations/Connect/Validator.cs
 create mode 100644 Emby.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
 create mode 100644 Emby.Server.Implementations/IO/FileRefresher.cs
 create mode 100644 Emby.Server.Implementations/Security/EncryptionManager.cs
 create mode 100644 Emby.Server.Implementations/Udp/UdpServer.cs
 delete mode 100644 MediaBrowser.Model/Net/ReceivedUdpData.cs
 create mode 100644 MediaBrowser.Model/Net/SocketReceiveResult.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Connect/ConnectData.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Connect/ConnectEntryPoint.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Connect/ConnectManager.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Connect/Responses.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Connect/Validator.cs
 delete mode 100644 MediaBrowser.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
 delete mode 100644 MediaBrowser.Server.Implementations/IO/FileRefresher.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Logging/PatternsLogger.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Security/EncryptionManager.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Udp/UdpMessageReceivedEventArgs.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Udp/UdpServer.cs

(limited to 'MediaBrowser.Model/Net/ISocketFactory.cs')

diff --git a/Emby.Common.Implementations/Net/SocketFactory.cs b/Emby.Common.Implementations/Net/SocketFactory.cs
index 3a2cea12a..6f0ff2996 100644
--- a/Emby.Common.Implementations/Net/SocketFactory.cs
+++ b/Emby.Common.Implementations/Net/SocketFactory.cs
@@ -36,13 +36,37 @@ namespace Emby.Common.Implementations.Net
 
         #region ISocketFactory Members
 
+        /// <summary>
+        /// Creates a new UDP socket and binds it to the specified local port.
+        /// </summary>
+        /// <param name="localPort">An integer specifying the local port to bind the socket to.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The purpose of this method is to create and returns a disposable result, it is up to the caller to dispose it when they are done with it.")]
+        public IUdpSocket CreateUdpSocket(int localPort)
+        {
+            if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort");
+
+            var retVal = new Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
+            try
+            {
+                retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+                return new UdpSocket(retVal, localPort, _LocalIP);
+            }
+            catch
+            {
+                if (retVal != null)
+                    retVal.Dispose();
+
+                throw;
+            }
+        }
+
         /// <summary>
         /// Creates a new UDP socket that is a member of the SSDP multicast local admin group and binds it to the specified local port.
         /// </summary>
         /// <param name="localPort">An integer specifying the local port to bind the socket to.</param>
         /// <returns>An implementation of the <see cref="IUdpSocket"/> interface used by RSSDP components to perform socket operations.</returns>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The purpose of this method is to create and returns a disposable result, it is up to the caller to dispose it when they are done with it.")]
-        public IUdpSocket CreateUdpSocket(int localPort)
+        public IUdpSocket CreateSsdpUdpSocket(int localPort)
         {
             if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort");
 
@@ -52,7 +76,7 @@ namespace Emby.Common.Implementations.Net
                 retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                 retVal.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 4);
                 retVal.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse("239.255.255.250"), _LocalIP));
-                return new UdpSocket(retVal, localPort, _LocalIP.ToString());
+                return new UdpSocket(retVal, localPort, _LocalIP);
             }
             catch
             {
@@ -97,7 +121,7 @@ namespace Emby.Common.Implementations.Net
                 retVal.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(IPAddress.Parse(ipAddress), _LocalIP));
                 retVal.MulticastLoopback = true;
 
-                return new UdpSocket(retVal, localPort, _LocalIP.ToString());
+                return new UdpSocket(retVal, localPort, _LocalIP);
             }
             catch
             {
diff --git a/Emby.Common.Implementations/Net/UdpSocket.cs b/Emby.Common.Implementations/Net/UdpSocket.cs
index 86ce9c83b..997d3f25f 100644
--- a/Emby.Common.Implementations/Net/UdpSocket.cs
+++ b/Emby.Common.Implementations/Net/UdpSocket.cs
@@ -24,19 +24,13 @@ namespace Emby.Common.Implementations.Net
 
         #region Constructors
 
-        public UdpSocket(System.Net.Sockets.Socket socket, int localPort, string ipAddress)
+        public UdpSocket(System.Net.Sockets.Socket socket, int localPort, IPAddress ip)
         {
             if (socket == null) throw new ArgumentNullException("socket");
 
             _Socket = socket;
             _LocalPort = localPort;
 
-            IPAddress ip = null;
-            if (String.IsNullOrEmpty(ipAddress))
-                ip = IPAddress.Any;
-            else
-                ip = IPAddress.Parse(ipAddress);
-
             _Socket.Bind(new IPEndPoint(ip, _LocalPort));
             if (_LocalPort == 0)
                 _LocalPort = (_Socket.LocalEndPoint as IPEndPoint).Port;
@@ -46,11 +40,11 @@ namespace Emby.Common.Implementations.Net
 
         #region IUdpSocket Members
 
-        public Task<ReceivedUdpData> ReceiveAsync()
+        public Task<SocketReceiveResult> ReceiveAsync()
         {
             ThrowIfDisposed();
 
-            var tcs = new TaskCompletionSource<ReceivedUdpData>();
+            var tcs = new TaskCompletionSource<SocketReceiveResult>();
 
             System.Net.EndPoint receivedFromEndPoint = new IPEndPoint(IPAddress.Any, 0);
             var state = new AsyncReceiveState(_Socket, receivedFromEndPoint);
@@ -74,22 +68,30 @@ namespace Emby.Common.Implementations.Net
             return tcs.Task;
         }
 
-        public Task SendTo(byte[] messageData, IpEndPointInfo endPoint)
+        public Task SendAsync(byte[] buffer, int size, IpEndPointInfo endPoint)
         {
             ThrowIfDisposed();
 
-            if (messageData == null) throw new ArgumentNullException("messageData");
+            if (buffer == null) throw new ArgumentNullException("messageData");
             if (endPoint == null) throw new ArgumentNullException("endPoint");
 
 #if NETSTANDARD1_6
-            _Socket.SendTo(messageData, new System.Net.IPEndPoint(IPAddress.Parse(endPoint.IpAddress.ToString()), endPoint.Port));
+
+            if (size != buffer.Length)
+            {
+                byte[] copy = new byte[size];
+                Buffer.BlockCopy(buffer, 0, copy, 0, size);
+                buffer = copy;
+            }
+
+            _Socket.SendTo(buffer, new System.Net.IPEndPoint(IPAddress.Parse(endPoint.IpAddress.ToString()), endPoint.Port));
             return Task.FromResult(true);
 #else
             var taskSource = new TaskCompletionSource<bool>();
 
             try
             {
-                _Socket.BeginSendTo(messageData, 0, messageData.Length, SocketFlags.None, new System.Net.IPEndPoint(IPAddress.Parse(endPoint.IpAddress.ToString()), endPoint.Port), result =>
+                _Socket.BeginSendTo(buffer, 0, size, SocketFlags.None, new System.Net.IPEndPoint(IPAddress.Parse(endPoint.IpAddress.ToString()), endPoint.Port), result =>
                 {
                     try
                     {
@@ -160,11 +162,11 @@ namespace Emby.Common.Implementations.Net
 
                 var ipEndPoint = state.EndPoint as IPEndPoint;
                 state.TaskCompletionSource.SetResult(
-                    new ReceivedUdpData()
+                    new SocketReceiveResult()
                     {
                         Buffer = state.Buffer,
                         ReceivedBytes = bytesRead,
-                        ReceivedFrom = ToIpEndPointInfo(ipEndPoint)
+                        RemoteEndPoint = ToIpEndPointInfo(ipEndPoint)
                     }
                 );
             }
@@ -215,11 +217,11 @@ namespace Emby.Common.Implementations.Net
 
                 var ipEndPoint = state.EndPoint as IPEndPoint;
                 state.TaskCompletionSource.SetResult(
-                    new ReceivedUdpData()
+                    new SocketReceiveResult
                     {
                         Buffer = state.Buffer,
                         ReceivedBytes = bytesRead,
-                        ReceivedFrom = ToIpEndPointInfo(ipEndPoint)
+                        RemoteEndPoint = ToIpEndPointInfo(ipEndPoint)
                     }
                 );
             }
@@ -258,7 +260,7 @@ namespace Emby.Common.Implementations.Net
 
             public System.Net.Sockets.Socket Socket { get; private set; }
 
-            public TaskCompletionSource<ReceivedUdpData> TaskCompletionSource { get; set; }
+            public TaskCompletionSource<SocketReceiveResult> TaskCompletionSource { get; set; }
 
         }
 
diff --git a/Emby.Common.Implementations/Networking/BaseNetworkManager.cs b/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
index bab340e27..d1c299dc9 100644
--- a/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
+++ b/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
@@ -8,6 +8,7 @@ using System.Net.NetworkInformation;
 using System.Net.Sockets;
 using System.Threading.Tasks;
 using MediaBrowser.Model.Extensions;
+using MediaBrowser.Model.Net;
 
 namespace Emby.Common.Implementations.Networking
 {
@@ -382,5 +383,35 @@ namespace Emby.Common.Implementations.Networking
 
             return hosts[0];
         }
+
+        public IpAddressInfo ParseIpAddress(string ipAddress)
+        {
+            IpAddressInfo info;
+            if (TryParseIpAddress(ipAddress, out info))
+            {
+                return info;
+            }
+
+            throw new ArgumentException("Invalid ip address: " + ipAddress);
+        }
+
+        public bool TryParseIpAddress(string ipAddress, out IpAddressInfo ipAddressInfo)
+        {
+            IPAddress address;
+            if (IPAddress.TryParse(ipAddress, out address))
+            {
+
+                ipAddressInfo = new IpAddressInfo
+                {
+                    Address = address.ToString(),
+                    IsIpv6 = address.AddressFamily == AddressFamily.InterNetworkV6
+                };
+
+                return true;
+            }
+
+            ipAddressInfo = null;
+            return false;
+        }
     }
 }
diff --git a/Emby.Server.Implementations/Connect/ConnectData.cs b/Emby.Server.Implementations/Connect/ConnectData.cs
new file mode 100644
index 000000000..41b89ce52
--- /dev/null
+++ b/Emby.Server.Implementations/Connect/ConnectData.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+namespace Emby.Server.Implementations.Connect
+{
+    public class ConnectData
+    {
+        /// <summary>
+        /// Gets or sets the server identifier.
+        /// </summary>
+        /// <value>The server identifier.</value>
+        public string ServerId { get; set; }
+        /// <summary>
+        /// Gets or sets the access key.
+        /// </summary>
+        /// <value>The access key.</value>
+        public string AccessKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the authorizations.
+        /// </summary>
+        /// <value>The authorizations.</value>
+        public List<ConnectAuthorizationInternal> PendingAuthorizations { get; set; }
+
+        /// <summary>
+        /// Gets or sets the last authorizations refresh.
+        /// </summary>
+        /// <value>The last authorizations refresh.</value>
+        public DateTime LastAuthorizationsRefresh { get; set; }
+
+        public ConnectData()
+        {
+            PendingAuthorizations = new List<ConnectAuthorizationInternal>();
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs b/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
new file mode 100644
index 000000000..d7574d466
--- /dev/null
+++ b/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
@@ -0,0 +1,199 @@
+using MediaBrowser.Common;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Connect;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Net;
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.Connect
+{
+    public class ConnectEntryPoint : IServerEntryPoint
+    {
+        private ITimer _timer;
+        private readonly IHttpClient _httpClient;
+        private readonly IApplicationPaths _appPaths;
+        private readonly ILogger _logger;
+        private readonly IConnectManager _connectManager;
+
+        private readonly INetworkManager _networkManager;
+        private readonly IApplicationHost _appHost;
+        private readonly IFileSystem _fileSystem;
+        private readonly ITimerFactory _timerFactory;
+
+        public ConnectEntryPoint(IHttpClient httpClient, IApplicationPaths appPaths, ILogger logger, INetworkManager networkManager, IConnectManager connectManager, IApplicationHost appHost, IFileSystem fileSystem, ITimerFactory timerFactory)
+        {
+            _httpClient = httpClient;
+            _appPaths = appPaths;
+            _logger = logger;
+            _networkManager = networkManager;
+            _connectManager = connectManager;
+            _appHost = appHost;
+            _fileSystem = fileSystem;
+            _timerFactory = timerFactory;
+        }
+
+        public void Run()
+        {
+            LoadCachedAddress();
+
+            _timer = _timerFactory.Create(TimerCallback, null, TimeSpan.FromSeconds(5), TimeSpan.FromHours(1));
+            ((ConnectManager)_connectManager).Start();
+        }
+
+        private readonly string[] _ipLookups =
+        {
+            "http://bot.whatismyipaddress.com",
+            "https://connect.emby.media/service/ip"
+        };
+
+        private async void TimerCallback(object state)
+        {
+            IpAddressInfo validIpAddress = null;
+
+            foreach (var ipLookupUrl in _ipLookups)
+            {
+                try
+                {
+                    validIpAddress = await GetIpAddress(ipLookupUrl).ConfigureAwait(false);
+
+                    // Try to find the ipv4 address, if present
+                    if (!validIpAddress.IsIpv6)
+                    {
+                        break;
+                    }
+                }
+                catch (HttpException)
+                {
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error getting connection info", ex);
+                }
+            }
+
+            // If this produced an ipv6 address, try again
+            if (validIpAddress != null && validIpAddress.IsIpv6)
+            {
+                foreach (var ipLookupUrl in _ipLookups)
+                {
+                    try
+                    {
+                        var newAddress = await GetIpAddress(ipLookupUrl, true).ConfigureAwait(false);
+
+                        // Try to find the ipv4 address, if present
+                        if (!newAddress.IsIpv6)
+                        {
+                            validIpAddress = newAddress;
+                            break;
+                        }
+                    }
+                    catch (HttpException)
+                    {
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.ErrorException("Error getting connection info", ex);
+                    }
+                }
+            }
+
+            if (validIpAddress != null)
+            {
+                ((ConnectManager)_connectManager).OnWanAddressResolved(validIpAddress);
+                CacheAddress(validIpAddress);
+            }
+        }
+
+        private async Task<IpAddressInfo> GetIpAddress(string lookupUrl, bool preferIpv4 = false)
+        {
+            // Sometimes whatismyipaddress might fail, but it won't do us any good having users raise alarms over it.
+            var logErrors = false;
+
+#if DEBUG
+            logErrors = true;
+#endif
+            using (var stream = await _httpClient.Get(new HttpRequestOptions
+            {
+                Url = lookupUrl,
+                UserAgent = "Emby/" + _appHost.ApplicationVersion,
+                LogErrors = logErrors,
+
+                // Seeing block length errors with our server
+                EnableHttpCompression = false,
+                PreferIpv4 = preferIpv4,
+                BufferContent = false
+
+            }).ConfigureAwait(false))
+            {
+                using (var reader = new StreamReader(stream))
+                {
+                    var addressString = await reader.ReadToEndAsync().ConfigureAwait(false);
+
+                    return _networkManager.ParseIpAddress(addressString);
+                }
+            }
+        }
+
+        private string CacheFilePath
+        {
+            get { return Path.Combine(_appPaths.DataPath, "wan.txt"); }
+        }
+
+        private void CacheAddress(IpAddressInfo address)
+        {
+            var path = CacheFilePath;
+
+            try
+            {
+                _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
+                _fileSystem.WriteAllText(path, address.ToString(), Encoding.UTF8);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error saving data", ex);
+            }
+        }
+
+        private void LoadCachedAddress()
+        {
+            var path = CacheFilePath;
+
+            _logger.Info("Loading data from {0}", path);
+
+            try
+            {
+                var endpoint = _fileSystem.ReadAllText(path, Encoding.UTF8);
+                IpAddressInfo ipAddress;
+
+                if (_networkManager.TryParseIpAddress(endpoint, out ipAddress))
+                {
+                    ((ConnectManager)_connectManager).OnWanAddressResolved(ipAddress);
+                }
+            }
+            catch (IOException)
+            {
+                // File isn't there. no biggie
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error loading data", ex);
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_timer != null)
+            {
+                _timer.Dispose();
+                _timer = null;
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Connect/ConnectManager.cs b/Emby.Server.Implementations/Connect/ConnectManager.cs
new file mode 100644
index 000000000..6c2ac40c3
--- /dev/null
+++ b/Emby.Server.Implementations/Connect/ConnectManager.cs
@@ -0,0 +1,1189 @@
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Common.Security;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Connect;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Controller.Security;
+using MediaBrowser.Model.Connect;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Net;
+using MediaBrowser.Model.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Common.Extensions;
+
+namespace Emby.Server.Implementations.Connect
+{
+    public class ConnectManager : IConnectManager
+    {
+        private readonly SemaphoreSlim _operationLock = new SemaphoreSlim(1, 1);
+
+        private readonly ILogger _logger;
+        private readonly IApplicationPaths _appPaths;
+        private readonly IJsonSerializer _json;
+        private readonly IEncryptionManager _encryption;
+        private readonly IHttpClient _httpClient;
+        private readonly IServerApplicationHost _appHost;
+        private readonly IServerConfigurationManager _config;
+        private readonly IUserManager _userManager;
+        private readonly IProviderManager _providerManager;
+        private readonly ISecurityManager _securityManager;
+        private readonly IFileSystem _fileSystem;
+
+        private ConnectData _data = new ConnectData();
+
+        public string ConnectServerId
+        {
+            get { return _data.ServerId; }
+        }
+        public string ConnectAccessKey
+        {
+            get { return _data.AccessKey; }
+        }
+
+        private IpAddressInfo DiscoveredWanIpAddress { get; set; }
+
+        public string WanIpAddress
+        {
+            get
+            {
+                var address = _config.Configuration.WanDdns;
+
+                if (!string.IsNullOrWhiteSpace(address))
+                {
+                    Uri newUri;
+
+                    if (Uri.TryCreate(address, UriKind.Absolute, out newUri))
+                    {
+                        address = newUri.Host;
+                    }
+                }
+
+                if (string.IsNullOrWhiteSpace(address) && DiscoveredWanIpAddress != null)
+                {
+                    if (DiscoveredWanIpAddress.IsIpv6)
+                    {
+                        address = "[" + DiscoveredWanIpAddress + "]";
+                    }
+                    else
+                    {
+                        address = DiscoveredWanIpAddress.ToString();
+                    }
+                }
+
+                return address;
+            }
+        }
+
+        public string WanApiAddress
+        {
+            get
+            {
+                var ip = WanIpAddress;
+
+                if (!string.IsNullOrEmpty(ip))
+                {
+                    if (!ip.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
+                        !ip.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+                    {
+                        ip = (_appHost.EnableHttps ? "https://" : "http://") + ip;
+                    }
+
+                    ip += ":";
+                    ip += _appHost.EnableHttps ? _config.Configuration.PublicHttpsPort.ToString(CultureInfo.InvariantCulture) : _config.Configuration.PublicPort.ToString(CultureInfo.InvariantCulture);
+
+                    return ip;
+                }
+
+                return null;
+            }
+        }
+
+        private string XApplicationValue
+        {
+            get { return _appHost.Name + "/" + _appHost.ApplicationVersion; }
+        }
+
+        public ConnectManager(ILogger logger,
+            IApplicationPaths appPaths,
+            IJsonSerializer json,
+            IEncryptionManager encryption,
+            IHttpClient httpClient,
+            IServerApplicationHost appHost,
+            IServerConfigurationManager config, IUserManager userManager, IProviderManager providerManager, ISecurityManager securityManager, IFileSystem fileSystem)
+        {
+            _logger = logger;
+            _appPaths = appPaths;
+            _json = json;
+            _encryption = encryption;
+            _httpClient = httpClient;
+            _appHost = appHost;
+            _config = config;
+            _userManager = userManager;
+            _providerManager = providerManager;
+            _securityManager = securityManager;
+            _fileSystem = fileSystem;
+
+            LoadCachedData();
+        }
+
+        internal void Start()
+        {
+            _config.ConfigurationUpdated += _config_ConfigurationUpdated;
+        }
+
+        internal void OnWanAddressResolved(IpAddressInfo address)
+        {
+            DiscoveredWanIpAddress = address;
+
+            var task = UpdateConnectInfo();
+        }
+
+        private async Task UpdateConnectInfo()
+        {
+            await _operationLock.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                await UpdateConnectInfoInternal().ConfigureAwait(false);
+            }
+            finally
+            {
+                _operationLock.Release();
+            }
+        }
+
+        private async Task UpdateConnectInfoInternal()
+        {
+            var wanApiAddress = WanApiAddress;
+
+            if (string.IsNullOrWhiteSpace(wanApiAddress))
+            {
+                _logger.Warn("Cannot update Emby Connect information without a WanApiAddress");
+                return;
+            }
+
+            try
+            {
+                var localAddress = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
+
+                var hasExistingRecord = !string.IsNullOrWhiteSpace(ConnectServerId) &&
+                                  !string.IsNullOrWhiteSpace(ConnectAccessKey);
+
+                var createNewRegistration = !hasExistingRecord;
+
+                if (hasExistingRecord)
+                {
+                    try
+                    {
+                        await UpdateServerRegistration(wanApiAddress, localAddress).ConfigureAwait(false);
+                    }
+                    catch (HttpException ex)
+                    {
+                        if (!ex.StatusCode.HasValue || !new[] { HttpStatusCode.NotFound, HttpStatusCode.Unauthorized }.Contains(ex.StatusCode.Value))
+                        {
+                            throw;
+                        }
+
+                        createNewRegistration = true;
+                    }
+                }
+
+                if (createNewRegistration)
+                {
+                    await CreateServerRegistration(wanApiAddress, localAddress).ConfigureAwait(false);
+                }
+
+                _lastReportedIdentifier = GetConnectReportingIdentifier(localAddress, wanApiAddress);
+
+                await RefreshAuthorizationsInternal(true, CancellationToken.None).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error registering with Connect", ex);
+            }
+        }
+
+        private string _lastReportedIdentifier;
+        private async Task<string> GetConnectReportingIdentifier()
+        {
+            var url = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
+            return GetConnectReportingIdentifier(url, WanApiAddress);
+        }
+        private string GetConnectReportingIdentifier(string localAddress, string remoteAddress)
+        {
+            return (remoteAddress ?? string.Empty) + (localAddress ?? string.Empty);
+        }
+
+        async void _config_ConfigurationUpdated(object sender, EventArgs e)
+        {
+            // If info hasn't changed, don't report anything
+            var connectIdentifier = await GetConnectReportingIdentifier().ConfigureAwait(false);
+            if (string.Equals(_lastReportedIdentifier, connectIdentifier, StringComparison.OrdinalIgnoreCase))
+            {
+                return;
+            }
+
+            await UpdateConnectInfo().ConfigureAwait(false);
+        }
+
+        private async Task CreateServerRegistration(string wanApiAddress, string localAddress)
+        {
+            if (string.IsNullOrWhiteSpace(wanApiAddress))
+            {
+                throw new ArgumentNullException("wanApiAddress");
+            }
+
+            var url = "Servers";
+            url = GetConnectUrl(url);
+
+            var postData = new Dictionary<string, string>
+            {
+                {"name", _appHost.FriendlyName},
+                {"url", wanApiAddress},
+                {"systemId", _appHost.SystemId}
+            };
+
+            if (!string.IsNullOrWhiteSpace(localAddress))
+            {
+                postData["localAddress"] = localAddress;
+            }
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            options.SetPostData(postData);
+            SetApplicationHeader(options);
+
+            using (var response = await _httpClient.Post(options).ConfigureAwait(false))
+            {
+                var data = _json.DeserializeFromStream<ServerRegistrationResponse>(response.Content);
+
+                _data.ServerId = data.Id;
+                _data.AccessKey = data.AccessKey;
+
+                CacheData();
+            }
+        }
+
+        private async Task UpdateServerRegistration(string wanApiAddress, string localAddress)
+        {
+            if (string.IsNullOrWhiteSpace(wanApiAddress))
+            {
+                throw new ArgumentNullException("wanApiAddress");
+            }
+
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                throw new ArgumentNullException("ConnectServerId");
+            }
+
+            var url = "Servers";
+            url = GetConnectUrl(url);
+            url += "?id=" + ConnectServerId;
+
+            var postData = new Dictionary<string, string>
+            {
+                {"name", _appHost.FriendlyName},
+                {"url", wanApiAddress},
+                {"systemId", _appHost.SystemId}
+            };
+
+            if (!string.IsNullOrWhiteSpace(localAddress))
+            {
+                postData["localAddress"] = localAddress;
+            }
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            options.SetPostData(postData);
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            // No need to examine the response
+            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
+            {
+            }
+        }
+
+        private readonly object _dataFileLock = new object();
+        private string CacheFilePath
+        {
+            get { return Path.Combine(_appPaths.DataPath, "connect.txt"); }
+        }
+
+        private void CacheData()
+        {
+            var path = CacheFilePath;
+
+            try
+            {
+                _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
+
+                var json = _json.SerializeToString(_data);
+
+                var encrypted = _encryption.EncryptString(json);
+
+                lock (_dataFileLock)
+                {
+                    _fileSystem.WriteAllText(path, encrypted, Encoding.UTF8);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error saving data", ex);
+            }
+        }
+
+        private void LoadCachedData()
+        {
+            var path = CacheFilePath;
+
+            _logger.Info("Loading data from {0}", path);
+
+            try
+            {
+                lock (_dataFileLock)
+                {
+                    var encrypted = _fileSystem.ReadAllText(path, Encoding.UTF8);
+
+                    var json = _encryption.DecryptString(encrypted);
+
+                    _data = _json.DeserializeFromString<ConnectData>(json);
+                }
+            }
+            catch (IOException)
+            {
+                // File isn't there. no biggie
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error loading data", ex);
+            }
+        }
+
+        private User GetUser(string id)
+        {
+            var user = _userManager.GetUserById(id);
+
+            if (user == null)
+            {
+                throw new ArgumentException("User not found.");
+            }
+
+            return user;
+        }
+
+        private string GetConnectUrl(string handler)
+        {
+            return "https://connect.emby.media/service/" + handler;
+        }
+
+        public async Task<UserLinkResult> LinkUser(string userId, string connectUsername)
+        {
+            if (string.IsNullOrWhiteSpace(userId))
+            {
+                throw new ArgumentNullException("userId");
+            }
+            if (string.IsNullOrWhiteSpace(connectUsername))
+            {
+                throw new ArgumentNullException("connectUsername");
+            }
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                await UpdateConnectInfo().ConfigureAwait(false);
+            }
+
+            await _operationLock.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                return await LinkUserInternal(userId, connectUsername).ConfigureAwait(false);
+            }
+            finally
+            {
+                _operationLock.Release();
+            }
+        }
+
+        private async Task<UserLinkResult> LinkUserInternal(string userId, string connectUsername)
+        {
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                throw new ArgumentNullException("ConnectServerId");
+            }
+
+            var connectUser = await GetConnectUser(new ConnectUserQuery
+            {
+                NameOrEmail = connectUsername
+
+            }, CancellationToken.None).ConfigureAwait(false);
+
+            if (!connectUser.IsActive)
+            {
+                throw new ArgumentException("The Emby account has been disabled.");
+            }
+
+            var existingUser = _userManager.Users.FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUser.Id) && !string.IsNullOrWhiteSpace(i.ConnectAccessKey));
+            if (existingUser != null)
+            {
+                throw new InvalidOperationException("This connect user is already linked to local user " + existingUser.Name);
+            }
+
+            var user = GetUser(userId);
+
+            if (!string.IsNullOrWhiteSpace(user.ConnectUserId))
+            {
+                await RemoveConnect(user, user.ConnectUserId).ConfigureAwait(false);
+            }
+
+            var url = GetConnectUrl("ServerAuthorizations");
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            var accessToken = Guid.NewGuid().ToString("N");
+
+            var postData = new Dictionary<string, string>
+            {
+                {"serverId", ConnectServerId},
+                {"userId", connectUser.Id},
+                {"userType", "Linked"},
+                {"accessToken", accessToken}
+            };
+
+            options.SetPostData(postData);
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            var result = new UserLinkResult();
+
+            // No need to examine the response
+            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
+            {
+                var response = _json.DeserializeFromStream<ServerUserAuthorizationResponse>(stream);
+
+                result.IsPending = string.Equals(response.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase);
+            }
+
+            user.ConnectAccessKey = accessToken;
+            user.ConnectUserName = connectUser.Name;
+            user.ConnectUserId = connectUser.Id;
+            user.ConnectLinkType = UserLinkType.LinkedUser;
+
+            await user.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+
+            await _userManager.UpdateConfiguration(user.Id.ToString("N"), user.Configuration);
+
+            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
+
+            return result;
+        }
+
+        public async Task<UserLinkResult> InviteUser(ConnectAuthorizationRequest request)
+        {
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                await UpdateConnectInfo().ConfigureAwait(false);
+            }
+
+            await _operationLock.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                return await InviteUserInternal(request).ConfigureAwait(false);
+            }
+            finally
+            {
+                _operationLock.Release();
+            }
+        }
+
+        private async Task<UserLinkResult> InviteUserInternal(ConnectAuthorizationRequest request)
+        {
+            var connectUsername = request.ConnectUserName;
+            var sendingUserId = request.SendingUserId;
+
+            if (string.IsNullOrWhiteSpace(connectUsername))
+            {
+                throw new ArgumentNullException("connectUsername");
+            }
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                throw new ArgumentNullException("ConnectServerId");
+            }
+
+            var sendingUser = GetUser(sendingUserId);
+            var requesterUserName = sendingUser.ConnectUserName;
+
+            if (string.IsNullOrWhiteSpace(requesterUserName))
+            {
+                throw new ArgumentException("A Connect account is required in order to send invitations.");
+            }
+
+            string connectUserId = null;
+            var result = new UserLinkResult();
+
+            try
+            {
+                var connectUser = await GetConnectUser(new ConnectUserQuery
+                {
+                    NameOrEmail = connectUsername
+
+                }, CancellationToken.None).ConfigureAwait(false);
+
+                if (!connectUser.IsActive)
+                {
+                    throw new ArgumentException("The Emby account is not active. Please ensure the account has been activated by following the instructions within the email confirmation.");
+                }
+
+                connectUserId = connectUser.Id;
+                result.GuestDisplayName = connectUser.Name;
+            }
+            catch (HttpException ex)
+            {
+                if (!ex.StatusCode.HasValue)
+                {
+                    throw;
+                }
+
+                // If they entered a username, then whatever the error is just throw it, for example, user not found
+                if (!Validator.EmailIsValid(connectUsername))
+                {
+                    if (ex.StatusCode.Value == HttpStatusCode.NotFound)
+                    {
+                        throw new ResourceNotFoundException();
+                    }
+                    throw;
+                }
+
+                if (ex.StatusCode.Value != HttpStatusCode.NotFound)
+                {
+                    throw;
+                }
+            }
+
+            if (string.IsNullOrWhiteSpace(connectUserId))
+            {
+                return await SendNewUserInvitation(requesterUserName, connectUsername).ConfigureAwait(false);
+            }
+
+            var url = GetConnectUrl("ServerAuthorizations");
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            var accessToken = Guid.NewGuid().ToString("N");
+
+            var postData = new Dictionary<string, string>
+            {
+                {"serverId", ConnectServerId},
+                {"userId", connectUserId},
+                {"userType", "Guest"},
+                {"accessToken", accessToken},
+                {"requesterUserName", requesterUserName}
+            };
+
+            options.SetPostData(postData);
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            // No need to examine the response
+            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
+            {
+                var response = _json.DeserializeFromStream<ServerUserAuthorizationResponse>(stream);
+
+                result.IsPending = string.Equals(response.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase);
+
+                _data.PendingAuthorizations.Add(new ConnectAuthorizationInternal
+                {
+                    ConnectUserId = response.UserId,
+                    Id = response.Id,
+                    ImageUrl = response.UserImageUrl,
+                    UserName = response.UserName,
+                    EnabledLibraries = request.EnabledLibraries,
+                    EnabledChannels = request.EnabledChannels,
+                    EnableLiveTv = request.EnableLiveTv,
+                    AccessToken = accessToken
+                });
+
+                CacheData();
+            }
+
+            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
+
+            return result;
+        }
+
+        private async Task<UserLinkResult> SendNewUserInvitation(string fromName, string email)
+        {
+            var url = GetConnectUrl("users/invite");
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            var postData = new Dictionary<string, string>
+            {
+                {"email", email},
+                {"requesterUserName", fromName}
+            };
+
+            options.SetPostData(postData);
+            SetApplicationHeader(options);
+
+            // No need to examine the response
+            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
+            {
+            }
+
+            return new UserLinkResult
+            {
+                IsNewUserInvitation = true,
+                GuestDisplayName = email
+            };
+        }
+
+        public Task RemoveConnect(string userId)
+        {
+            var user = GetUser(userId);
+
+            return RemoveConnect(user, user.ConnectUserId);
+        }
+
+        private async Task RemoveConnect(User user, string connectUserId)
+        {
+            if (!string.IsNullOrWhiteSpace(connectUserId))
+            {
+                await CancelAuthorizationByConnectUserId(connectUserId).ConfigureAwait(false);
+            }
+
+            user.ConnectAccessKey = null;
+            user.ConnectUserName = null;
+            user.ConnectUserId = null;
+            user.ConnectLinkType = null;
+
+            await user.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        private async Task<ConnectUser> GetConnectUser(ConnectUserQuery query, CancellationToken cancellationToken)
+        {
+            var url = GetConnectUrl("user");
+
+            if (!string.IsNullOrWhiteSpace(query.Id))
+            {
+                url = url + "?id=" + WebUtility.UrlEncode(query.Id);
+            }
+            else if (!string.IsNullOrWhiteSpace(query.NameOrEmail))
+            {
+                url = url + "?nameOrEmail=" + WebUtility.UrlEncode(query.NameOrEmail);
+            }
+            else if (!string.IsNullOrWhiteSpace(query.Name))
+            {
+                url = url + "?name=" + WebUtility.UrlEncode(query.Name);
+            }
+            else if (!string.IsNullOrWhiteSpace(query.Email))
+            {
+                url = url + "?name=" + WebUtility.UrlEncode(query.Email);
+            }
+            else
+            {
+                throw new ArgumentException("Empty ConnectUserQuery supplied");
+            }
+
+            var options = new HttpRequestOptions
+            {
+                CancellationToken = cancellationToken,
+                Url = url,
+                BufferContent = false
+            };
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            using (var stream = await _httpClient.Get(options).ConfigureAwait(false))
+            {
+                var response = _json.DeserializeFromStream<GetConnectUserResponse>(stream);
+
+                return new ConnectUser
+                {
+                    Email = response.Email,
+                    Id = response.Id,
+                    Name = response.Name,
+                    IsActive = response.IsActive,
+                    ImageUrl = response.ImageUrl
+                };
+            }
+        }
+
+        private void SetApplicationHeader(HttpRequestOptions options)
+        {
+            options.RequestHeaders.Add("X-Application", XApplicationValue);
+        }
+
+        private void SetServerAccessToken(HttpRequestOptions options)
+        {
+            if (string.IsNullOrWhiteSpace(ConnectAccessKey))
+            {
+                throw new ArgumentNullException("ConnectAccessKey");
+            }
+
+            options.RequestHeaders.Add("X-Connect-Token", ConnectAccessKey);
+        }
+
+        public async Task RefreshAuthorizations(CancellationToken cancellationToken)
+        {
+            await _operationLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+            try
+            {
+                await RefreshAuthorizationsInternal(true, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                _operationLock.Release();
+            }
+        }
+
+        private async Task RefreshAuthorizationsInternal(bool refreshImages, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                throw new ArgumentNullException("ConnectServerId");
+            }
+
+            var url = GetConnectUrl("ServerAuthorizations");
+
+            url += "?serverId=" + ConnectServerId;
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = cancellationToken,
+                BufferContent = false
+            };
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            try
+            {
+                using (var stream = (await _httpClient.SendAsync(options, "GET").ConfigureAwait(false)).Content)
+                {
+                    var list = _json.DeserializeFromStream<List<ServerUserAuthorizationResponse>>(stream);
+
+                    await RefreshAuthorizations(list, refreshImages).ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error refreshing server authorizations.", ex);
+            }
+        }
+
+        private readonly SemaphoreSlim _connectImageSemaphore = new SemaphoreSlim(5, 5);
+        private async Task RefreshAuthorizations(List<ServerUserAuthorizationResponse> list, bool refreshImages)
+        {
+            var users = _userManager.Users.ToList();
+
+            // Handle existing authorizations that were removed by the Connect server
+            // Handle existing authorizations whose status may have been updated
+            foreach (var user in users)
+            {
+                if (!string.IsNullOrWhiteSpace(user.ConnectUserId))
+                {
+                    var connectEntry = list.FirstOrDefault(i => string.Equals(i.UserId, user.ConnectUserId, StringComparison.OrdinalIgnoreCase));
+
+                    if (connectEntry == null)
+                    {
+                        var deleteUser = user.ConnectLinkType.HasValue &&
+                                         user.ConnectLinkType.Value == UserLinkType.Guest;
+
+                        user.ConnectUserId = null;
+                        user.ConnectAccessKey = null;
+                        user.ConnectUserName = null;
+                        user.ConnectLinkType = null;
+
+                        await _userManager.UpdateUser(user).ConfigureAwait(false);
+
+                        if (deleteUser)
+                        {
+                            _logger.Debug("Deleting guest user {0}", user.Name);
+                            await _userManager.DeleteUser(user).ConfigureAwait(false);
+                        }
+                    }
+                    else
+                    {
+                        var changed = !string.Equals(user.ConnectAccessKey, connectEntry.AccessToken, StringComparison.OrdinalIgnoreCase);
+
+                        if (changed)
+                        {
+                            user.ConnectUserId = connectEntry.UserId;
+                            user.ConnectAccessKey = connectEntry.AccessToken;
+
+                            await _userManager.UpdateUser(user).ConfigureAwait(false);
+                        }
+                    }
+                }
+            }
+
+            var currentPendingList = _data.PendingAuthorizations.ToList();
+            var newPendingList = new List<ConnectAuthorizationInternal>();
+
+            foreach (var connectEntry in list)
+            {
+                if (string.Equals(connectEntry.UserType, "guest", StringComparison.OrdinalIgnoreCase))
+                {
+                    var currentPendingEntry = currentPendingList.FirstOrDefault(i => string.Equals(i.Id, connectEntry.Id, StringComparison.OrdinalIgnoreCase));
+
+                    if (string.Equals(connectEntry.AcceptStatus, "accepted", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var user = _userManager.Users
+                            .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectEntry.UserId, StringComparison.OrdinalIgnoreCase));
+
+                        if (user == null)
+                        {
+                            // Add user
+                            user = await _userManager.CreateUser(_userManager.MakeValidUsername(connectEntry.UserName)).ConfigureAwait(false);
+
+                            user.ConnectUserName = connectEntry.UserName;
+                            user.ConnectUserId = connectEntry.UserId;
+                            user.ConnectLinkType = UserLinkType.Guest;
+                            user.ConnectAccessKey = connectEntry.AccessToken;
+
+                            await _userManager.UpdateUser(user).ConfigureAwait(false);
+
+                            user.Policy.IsHidden = true;
+                            user.Policy.EnableLiveTvManagement = false;
+                            user.Policy.EnableContentDeletion = false;
+                            user.Policy.EnableRemoteControlOfOtherUsers = false;
+                            user.Policy.EnableSharedDeviceControl = false;
+                            user.Policy.IsAdministrator = false;
+
+                            if (currentPendingEntry != null)
+                            {
+                                user.Policy.EnabledFolders = currentPendingEntry.EnabledLibraries;
+                                user.Policy.EnableAllFolders = false;
+
+                                user.Policy.EnabledChannels = currentPendingEntry.EnabledChannels;
+                                user.Policy.EnableAllChannels = false;
+
+                                user.Policy.EnableLiveTvAccess = currentPendingEntry.EnableLiveTv;
+                            }
+
+                            await _userManager.UpdateConfiguration(user.Id.ToString("N"), user.Configuration);
+                        }
+                    }
+                    else if (string.Equals(connectEntry.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase))
+                    {
+                        currentPendingEntry = currentPendingEntry ?? new ConnectAuthorizationInternal();
+
+                        currentPendingEntry.ConnectUserId = connectEntry.UserId;
+                        currentPendingEntry.ImageUrl = connectEntry.UserImageUrl;
+                        currentPendingEntry.UserName = connectEntry.UserName;
+                        currentPendingEntry.Id = connectEntry.Id;
+                        currentPendingEntry.AccessToken = connectEntry.AccessToken;
+
+                        newPendingList.Add(currentPendingEntry);
+                    }
+                }
+            }
+
+            _data.PendingAuthorizations = newPendingList;
+            CacheData();
+
+            await RefreshGuestNames(list, refreshImages).ConfigureAwait(false);
+        }
+
+        private async Task RefreshGuestNames(List<ServerUserAuthorizationResponse> list, bool refreshImages)
+        {
+            var users = _userManager.Users
+                .Where(i => !string.IsNullOrEmpty(i.ConnectUserId) && i.ConnectLinkType.HasValue && i.ConnectLinkType.Value == UserLinkType.Guest)
+                    .ToList();
+
+            foreach (var user in users)
+            {
+                var authorization = list.FirstOrDefault(i => string.Equals(i.UserId, user.ConnectUserId, StringComparison.Ordinal));
+
+                if (authorization == null)
+                {
+                    _logger.Warn("Unable to find connect authorization record for user {0}", user.Name);
+                    continue;
+                }
+
+                var syncConnectName = true;
+                var syncConnectImage = true;
+
+                if (syncConnectName)
+                {
+                    var changed = !string.Equals(authorization.UserName, user.Name, StringComparison.OrdinalIgnoreCase);
+
+                    if (changed)
+                    {
+                        await user.Rename(authorization.UserName).ConfigureAwait(false);
+                    }
+                }
+
+                if (syncConnectImage)
+                {
+                    var imageUrl = authorization.UserImageUrl;
+
+                    if (!string.IsNullOrWhiteSpace(imageUrl))
+                    {
+                        var changed = false;
+
+                        if (!user.HasImage(ImageType.Primary))
+                        {
+                            changed = true;
+                        }
+                        else if (refreshImages)
+                        {
+                            using (var response = await _httpClient.SendAsync(new HttpRequestOptions
+                            {
+                                Url = imageUrl,
+                                BufferContent = false
+
+                            }, "HEAD").ConfigureAwait(false))
+                            {
+                                var length = response.ContentLength;
+
+                                if (length != _fileSystem.GetFileInfo(user.GetImageInfo(ImageType.Primary, 0).Path).Length)
+                                {
+                                    changed = true;
+                                }
+                            }
+                        }
+
+                        if (changed)
+                        {
+                            await _providerManager.SaveImage(user, imageUrl, _connectImageSemaphore, ImageType.Primary, null, CancellationToken.None).ConfigureAwait(false);
+
+                            await user.RefreshMetadata(new MetadataRefreshOptions(_fileSystem)
+                            {
+                                ForceSave = true,
+
+                            }, CancellationToken.None).ConfigureAwait(false);
+                        }
+                    }
+                }
+            }
+        }
+
+        public async Task<List<ConnectAuthorization>> GetPendingGuests()
+        {
+            var time = DateTime.UtcNow - _data.LastAuthorizationsRefresh;
+
+            if (time.TotalMinutes >= 5)
+            {
+                await _operationLock.WaitAsync(CancellationToken.None).ConfigureAwait(false);
+
+                try
+                {
+                    await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
+
+                    _data.LastAuthorizationsRefresh = DateTime.UtcNow;
+                    CacheData();
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing authorization", ex);
+                }
+                finally
+                {
+                    _operationLock.Release();
+                }
+            }
+
+            return _data.PendingAuthorizations.Select(i => new ConnectAuthorization
+            {
+                ConnectUserId = i.ConnectUserId,
+                EnableLiveTv = i.EnableLiveTv,
+                EnabledChannels = i.EnabledChannels,
+                EnabledLibraries = i.EnabledLibraries,
+                Id = i.Id,
+                ImageUrl = i.ImageUrl,
+                UserName = i.UserName
+
+            }).ToList();
+        }
+
+        public async Task CancelAuthorization(string id)
+        {
+            await _operationLock.WaitAsync().ConfigureAwait(false);
+
+            try
+            {
+                await CancelAuthorizationInternal(id).ConfigureAwait(false);
+            }
+            finally
+            {
+                _operationLock.Release();
+            }
+        }
+
+        private async Task CancelAuthorizationInternal(string id)
+        {
+            var connectUserId = _data.PendingAuthorizations
+                .First(i => string.Equals(i.Id, id, StringComparison.Ordinal))
+                .ConnectUserId;
+
+            await CancelAuthorizationByConnectUserId(connectUserId).ConfigureAwait(false);
+
+            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        private async Task CancelAuthorizationByConnectUserId(string connectUserId)
+        {
+            if (string.IsNullOrWhiteSpace(connectUserId))
+            {
+                throw new ArgumentNullException("connectUserId");
+            }
+            if (string.IsNullOrWhiteSpace(ConnectServerId))
+            {
+                throw new ArgumentNullException("ConnectServerId");
+            }
+
+            var url = GetConnectUrl("ServerAuthorizations");
+
+            var options = new HttpRequestOptions
+            {
+                Url = url,
+                CancellationToken = CancellationToken.None,
+                BufferContent = false
+            };
+
+            var postData = new Dictionary<string, string>
+                {
+                    {"serverId", ConnectServerId},
+                    {"userId", connectUserId}
+                };
+
+            options.SetPostData(postData);
+
+            SetServerAccessToken(options);
+            SetApplicationHeader(options);
+
+            try
+            {
+                // No need to examine the response
+                using (var stream = (await _httpClient.SendAsync(options, "DELETE").ConfigureAwait(false)).Content)
+                {
+                }
+            }
+            catch (HttpException ex)
+            {
+                // If connect says the auth doesn't exist, we can handle that gracefully since this is a remove operation
+
+                if (!ex.StatusCode.HasValue || ex.StatusCode.Value != HttpStatusCode.NotFound)
+                {
+                    throw;
+                }
+
+                _logger.Debug("Connect returned a 404 when removing a user auth link. Handling it.");
+            }
+        }
+
+        public async Task Authenticate(string username, string passwordMd5)
+        {
+            if (string.IsNullOrWhiteSpace(username))
+            {
+                throw new ArgumentNullException("username");
+            }
+
+            if (string.IsNullOrWhiteSpace(passwordMd5))
+            {
+                throw new ArgumentNullException("passwordMd5");
+            }
+
+            var options = new HttpRequestOptions
+            {
+                Url = GetConnectUrl("user/authenticate"),
+                BufferContent = false
+            };
+
+            options.SetPostData(new Dictionary<string, string>
+                {
+                    {"userName",username},
+                    {"password",passwordMd5}
+                });
+
+            SetApplicationHeader(options);
+
+            // No need to examine the response
+            using (var response = (await _httpClient.SendAsync(options, "POST").ConfigureAwait(false)).Content)
+            {
+            }
+        }
+
+        public async Task<User> GetLocalUser(string connectUserId)
+        {
+            var user = _userManager.Users
+                .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUserId, StringComparison.OrdinalIgnoreCase));
+
+            if (user == null)
+            {
+                await RefreshAuthorizations(CancellationToken.None).ConfigureAwait(false);
+            }
+
+            return _userManager.Users
+                .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUserId, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public User GetUserFromExchangeToken(string token)
+        {
+            if (string.IsNullOrWhiteSpace(token))
+            {
+                throw new ArgumentNullException("token");
+            }
+
+            return _userManager.Users.FirstOrDefault(u => string.Equals(token, u.ConnectAccessKey, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public bool IsAuthorizationTokenValid(string token)
+        {
+            if (string.IsNullOrWhiteSpace(token))
+            {
+                throw new ArgumentNullException("token");
+            }
+
+            return _userManager.Users.Any(u => string.Equals(token, u.ConnectAccessKey, StringComparison.OrdinalIgnoreCase)) ||
+                _data.PendingAuthorizations.Select(i => i.AccessToken).Contains(token, StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Connect/Responses.cs b/Emby.Server.Implementations/Connect/Responses.cs
new file mode 100644
index 000000000..87cb6cdf9
--- /dev/null
+++ b/Emby.Server.Implementations/Connect/Responses.cs
@@ -0,0 +1,85 @@
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Connect;
+
+namespace Emby.Server.Implementations.Connect
+{
+    public class ServerRegistrationResponse
+    {
+        public string Id { get; set; }
+        public string Url { get; set; }
+        public string Name { get; set; }
+        public string AccessKey { get; set; }
+    }
+
+    public class UpdateServerRegistrationResponse
+    {
+        public string Id { get; set; }
+        public string Url { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class GetConnectUserResponse
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string DisplayName { get; set; }
+        public string Email { get; set; }
+        public bool IsActive { get; set; }
+        public string ImageUrl { get; set; }
+    }
+
+    public class ServerUserAuthorizationResponse
+    {
+        public string Id { get; set; }
+        public string ServerId { get; set; }
+        public string UserId { get; set; }
+        public string AccessToken { get; set; }
+        public string DateCreated { get; set; }
+        public bool IsActive { get; set; }
+        public string AcceptStatus { get; set; }
+        public string UserType { get; set; }
+        public string UserImageUrl { get; set; }
+        public string UserName { get; set; }
+    }
+
+    public class ConnectUserPreferences
+    {
+        public string[] PreferredAudioLanguages { get; set; }
+        public bool PlayDefaultAudioTrack { get; set; }
+        public string[] PreferredSubtitleLanguages { get; set; }
+        public SubtitlePlaybackMode SubtitleMode { get; set; }
+        public bool GroupMoviesIntoBoxSets { get; set; }
+
+        public ConnectUserPreferences()
+        {
+            PreferredAudioLanguages = new string[] { };
+            PreferredSubtitleLanguages = new string[] { };
+        }
+
+        public static ConnectUserPreferences FromUserConfiguration(UserConfiguration config)
+        {
+            return new ConnectUserPreferences
+            {
+                PlayDefaultAudioTrack = config.PlayDefaultAudioTrack,
+                SubtitleMode = config.SubtitleMode,
+                PreferredAudioLanguages = string.IsNullOrWhiteSpace(config.AudioLanguagePreference) ? new string[] { } : new[] { config.AudioLanguagePreference },
+                PreferredSubtitleLanguages = string.IsNullOrWhiteSpace(config.SubtitleLanguagePreference) ? new string[] { } : new[] { config.SubtitleLanguagePreference }
+            };
+        }
+
+        public void MergeInto(UserConfiguration config)
+        {
+
+        }
+    }
+
+    public class UserPreferencesDto<T>
+    {
+        public T data { get; set; }
+    }
+
+    public class ConnectAuthorizationInternal : ConnectAuthorization
+    {
+        public string AccessToken { get; set; }
+    }
+}
diff --git a/Emby.Server.Implementations/Connect/Validator.cs b/Emby.Server.Implementations/Connect/Validator.cs
new file mode 100644
index 000000000..5c94fa71c
--- /dev/null
+++ b/Emby.Server.Implementations/Connect/Validator.cs
@@ -0,0 +1,29 @@
+using System.Text.RegularExpressions;
+
+namespace Emby.Server.Implementations.Connect
+{
+    public static class Validator
+    {
+        static readonly Regex ValidEmailRegex = CreateValidEmailRegex();
+
+        /// <summary>
+        /// Taken from http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx
+        /// </summary>
+        /// <returns></returns>
+        private static Regex CreateValidEmailRegex()
+        {
+            const string validEmailPattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|"
+                                             + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
+                                             + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
+
+            return new Regex(validEmailPattern, RegexOptions.IgnoreCase);
+        }
+
+        internal static bool EmailIsValid(string emailAddress)
+        {
+            bool isValid = ValidEmailRegex.IsMatch(emailAddress);
+
+            return isValid;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Emby.Server.Implementations.csproj b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
index 4a27ddb74..8d13d206a 100644
--- a/Emby.Server.Implementations/Emby.Server.Implementations.csproj
+++ b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
@@ -43,6 +43,11 @@
     <Compile Include="Channels\RefreshChannelsScheduledTask.cs" />
     <Compile Include="Collections\CollectionImageProvider.cs" />
     <Compile Include="Collections\CollectionManager.cs" />
+    <Compile Include="Connect\ConnectData.cs" />
+    <Compile Include="Connect\ConnectEntryPoint.cs" />
+    <Compile Include="Connect\ConnectManager.cs" />
+    <Compile Include="Connect\Responses.cs" />
+    <Compile Include="Connect\Validator.cs" />
     <Compile Include="Devices\DeviceManager.cs" />
     <Compile Include="Dto\DtoService.cs" />
     <Compile Include="EntryPoints\AutomaticRestartEntryPoint.cs" />
@@ -51,6 +56,7 @@
     <Compile Include="EntryPoints\RecordingNotifier.cs" />
     <Compile Include="EntryPoints\RefreshUsersMetadata.cs" />
     <Compile Include="EntryPoints\ServerEventNotifier.cs" />
+    <Compile Include="EntryPoints\UdpServerEntryPoint.cs" />
     <Compile Include="EntryPoints\UsageEntryPoint.cs" />
     <Compile Include="EntryPoints\UsageReporter.cs" />
     <Compile Include="EntryPoints\UserDataChangeNotifier.cs" />
@@ -68,6 +74,7 @@
     <Compile Include="HttpServer\StreamWriter.cs" />
     <Compile Include="Images\BaseDynamicImageProvider.cs" />
     <Compile Include="Intros\DefaultIntroProvider.cs" />
+    <Compile Include="IO\FileRefresher.cs" />
     <Compile Include="IO\ThrottledStream.cs" />
     <Compile Include="Library\CoreResolutionIgnoreRule.cs" />
     <Compile Include="Library\LibraryManager.cs" />
@@ -159,6 +166,7 @@
     <Compile Include="ScheduledTasks\RefreshIntrosTask.cs" />
     <Compile Include="ScheduledTasks\RefreshMediaLibraryTask.cs" />
     <Compile Include="ScheduledTasks\SystemUpdateTask.cs" />
+    <Compile Include="Security\EncryptionManager.cs" />
     <Compile Include="Security\MBLicenseFile.cs" />
     <Compile Include="Security\PluginSecurityManager.cs" />
     <Compile Include="Security\RegRecord.cs" />
@@ -217,6 +225,7 @@
     <Compile Include="Sync\TargetDataProvider.cs" />
     <Compile Include="TV\SeriesPostScanTask.cs" />
     <Compile Include="TV\TVSeriesManager.cs" />
+    <Compile Include="Udp\UdpServer.cs" />
     <Compile Include="Updates\InstallationManager.cs" />
     <Compile Include="UserViews\CollectionFolderImageProvider.cs" />
     <Compile Include="UserViews\DynamicImageProvider.cs" />
diff --git a/Emby.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs b/Emby.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
new file mode 100644
index 000000000..df5a7c985
--- /dev/null
+++ b/Emby.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
@@ -0,0 +1,85 @@
+using System;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using Emby.Server.Implementations.Udp;
+using MediaBrowser.Model.Net;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// Class UdpServerEntryPoint
+    /// </summary>
+    public class UdpServerEntryPoint : IServerEntryPoint
+    {
+        /// <summary>
+        /// Gets or sets the UDP server.
+        /// </summary>
+        /// <value>The UDP server.</value>
+        private UdpServer UdpServer { get; set; }
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+        private readonly ISocketFactory _socketFactory;
+        private readonly IServerApplicationHost _appHost;
+        private readonly IJsonSerializer _json;
+
+        public const int PortNumber = 7359;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class.
+        /// </summary>
+        public UdpServerEntryPoint(ILogger logger, IServerApplicationHost appHost, IJsonSerializer json, ISocketFactory socketFactory)
+        {
+            _logger = logger;
+            _appHost = appHost;
+            _json = json;
+            _socketFactory = socketFactory;
+        }
+
+        /// <summary>
+        /// Runs this instance.
+        /// </summary>
+        public void Run()
+        {
+            var udpServer = new UdpServer(_logger, _appHost, _json, _socketFactory);
+
+            try
+            {
+                udpServer.Start(PortNumber);
+
+                UdpServer = udpServer;
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Failed to start UDP Server", ex);
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                if (UdpServer != null)
+                {
+                    UdpServer.Dispose();
+                }
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/IO/FileRefresher.cs b/Emby.Server.Implementations/IO/FileRefresher.cs
new file mode 100644
index 000000000..295ecc465
--- /dev/null
+++ b/Emby.Server.Implementations/IO/FileRefresher.cs
@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Common.Events;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Extensions;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Tasks;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.IO
+{
+    public class FileRefresher : IDisposable
+    {
+        private ILogger Logger { get; set; }
+        private ITaskManager TaskManager { get; set; }
+        private ILibraryManager LibraryManager { get; set; }
+        private IServerConfigurationManager ConfigurationManager { get; set; }
+        private readonly IFileSystem _fileSystem;
+        private readonly List<string> _affectedPaths = new List<string>();
+        private ITimer _timer;
+        private readonly ITimerFactory _timerFactory;
+        private readonly object _timerLock = new object();
+        public string Path { get; private set; }
+
+        public event EventHandler<EventArgs> Completed;
+
+        public FileRefresher(string path, IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ITaskManager taskManager, ILogger logger, ITimerFactory timerFactory)
+        {
+            logger.Debug("New file refresher created for {0}", path);
+            Path = path;
+
+            _fileSystem = fileSystem;
+            ConfigurationManager = configurationManager;
+            LibraryManager = libraryManager;
+            TaskManager = taskManager;
+            Logger = logger;
+            _timerFactory = timerFactory;
+            AddPath(path);
+        }
+
+        private void AddAffectedPath(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            if (!_affectedPaths.Contains(path, StringComparer.Ordinal))
+            {
+                _affectedPaths.Add(path);
+            }
+        }
+
+        public void AddPath(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            lock (_timerLock)
+            {
+                AddAffectedPath(path);
+            }
+            RestartTimer();
+        }
+
+        public void RestartTimer()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            lock (_timerLock)
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+
+                if (_timer == null)
+                {
+                    _timer = _timerFactory.Create(OnTimerCallback, null, TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
+                }
+                else
+                {
+                    _timer.Change(TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
+                }
+            }
+        }
+
+        public void ResetPath(string path, string affectedFile)
+        {
+            lock (_timerLock)
+            {
+                Logger.Debug("Resetting file refresher from {0} to {1}", Path, path);
+
+                Path = path;
+                AddAffectedPath(path);
+
+                if (!string.IsNullOrWhiteSpace(affectedFile))
+                {
+                    AddAffectedPath(affectedFile);
+                }
+            }
+            RestartTimer();
+        }
+
+        private async void OnTimerCallback(object state)
+        {
+            List<string> paths;
+
+            lock (_timerLock)
+            {
+                paths = _affectedPaths.ToList();
+            }
+
+            // Extend the timer as long as any of the paths are still being written to.
+            if (paths.Any(IsFileLocked))
+            {
+                Logger.Info("Timer extended.");
+                RestartTimer();
+                return;
+            }
+
+            Logger.Debug("Timer stopped.");
+
+            DisposeTimer();
+            EventHelper.FireEventIfNotNull(Completed, this, EventArgs.Empty, Logger);
+
+            try
+            {
+                await ProcessPathChanges(paths.ToList()).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.ErrorException("Error processing directory changes", ex);
+            }
+        }
+
+        private async Task ProcessPathChanges(List<string> paths)
+        {
+            var itemsToRefresh = paths
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Select(GetAffectedBaseItem)
+                .Where(item => item != null)
+                .DistinctBy(i => i.Id)
+                .ToList();
+
+            foreach (var p in paths)
+            {
+                Logger.Info(p + " reports change.");
+            }
+
+            // If the root folder changed, run the library task so the user can see it
+            if (itemsToRefresh.Any(i => i is AggregateFolder))
+            {
+                LibraryManager.ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
+                return;
+            }
+
+            foreach (var item in itemsToRefresh)
+            {
+                Logger.Info(item.Name + " (" + item.Path + ") will be refreshed.");
+
+                try
+                {
+                    await item.ChangedExternally().ConfigureAwait(false);
+                }
+                catch (IOException ex)
+                {
+                    // For now swallow and log. 
+                    // Research item: If an IOException occurs, the item may be in a disconnected state (media unavailable)
+                    // Should we remove it from it's parent?
+                    Logger.ErrorException("Error refreshing {0}", ex, item.Name);
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error refreshing {0}", ex, item.Name);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the affected base item.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <returns>BaseItem.</returns>
+        private BaseItem GetAffectedBaseItem(string path)
+        {
+            BaseItem item = null;
+
+            while (item == null && !string.IsNullOrEmpty(path))
+            {
+                item = LibraryManager.FindByPath(path, null);
+
+                path = System.IO.Path.GetDirectoryName(path);
+            }
+
+            if (item != null)
+            {
+                // If the item has been deleted find the first valid parent that still exists
+                while (!_fileSystem.DirectoryExists(item.Path) && !_fileSystem.FileExists(item.Path))
+                {
+                    item = item.GetParent();
+
+                    if (item == null)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return item;
+        }
+
+        private bool IsFileLocked(string path)
+        {
+            //if (Environment.OSVersion.Platform != PlatformID.Win32NT)
+            //{
+            //    // Causing lockups on linux
+            //    return false;
+            //}
+
+            try
+            {
+                var data = _fileSystem.GetFileSystemInfo(path);
+
+                if (!data.Exists
+                    || data.IsDirectory
+
+                    // Opening a writable stream will fail with readonly files
+                    || data.IsReadOnly)
+                {
+                    return false;
+                }
+            }
+            catch (IOException)
+            {
+                return false;
+            }
+            catch (Exception ex)
+            {
+                Logger.ErrorException("Error getting file system info for: {0}", ex, path);
+                return false;
+            }
+
+            // In order to determine if the file is being written to, we have to request write access
+            // But if the server only has readonly access, this is going to cause this entire algorithm to fail
+            // So we'll take a best guess about our access level
+            var requestedFileAccess = ConfigurationManager.Configuration.SaveLocalMeta
+                ? FileAccessMode.ReadWrite
+                : FileAccessMode.Read;
+
+            try
+            {
+                using (_fileSystem.GetFileStream(path, FileOpenMode.Open, requestedFileAccess, FileShareMode.ReadWrite))
+                {
+                    //file is not locked
+                    return false;
+                }
+            }
+            //catch (DirectoryNotFoundException)
+            //{
+            //    // File may have been deleted
+            //    return false;
+            //}
+            catch (FileNotFoundException)
+            {
+                // File may have been deleted
+                return false;
+            }
+            catch (UnauthorizedAccessException)
+            {
+                Logger.Debug("No write permission for: {0}.", path);
+                return false;
+            }
+            catch (IOException)
+            {
+                //the file is unavailable because it is:
+                //still being written to
+                //or being processed by another thread
+                //or does not exist (has already been processed)
+                Logger.Debug("{0} is locked.", path);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.ErrorException("Error determining if file is locked: {0}", ex, path);
+                return false;
+            }
+        }
+
+        private void DisposeTimer()
+        {
+            lock (_timerLock)
+            {
+                if (_timer != null)
+                {
+                    _timer.Dispose();
+                    _timer = null;
+                }
+            }
+        }
+
+        private bool _disposed;
+        public void Dispose()
+        {
+            _disposed = true;
+            DisposeTimer();
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Security/EncryptionManager.cs b/Emby.Server.Implementations/Security/EncryptionManager.cs
new file mode 100644
index 000000000..271b0bbdb
--- /dev/null
+++ b/Emby.Server.Implementations/Security/EncryptionManager.cs
@@ -0,0 +1,51 @@
+using MediaBrowser.Controller.Security;
+using System;
+using System.Text;
+
+namespace Emby.Server.Implementations.Security
+{
+    public class EncryptionManager : IEncryptionManager
+    {
+        /// <summary>
+        /// Encrypts the string.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentNullException">value</exception>
+        public string EncryptString(string value)
+        {
+            if (value == null) throw new ArgumentNullException("value");
+
+            return EncryptStringUniversal(value);
+        }
+
+        /// <summary>
+        /// Decrypts the string.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentNullException">value</exception>
+        public string DecryptString(string value)
+        {
+            if (value == null) throw new ArgumentNullException("value");
+
+            return DecryptStringUniversal(value);
+        }
+
+        private string EncryptStringUniversal(string value)
+        {
+            // Yes, this isn't good, but ProtectedData in mono is throwing exceptions, so use this for now
+
+            var bytes = Encoding.UTF8.GetBytes(value);
+            return Convert.ToBase64String(bytes);
+        }
+
+        private string DecryptStringUniversal(string value)
+        {
+            // Yes, this isn't good, but ProtectedData in mono is throwing exceptions, so use this for now
+
+            var bytes = Convert.FromBase64String(value);
+            return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Udp/UdpServer.cs b/Emby.Server.Implementations/Udp/UdpServer.cs
new file mode 100644
index 000000000..c15e0ee41
--- /dev/null
+++ b/Emby.Server.Implementations/Udp/UdpServer.cs
@@ -0,0 +1,247 @@
+using MediaBrowser.Controller;
+using MediaBrowser.Model.ApiClient;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Events;
+using MediaBrowser.Model.Net;
+
+namespace Emby.Server.Implementations.Udp
+{
+    /// <summary>
+    /// Provides a Udp Server
+    /// </summary>
+    public class UdpServer : IDisposable
+    {
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        private bool _isDisposed;
+
+        private readonly List<Tuple<string, bool, Func<string, IpEndPointInfo, Encoding, Task>>> _responders = new List<Tuple<string, bool, Func<string, IpEndPointInfo, Encoding, Task>>>();
+
+        private readonly IServerApplicationHost _appHost;
+        private readonly IJsonSerializer _json;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UdpServer" /> class.
+        /// </summary>
+        public UdpServer(ILogger logger, IServerApplicationHost appHost, IJsonSerializer json, ISocketFactory socketFactory)
+        {
+            _logger = logger;
+            _appHost = appHost;
+            _json = json;
+            _socketFactory = socketFactory;
+
+            AddMessageResponder("who is EmbyServer?", true, RespondToV2Message);
+            AddMessageResponder("who is MediaBrowserServer_v2?", false, RespondToV2Message);
+        }
+
+        private void AddMessageResponder(string message, bool isSubstring, Func<string, IpEndPointInfo, Encoding, Task> responder)
+        {
+            _responders.Add(new Tuple<string, bool, Func<string, IpEndPointInfo, Encoding, Task>>(message, isSubstring, responder));
+        }
+
+        /// <summary>
+        /// Raises the <see cref="E:MessageReceived" /> event.
+        /// </summary>
+        private async void OnMessageReceived(GenericEventArgs<SocketReceiveResult> e)
+        {
+            var message = e.Argument;
+
+            var encoding = Encoding.UTF8;
+            var responder = GetResponder(message.Buffer, message.ReceivedBytes, encoding);
+
+            if (responder == null)
+            {
+                encoding = Encoding.Unicode;
+                responder = GetResponder(message.Buffer, message.ReceivedBytes, encoding);
+            }
+
+            if (responder != null)
+            {
+                try
+                {
+                    await responder.Item2.Item3(responder.Item1, message.RemoteEndPoint, encoding).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error in OnMessageReceived", ex);
+                }
+            }
+        }
+
+        private Tuple<string, Tuple<string, bool, Func<string, IpEndPointInfo, Encoding, Task>>> GetResponder(byte[] buffer, int bytesReceived, Encoding encoding)
+        {
+            var text = encoding.GetString(buffer, 0, bytesReceived);
+            var responder = _responders.FirstOrDefault(i =>
+            {
+                if (i.Item2)
+                {
+                    return text.IndexOf(i.Item1, StringComparison.OrdinalIgnoreCase) != -1;
+                }
+                return string.Equals(i.Item1, text, StringComparison.OrdinalIgnoreCase);
+            });
+
+            if (responder == null)
+            {
+                return null;
+            }
+            return new Tuple<string, Tuple<string, bool, Func<string, IpEndPointInfo, Encoding, Task>>>(text, responder);
+        }
+
+        private async Task RespondToV2Message(string messageText, IpEndPointInfo endpoint, Encoding encoding)
+        {
+            var parts = messageText.Split('|');
+
+            var localUrl = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
+
+            if (!string.IsNullOrEmpty(localUrl))
+            {
+                var response = new ServerDiscoveryInfo
+                {
+                    Address = localUrl,
+                    Id = _appHost.SystemId,
+                    Name = _appHost.FriendlyName
+                };
+
+                await SendAsync(encoding.GetBytes(_json.SerializeToString(response)), endpoint).ConfigureAwait(false);
+
+                if (parts.Length > 1)
+                {
+                    _appHost.EnableLoopback(parts[1]);
+                }
+            }
+            else
+            {
+                _logger.Warn("Unable to respond to udp request because the local ip address could not be determined.");
+            }
+        }
+
+        /// <summary>
+        /// The _udp client
+        /// </summary>
+        private IUdpSocket _udpClient;
+        private readonly ISocketFactory _socketFactory;
+
+        /// <summary>
+        /// Starts the specified port.
+        /// </summary>
+        /// <param name="port">The port.</param>
+        public void Start(int port)
+        {
+            _udpClient = _socketFactory.CreateUdpSocket(port);
+
+            Task.Run(() => StartListening());
+        }
+
+        private async void StartListening()
+        {
+            while (!_isDisposed)
+            {
+                try
+                {
+                    var result = await _udpClient.ReceiveAsync().ConfigureAwait(false);
+
+                    OnMessageReceived(result);
+                }
+                catch (ObjectDisposedException)
+                {
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error receiving udp message", ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Called when [message received].
+        /// </summary>
+        /// <param name="message">The message.</param>
+        private void OnMessageReceived(SocketReceiveResult message)
+        {
+            if (message.RemoteEndPoint.Port == 0)
+            {
+                return;
+            }
+
+            try
+            {
+                OnMessageReceived(new GenericEventArgs<SocketReceiveResult>
+                {
+                    Argument = message
+                });
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error handling UDP message", ex);
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Stops this instance.
+        /// </summary>
+        public void Stop()
+        {
+            _isDisposed = true;
+
+            if (_udpClient != null)
+            {
+                _udpClient.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                Stop();
+            }
+        }
+
+        public async Task SendAsync(byte[] bytes, IpEndPointInfo remoteEndPoint)
+        {
+            if (bytes == null)
+            {
+                throw new ArgumentNullException("bytes");
+            }
+
+            if (remoteEndPoint == null)
+            {
+                throw new ArgumentNullException("remoteEndPoint");
+            }
+
+            try
+            {
+                await _udpClient.SendAsync(bytes, bytes.Length, remoteEndPoint).ConfigureAwait(false);
+
+                _logger.Info("Udp message sent to {0}", remoteEndPoint);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error sending message to {0}", ex, remoteEndPoint);
+            }
+        }
+    }
+
+}
diff --git a/MediaBrowser.Common/Net/INetworkManager.cs b/MediaBrowser.Common/Net/INetworkManager.cs
index 0a565f670..fe60c7ebf 100644
--- a/MediaBrowser.Common/Net/INetworkManager.cs
+++ b/MediaBrowser.Common/Net/INetworkManager.cs
@@ -46,6 +46,10 @@ namespace MediaBrowser.Common.Net
         /// <returns><c>true</c> if [is in local network] [the specified endpoint]; otherwise, <c>false</c>.</returns>
         bool IsInLocalNetwork(string endpoint);
 
+        IpAddressInfo ParseIpAddress(string ipAddress);
+
+        bool TryParseIpAddress(string ipAddress, out IpAddressInfo ipAddressInfo);
+
         /// <summary>
         /// Generates a self signed certificate at the locatation specified by <paramref name="certificatePath"/>.
         /// </summary>
diff --git a/MediaBrowser.Model/MediaBrowser.Model.csproj b/MediaBrowser.Model/MediaBrowser.Model.csproj
index 03bbafe60..c85b215f2 100644
--- a/MediaBrowser.Model/MediaBrowser.Model.csproj
+++ b/MediaBrowser.Model/MediaBrowser.Model.csproj
@@ -140,7 +140,7 @@
     <Compile Include="Net\IpEndPointInfo.cs" />
     <Compile Include="Net\ISocketFactory.cs" />
     <Compile Include="Net\IUdpSocket.cs" />
-    <Compile Include="Net\ReceivedUdpData.cs" />
+    <Compile Include="Net\SocketReceiveResult.cs" />
     <Compile Include="TextEncoding\IEncoding.cs" />
     <Compile Include="Extensions\LinqExtensions.cs" />
     <Compile Include="FileOrganization\SmartMatchInfo.cs" />
diff --git a/MediaBrowser.Model/Net/ISocketFactory.cs b/MediaBrowser.Model/Net/ISocketFactory.cs
index c0e0440c2..3f1ddf84f 100644
--- a/MediaBrowser.Model/Net/ISocketFactory.cs
+++ b/MediaBrowser.Model/Net/ISocketFactory.cs
@@ -14,13 +14,18 @@ namespace MediaBrowser.Model.Net
 		/// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
 		IUdpSocket CreateUdpSocket(int localPort);
 
-		/// <summary>
-		/// Createa a new multicast socket using the specified multicast IP address, multicast time to live and local port.
-		/// </summary>
-		/// <param name="ipAddress">The multicast IP address to bind to.</param>
-		/// <param name="multicastTimeToLive">The multicast time to live value. Actually a maximum number of network hops for UDP packets.</param>
-		/// <param name="localPort">The local port to bind to.</param>
-		/// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
-		IUdpSocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort);
+        /// <summary>
+        /// Createa a new unicast socket using the specified local port number.
+        /// </summary>
+        IUdpSocket CreateSsdpUdpSocket(int localPort);
+
+        /// <summary>
+        /// Createa a new multicast socket using the specified multicast IP address, multicast time to live and local port.
+        /// </summary>
+        /// <param name="ipAddress">The multicast IP address to bind to.</param>
+        /// <param name="multicastTimeToLive">The multicast time to live value. Actually a maximum number of network hops for UDP packets.</param>
+        /// <param name="localPort">The local port to bind to.</param>
+        /// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
+        IUdpSocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort);
 	}
 }
diff --git a/MediaBrowser.Model/Net/IUdpSocket.cs b/MediaBrowser.Model/Net/IUdpSocket.cs
index cbeb8a995..ef090e010 100644
--- a/MediaBrowser.Model/Net/IUdpSocket.cs
+++ b/MediaBrowser.Model/Net/IUdpSocket.cs
@@ -15,13 +15,11 @@ namespace MediaBrowser.Model.Net
 		/// Waits for and returns the next UDP message sent to this socket (uni or multicast).
 		/// </summary>
 		/// <returns></returns>
-		Task<ReceivedUdpData> ReceiveAsync();
+		Task<SocketReceiveResult> ReceiveAsync();
 
         /// <summary>
         /// Sends a UDP message to a particular end point (uni or multicast).
         /// </summary>
-        /// <param name="messageData">The data to send.</param>
-        /// <param name="endPoint">The <see cref="IpEndPointInfo"/> providing the address and port to send to.</param>
-        Task SendTo(byte[] messageData, IpEndPointInfo endPoint);
+        Task SendAsync(byte[] buffer, int bytes, IpEndPointInfo endPoint);
 	}
 }
\ No newline at end of file
diff --git a/MediaBrowser.Model/Net/ReceivedUdpData.cs b/MediaBrowser.Model/Net/ReceivedUdpData.cs
deleted file mode 100644
index 1fdb22c93..000000000
--- a/MediaBrowser.Model/Net/ReceivedUdpData.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-
-namespace MediaBrowser.Model.Net
-{
-    /// <summary>
-    /// Used by the sockets wrapper to hold raw data received from a UDP socket.
-    /// </summary>
-    public sealed class ReceivedUdpData
-	{
-		/// <summary>
-		/// The buffer to place received data into.
-		/// </summary>
-		public byte[] Buffer { get; set; }
-
-		/// <summary>
-		/// The number of bytes received.
-		/// </summary>
-		public int ReceivedBytes { get; set; }
-
-        /// <summary>
-        /// The <see cref="IpEndPointInfo"/> the data was received from.
-        /// </summary>
-        public IpEndPointInfo ReceivedFrom { get; set; }
-	}
-}
diff --git a/MediaBrowser.Model/Net/SocketReceiveResult.cs b/MediaBrowser.Model/Net/SocketReceiveResult.cs
new file mode 100644
index 000000000..0a2d04ad3
--- /dev/null
+++ b/MediaBrowser.Model/Net/SocketReceiveResult.cs
@@ -0,0 +1,24 @@
+
+namespace MediaBrowser.Model.Net
+{
+    /// <summary>
+    /// Used by the sockets wrapper to hold raw data received from a UDP socket.
+    /// </summary>
+    public sealed class SocketReceiveResult
+	{
+		/// <summary>
+		/// The buffer to place received data into.
+		/// </summary>
+		public byte[] Buffer { get; set; }
+
+		/// <summary>
+		/// The number of bytes received.
+		/// </summary>
+		public int ReceivedBytes { get; set; }
+
+        /// <summary>
+        /// The <see cref="IpEndPointInfo"/> the data was received from.
+        /// </summary>
+        public IpEndPointInfo RemoteEndPoint { get; set; }
+	}
+}
diff --git a/MediaBrowser.Server.Implementations/Connect/ConnectData.cs b/MediaBrowser.Server.Implementations/Connect/ConnectData.cs
deleted file mode 100644
index 5ec0bea22..000000000
--- a/MediaBrowser.Server.Implementations/Connect/ConnectData.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace MediaBrowser.Server.Implementations.Connect
-{
-    public class ConnectData
-    {
-        /// <summary>
-        /// Gets or sets the server identifier.
-        /// </summary>
-        /// <value>The server identifier.</value>
-        public string ServerId { get; set; }
-        /// <summary>
-        /// Gets or sets the access key.
-        /// </summary>
-        /// <value>The access key.</value>
-        public string AccessKey { get; set; }
-
-        /// <summary>
-        /// Gets or sets the authorizations.
-        /// </summary>
-        /// <value>The authorizations.</value>
-        public List<ConnectAuthorizationInternal> PendingAuthorizations { get; set; }
-
-        /// <summary>
-        /// Gets or sets the last authorizations refresh.
-        /// </summary>
-        /// <value>The last authorizations refresh.</value>
-        public DateTime LastAuthorizationsRefresh { get; set; }
-
-        public ConnectData()
-        {
-            PendingAuthorizations = new List<ConnectAuthorizationInternal>();
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Connect/ConnectEntryPoint.cs b/MediaBrowser.Server.Implementations/Connect/ConnectEntryPoint.cs
deleted file mode 100644
index 565eeb259..000000000
--- a/MediaBrowser.Server.Implementations/Connect/ConnectEntryPoint.cs
+++ /dev/null
@@ -1,203 +0,0 @@
-using MediaBrowser.Common;
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Common.Net;
-using MediaBrowser.Controller.Connect;
-using MediaBrowser.Controller.Plugins;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Net;
-using System;
-using System.IO;
-using System.Net;
-using System.Net.Sockets;
-using System.Text;
-using System.Threading.Tasks;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Controller.IO;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Threading;
-
-namespace MediaBrowser.Server.Implementations.Connect
-{
-    public class ConnectEntryPoint : IServerEntryPoint
-    {
-        private ITimer _timer;
-        private readonly IHttpClient _httpClient;
-        private readonly IApplicationPaths _appPaths;
-        private readonly ILogger _logger;
-        private readonly IConnectManager _connectManager;
-
-        private readonly INetworkManager _networkManager;
-        private readonly IApplicationHost _appHost;
-        private readonly IFileSystem _fileSystem;
-        private readonly ITimerFactory _timerFactory;
-
-        public ConnectEntryPoint(IHttpClient httpClient, IApplicationPaths appPaths, ILogger logger, INetworkManager networkManager, IConnectManager connectManager, IApplicationHost appHost, IFileSystem fileSystem, ITimerFactory timerFactory)
-        {
-            _httpClient = httpClient;
-            _appPaths = appPaths;
-            _logger = logger;
-            _networkManager = networkManager;
-            _connectManager = connectManager;
-            _appHost = appHost;
-            _fileSystem = fileSystem;
-            _timerFactory = timerFactory;
-        }
-
-        public void Run()
-        {
-            LoadCachedAddress();
-
-            _timer = _timerFactory.Create(TimerCallback, null, TimeSpan.FromSeconds(5), TimeSpan.FromHours(1));
-            ((ConnectManager)_connectManager).Start();
-        }
-
-        private readonly string[] _ipLookups =
-        {
-            "http://bot.whatismyipaddress.com",
-            "https://connect.emby.media/service/ip"
-        };
-
-        private async void TimerCallback(object state)
-        {
-            IPAddress validIpAddress = null;
-
-            foreach (var ipLookupUrl in _ipLookups)
-            {
-                try
-                {
-                    validIpAddress = await GetIpAddress(ipLookupUrl).ConfigureAwait(false);
-
-                    // Try to find the ipv4 address, if present
-                    if (validIpAddress.AddressFamily == AddressFamily.InterNetwork)
-                    {
-                        break;
-                    }
-                }
-                catch (HttpException)
-                {
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error getting connection info", ex);
-                }
-            }
-
-            // If this produced an ipv6 address, try again
-            if (validIpAddress != null && validIpAddress.AddressFamily == AddressFamily.InterNetworkV6)
-            {
-                foreach (var ipLookupUrl in _ipLookups)
-                {
-                    try
-                    {
-                        var newAddress = await GetIpAddress(ipLookupUrl, true).ConfigureAwait(false);
-
-                        // Try to find the ipv4 address, if present
-                        if (newAddress.AddressFamily == AddressFamily.InterNetwork)
-                        {
-                            validIpAddress = newAddress;
-                            break;
-                        }
-                    }
-                    catch (HttpException)
-                    {
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.ErrorException("Error getting connection info", ex);
-                    }
-                }
-            }
-
-            if (validIpAddress != null)
-            {
-                ((ConnectManager)_connectManager).OnWanAddressResolved(validIpAddress);
-                CacheAddress(validIpAddress);
-            }
-        }
-
-        private async Task<IPAddress> GetIpAddress(string lookupUrl, bool preferIpv4 = false)
-        {
-            // Sometimes whatismyipaddress might fail, but it won't do us any good having users raise alarms over it.
-            var logErrors = false;
-
-#if DEBUG
-            logErrors = true;
-#endif
-            using (var stream = await _httpClient.Get(new HttpRequestOptions
-            {
-                Url = lookupUrl,
-                UserAgent = "Emby/" + _appHost.ApplicationVersion,
-                LogErrors = logErrors,
-
-                // Seeing block length errors with our server
-                EnableHttpCompression = false,
-                PreferIpv4 = preferIpv4,
-                BufferContent = false
-
-            }).ConfigureAwait(false))
-            {
-                using (var reader = new StreamReader(stream))
-                {
-                    var addressString = await reader.ReadToEndAsync().ConfigureAwait(false);
-
-                    return IPAddress.Parse(addressString);
-                }
-            }
-        }
-
-        private string CacheFilePath
-        {
-            get { return Path.Combine(_appPaths.DataPath, "wan.txt"); }
-        }
-
-        private void CacheAddress(IPAddress address)
-        {
-            var path = CacheFilePath;
-
-            try
-            {
-                _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
-                _fileSystem.WriteAllText(path, address.ToString(), Encoding.UTF8);
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error saving data", ex);
-            }
-        }
-
-        private void LoadCachedAddress()
-        {
-            var path = CacheFilePath;
-
-            _logger.Info("Loading data from {0}", path);
-
-            try
-            {
-                var endpoint = _fileSystem.ReadAllText(path, Encoding.UTF8);
-                IPAddress ipAddress;
-
-                if (IPAddress.TryParse(endpoint, out ipAddress))
-                {
-                    ((ConnectManager)_connectManager).OnWanAddressResolved(ipAddress);
-                }
-            }
-            catch (IOException)
-            {
-                // File isn't there. no biggie
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error loading data", ex);
-            }
-        }
-
-        public void Dispose()
-        {
-            if (_timer != null)
-            {
-                _timer.Dispose();
-                _timer = null;
-            }
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Connect/ConnectManager.cs b/MediaBrowser.Server.Implementations/Connect/ConnectManager.cs
deleted file mode 100644
index 27bbfbe82..000000000
--- a/MediaBrowser.Server.Implementations/Connect/ConnectManager.cs
+++ /dev/null
@@ -1,1192 +0,0 @@
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Common.Net;
-using MediaBrowser.Common.Security;
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Configuration;
-using MediaBrowser.Controller.Connect;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Controller.Providers;
-using MediaBrowser.Controller.Security;
-using MediaBrowser.Model.Connect;
-using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Net;
-using MediaBrowser.Model.Serialization;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Sockets;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Common.Extensions;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Controller.IO;
-
-namespace MediaBrowser.Server.Implementations.Connect
-{
-    public class ConnectManager : IConnectManager
-    {
-        private readonly SemaphoreSlim _operationLock = new SemaphoreSlim(1, 1);
-
-        private readonly ILogger _logger;
-        private readonly IApplicationPaths _appPaths;
-        private readonly IJsonSerializer _json;
-        private readonly IEncryptionManager _encryption;
-        private readonly IHttpClient _httpClient;
-        private readonly IServerApplicationHost _appHost;
-        private readonly IServerConfigurationManager _config;
-        private readonly IUserManager _userManager;
-        private readonly IProviderManager _providerManager;
-        private readonly ISecurityManager _securityManager;
-        private readonly IFileSystem _fileSystem;
-
-        private ConnectData _data = new ConnectData();
-
-        public string ConnectServerId
-        {
-            get { return _data.ServerId; }
-        }
-        public string ConnectAccessKey
-        {
-            get { return _data.AccessKey; }
-        }
-
-        private IPAddress DiscoveredWanIpAddress { get; set; }
-
-        public string WanIpAddress
-        {
-            get
-            {
-                var address = _config.Configuration.WanDdns;
-
-                if (!string.IsNullOrWhiteSpace(address))
-                {
-                    Uri newUri;
-
-                    if (Uri.TryCreate(address, UriKind.Absolute, out newUri))
-                    {
-                        address = newUri.Host;
-                    }
-                }
-
-                if (string.IsNullOrWhiteSpace(address) && DiscoveredWanIpAddress != null)
-                {
-                    if (DiscoveredWanIpAddress.AddressFamily == AddressFamily.InterNetworkV6)
-                    {
-                        address = "[" + DiscoveredWanIpAddress + "]";
-                    }
-                    else
-                    {
-                        address = DiscoveredWanIpAddress.ToString();
-                    }
-                }
-
-                return address;
-            }
-        }
-
-        public string WanApiAddress
-        {
-            get
-            {
-                var ip = WanIpAddress;
-
-                if (!string.IsNullOrEmpty(ip))
-                {
-                    if (!ip.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
-                        !ip.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
-                    {
-                        ip = (_appHost.EnableHttps ? "https://" : "http://") + ip;
-                    }
-
-                    ip += ":";
-                    ip += _appHost.EnableHttps ? _config.Configuration.PublicHttpsPort.ToString(CultureInfo.InvariantCulture) : _config.Configuration.PublicPort.ToString(CultureInfo.InvariantCulture);
-
-                    return ip;
-                }
-
-                return null;
-            }
-        }
-
-        private string XApplicationValue
-        {
-            get { return _appHost.Name + "/" + _appHost.ApplicationVersion; }
-        }
-
-        public ConnectManager(ILogger logger,
-            IApplicationPaths appPaths,
-            IJsonSerializer json,
-            IEncryptionManager encryption,
-            IHttpClient httpClient,
-            IServerApplicationHost appHost,
-            IServerConfigurationManager config, IUserManager userManager, IProviderManager providerManager, ISecurityManager securityManager, IFileSystem fileSystem)
-        {
-            _logger = logger;
-            _appPaths = appPaths;
-            _json = json;
-            _encryption = encryption;
-            _httpClient = httpClient;
-            _appHost = appHost;
-            _config = config;
-            _userManager = userManager;
-            _providerManager = providerManager;
-            _securityManager = securityManager;
-            _fileSystem = fileSystem;
-
-            LoadCachedData();
-        }
-
-        internal void Start()
-        {
-            _config.ConfigurationUpdated += _config_ConfigurationUpdated;
-        }
-
-        internal void OnWanAddressResolved(IPAddress address)
-        {
-            DiscoveredWanIpAddress = address;
-
-            var task = UpdateConnectInfo();
-        }
-
-        private async Task UpdateConnectInfo()
-        {
-            await _operationLock.WaitAsync().ConfigureAwait(false);
-
-            try
-            {
-                await UpdateConnectInfoInternal().ConfigureAwait(false);
-            }
-            finally
-            {
-                _operationLock.Release();
-            }
-        }
-
-        private async Task UpdateConnectInfoInternal()
-        {
-            var wanApiAddress = WanApiAddress;
-
-            if (string.IsNullOrWhiteSpace(wanApiAddress))
-            {
-                _logger.Warn("Cannot update Emby Connect information without a WanApiAddress");
-                return;
-            }
-
-            try
-            {
-                var localAddress = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
-
-                var hasExistingRecord = !string.IsNullOrWhiteSpace(ConnectServerId) &&
-                                  !string.IsNullOrWhiteSpace(ConnectAccessKey);
-
-                var createNewRegistration = !hasExistingRecord;
-
-                if (hasExistingRecord)
-                {
-                    try
-                    {
-                        await UpdateServerRegistration(wanApiAddress, localAddress).ConfigureAwait(false);
-                    }
-                    catch (HttpException ex)
-                    {
-                        if (!ex.StatusCode.HasValue || !new[] { HttpStatusCode.NotFound, HttpStatusCode.Unauthorized }.Contains(ex.StatusCode.Value))
-                        {
-                            throw;
-                        }
-
-                        createNewRegistration = true;
-                    }
-                }
-
-                if (createNewRegistration)
-                {
-                    await CreateServerRegistration(wanApiAddress, localAddress).ConfigureAwait(false);
-                }
-
-                _lastReportedIdentifier = GetConnectReportingIdentifier(localAddress, wanApiAddress);
-
-                await RefreshAuthorizationsInternal(true, CancellationToken.None).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error registering with Connect", ex);
-            }
-        }
-
-        private string _lastReportedIdentifier;
-        private async Task<string> GetConnectReportingIdentifier()
-        {
-            var url = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
-            return GetConnectReportingIdentifier(url, WanApiAddress);
-        }
-        private string GetConnectReportingIdentifier(string localAddress, string remoteAddress)
-        {
-            return (remoteAddress ?? string.Empty) + (localAddress ?? string.Empty);
-        }
-
-        async void _config_ConfigurationUpdated(object sender, EventArgs e)
-        {
-            // If info hasn't changed, don't report anything
-            var connectIdentifier = await GetConnectReportingIdentifier().ConfigureAwait(false);
-            if (string.Equals(_lastReportedIdentifier, connectIdentifier, StringComparison.OrdinalIgnoreCase))
-            {
-                return;
-            }
-
-            await UpdateConnectInfo().ConfigureAwait(false);
-        }
-
-        private async Task CreateServerRegistration(string wanApiAddress, string localAddress)
-        {
-            if (string.IsNullOrWhiteSpace(wanApiAddress))
-            {
-                throw new ArgumentNullException("wanApiAddress");
-            }
-
-            var url = "Servers";
-            url = GetConnectUrl(url);
-
-            var postData = new Dictionary<string, string>
-            {
-                {"name", _appHost.FriendlyName},
-                {"url", wanApiAddress},
-                {"systemId", _appHost.SystemId}
-            };
-
-            if (!string.IsNullOrWhiteSpace(localAddress))
-            {
-                postData["localAddress"] = localAddress;
-            }
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            options.SetPostData(postData);
-            SetApplicationHeader(options);
-
-            using (var response = await _httpClient.Post(options).ConfigureAwait(false))
-            {
-                var data = _json.DeserializeFromStream<ServerRegistrationResponse>(response.Content);
-
-                _data.ServerId = data.Id;
-                _data.AccessKey = data.AccessKey;
-
-                CacheData();
-            }
-        }
-
-        private async Task UpdateServerRegistration(string wanApiAddress, string localAddress)
-        {
-            if (string.IsNullOrWhiteSpace(wanApiAddress))
-            {
-                throw new ArgumentNullException("wanApiAddress");
-            }
-
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                throw new ArgumentNullException("ConnectServerId");
-            }
-
-            var url = "Servers";
-            url = GetConnectUrl(url);
-            url += "?id=" + ConnectServerId;
-
-            var postData = new Dictionary<string, string>
-            {
-                {"name", _appHost.FriendlyName},
-                {"url", wanApiAddress},
-                {"systemId", _appHost.SystemId}
-            };
-
-            if (!string.IsNullOrWhiteSpace(localAddress))
-            {
-                postData["localAddress"] = localAddress;
-            }
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            options.SetPostData(postData);
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            // No need to examine the response
-            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
-            {
-            }
-        }
-
-        private readonly object _dataFileLock = new object();
-        private string CacheFilePath
-        {
-            get { return Path.Combine(_appPaths.DataPath, "connect.txt"); }
-        }
-
-        private void CacheData()
-        {
-            var path = CacheFilePath;
-
-            try
-            {
-                _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
-
-                var json = _json.SerializeToString(_data);
-
-                var encrypted = _encryption.EncryptString(json);
-
-                lock (_dataFileLock)
-                {
-                    _fileSystem.WriteAllText(path, encrypted, Encoding.UTF8);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error saving data", ex);
-            }
-        }
-
-        private void LoadCachedData()
-        {
-            var path = CacheFilePath;
-
-            _logger.Info("Loading data from {0}", path);
-
-            try
-            {
-                lock (_dataFileLock)
-                {
-                    var encrypted = _fileSystem.ReadAllText(path, Encoding.UTF8);
-
-                    var json = _encryption.DecryptString(encrypted);
-
-                    _data = _json.DeserializeFromString<ConnectData>(json);
-                }
-            }
-            catch (IOException)
-            {
-                // File isn't there. no biggie
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error loading data", ex);
-            }
-        }
-
-        private User GetUser(string id)
-        {
-            var user = _userManager.GetUserById(id);
-
-            if (user == null)
-            {
-                throw new ArgumentException("User not found.");
-            }
-
-            return user;
-        }
-
-        private string GetConnectUrl(string handler)
-        {
-            return "https://connect.emby.media/service/" + handler;
-        }
-
-        public async Task<UserLinkResult> LinkUser(string userId, string connectUsername)
-        {
-            if (string.IsNullOrWhiteSpace(userId))
-            {
-                throw new ArgumentNullException("userId");
-            }
-            if (string.IsNullOrWhiteSpace(connectUsername))
-            {
-                throw new ArgumentNullException("connectUsername");
-            }
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                await UpdateConnectInfo().ConfigureAwait(false);
-            }
-
-            await _operationLock.WaitAsync().ConfigureAwait(false);
-
-            try
-            {
-                return await LinkUserInternal(userId, connectUsername).ConfigureAwait(false);
-            }
-            finally
-            {
-                _operationLock.Release();
-            }
-        }
-
-        private async Task<UserLinkResult> LinkUserInternal(string userId, string connectUsername)
-        {
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                throw new ArgumentNullException("ConnectServerId");
-            }
-
-            var connectUser = await GetConnectUser(new ConnectUserQuery
-            {
-                NameOrEmail = connectUsername
-
-            }, CancellationToken.None).ConfigureAwait(false);
-
-            if (!connectUser.IsActive)
-            {
-                throw new ArgumentException("The Emby account has been disabled.");
-            }
-
-            var existingUser = _userManager.Users.FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUser.Id) && !string.IsNullOrWhiteSpace(i.ConnectAccessKey));
-            if (existingUser != null)
-            {
-                throw new InvalidOperationException("This connect user is already linked to local user " + existingUser.Name);
-            }
-
-            var user = GetUser(userId);
-
-            if (!string.IsNullOrWhiteSpace(user.ConnectUserId))
-            {
-                await RemoveConnect(user, user.ConnectUserId).ConfigureAwait(false);
-            }
-
-            var url = GetConnectUrl("ServerAuthorizations");
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            var accessToken = Guid.NewGuid().ToString("N");
-
-            var postData = new Dictionary<string, string>
-            {
-                {"serverId", ConnectServerId},
-                {"userId", connectUser.Id},
-                {"userType", "Linked"},
-                {"accessToken", accessToken}
-            };
-
-            options.SetPostData(postData);
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            var result = new UserLinkResult();
-
-            // No need to examine the response
-            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
-            {
-                var response = _json.DeserializeFromStream<ServerUserAuthorizationResponse>(stream);
-
-                result.IsPending = string.Equals(response.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase);
-            }
-
-            user.ConnectAccessKey = accessToken;
-            user.ConnectUserName = connectUser.Name;
-            user.ConnectUserId = connectUser.Id;
-            user.ConnectLinkType = UserLinkType.LinkedUser;
-
-            await user.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
-
-            await _userManager.UpdateConfiguration(user.Id.ToString("N"), user.Configuration);
-
-            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
-
-            return result;
-        }
-
-        public async Task<UserLinkResult> InviteUser(ConnectAuthorizationRequest request)
-        {
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                await UpdateConnectInfo().ConfigureAwait(false);
-            }
-
-            await _operationLock.WaitAsync().ConfigureAwait(false);
-
-            try
-            {
-                return await InviteUserInternal(request).ConfigureAwait(false);
-            }
-            finally
-            {
-                _operationLock.Release();
-            }
-        }
-
-        private async Task<UserLinkResult> InviteUserInternal(ConnectAuthorizationRequest request)
-        {
-            var connectUsername = request.ConnectUserName;
-            var sendingUserId = request.SendingUserId;
-
-            if (string.IsNullOrWhiteSpace(connectUsername))
-            {
-                throw new ArgumentNullException("connectUsername");
-            }
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                throw new ArgumentNullException("ConnectServerId");
-            }
-
-            var sendingUser = GetUser(sendingUserId);
-            var requesterUserName = sendingUser.ConnectUserName;
-
-            if (string.IsNullOrWhiteSpace(requesterUserName))
-            {
-                throw new ArgumentException("A Connect account is required in order to send invitations.");
-            }
-
-            string connectUserId = null;
-            var result = new UserLinkResult();
-
-            try
-            {
-                var connectUser = await GetConnectUser(new ConnectUserQuery
-                {
-                    NameOrEmail = connectUsername
-
-                }, CancellationToken.None).ConfigureAwait(false);
-
-                if (!connectUser.IsActive)
-                {
-                    throw new ArgumentException("The Emby account is not active. Please ensure the account has been activated by following the instructions within the email confirmation.");
-                }
-
-                connectUserId = connectUser.Id;
-                result.GuestDisplayName = connectUser.Name;
-            }
-            catch (HttpException ex)
-            {
-                if (!ex.StatusCode.HasValue)
-                {
-                    throw;
-                }
-
-                // If they entered a username, then whatever the error is just throw it, for example, user not found
-                if (!Validator.EmailIsValid(connectUsername))
-                {
-                    if (ex.StatusCode.Value == HttpStatusCode.NotFound)
-                    {
-                        throw new ResourceNotFoundException();
-                    }
-                    throw;
-                }
-
-                if (ex.StatusCode.Value != HttpStatusCode.NotFound)
-                {
-                    throw;
-                }
-            }
-
-            if (string.IsNullOrWhiteSpace(connectUserId))
-            {
-                return await SendNewUserInvitation(requesterUserName, connectUsername).ConfigureAwait(false);
-            }
-
-            var url = GetConnectUrl("ServerAuthorizations");
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            var accessToken = Guid.NewGuid().ToString("N");
-
-            var postData = new Dictionary<string, string>
-            {
-                {"serverId", ConnectServerId},
-                {"userId", connectUserId},
-                {"userType", "Guest"},
-                {"accessToken", accessToken},
-                {"requesterUserName", requesterUserName}
-            };
-
-            options.SetPostData(postData);
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            // No need to examine the response
-            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
-            {
-                var response = _json.DeserializeFromStream<ServerUserAuthorizationResponse>(stream);
-
-                result.IsPending = string.Equals(response.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase);
-
-                _data.PendingAuthorizations.Add(new ConnectAuthorizationInternal
-                {
-                    ConnectUserId = response.UserId,
-                    Id = response.Id,
-                    ImageUrl = response.UserImageUrl,
-                    UserName = response.UserName,
-                    EnabledLibraries = request.EnabledLibraries,
-                    EnabledChannels = request.EnabledChannels,
-                    EnableLiveTv = request.EnableLiveTv,
-                    AccessToken = accessToken
-                });
-
-                CacheData();
-            }
-
-            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
-
-            return result;
-        }
-
-        private async Task<UserLinkResult> SendNewUserInvitation(string fromName, string email)
-        {
-            var url = GetConnectUrl("users/invite");
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            var postData = new Dictionary<string, string>
-            {
-                {"email", email},
-                {"requesterUserName", fromName}
-            };
-
-            options.SetPostData(postData);
-            SetApplicationHeader(options);
-
-            // No need to examine the response
-            using (var stream = (await _httpClient.Post(options).ConfigureAwait(false)).Content)
-            {
-            }
-
-            return new UserLinkResult
-            {
-                IsNewUserInvitation = true,
-                GuestDisplayName = email
-            };
-        }
-
-        public Task RemoveConnect(string userId)
-        {
-            var user = GetUser(userId);
-
-            return RemoveConnect(user, user.ConnectUserId);
-        }
-
-        private async Task RemoveConnect(User user, string connectUserId)
-        {
-            if (!string.IsNullOrWhiteSpace(connectUserId))
-            {
-                await CancelAuthorizationByConnectUserId(connectUserId).ConfigureAwait(false);
-            }
-
-            user.ConnectAccessKey = null;
-            user.ConnectUserName = null;
-            user.ConnectUserId = null;
-            user.ConnectLinkType = null;
-
-            await user.UpdateToRepository(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
-        }
-
-        private async Task<ConnectUser> GetConnectUser(ConnectUserQuery query, CancellationToken cancellationToken)
-        {
-            var url = GetConnectUrl("user");
-
-            if (!string.IsNullOrWhiteSpace(query.Id))
-            {
-                url = url + "?id=" + WebUtility.UrlEncode(query.Id);
-            }
-            else if (!string.IsNullOrWhiteSpace(query.NameOrEmail))
-            {
-                url = url + "?nameOrEmail=" + WebUtility.UrlEncode(query.NameOrEmail);
-            }
-            else if (!string.IsNullOrWhiteSpace(query.Name))
-            {
-                url = url + "?name=" + WebUtility.UrlEncode(query.Name);
-            }
-            else if (!string.IsNullOrWhiteSpace(query.Email))
-            {
-                url = url + "?name=" + WebUtility.UrlEncode(query.Email);
-            }
-            else
-            {
-                throw new ArgumentException("Empty ConnectUserQuery supplied");
-            }
-
-            var options = new HttpRequestOptions
-            {
-                CancellationToken = cancellationToken,
-                Url = url,
-                BufferContent = false
-            };
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            using (var stream = await _httpClient.Get(options).ConfigureAwait(false))
-            {
-                var response = _json.DeserializeFromStream<GetConnectUserResponse>(stream);
-
-                return new ConnectUser
-                {
-                    Email = response.Email,
-                    Id = response.Id,
-                    Name = response.Name,
-                    IsActive = response.IsActive,
-                    ImageUrl = response.ImageUrl
-                };
-            }
-        }
-
-        private void SetApplicationHeader(HttpRequestOptions options)
-        {
-            options.RequestHeaders.Add("X-Application", XApplicationValue);
-        }
-
-        private void SetServerAccessToken(HttpRequestOptions options)
-        {
-            if (string.IsNullOrWhiteSpace(ConnectAccessKey))
-            {
-                throw new ArgumentNullException("ConnectAccessKey");
-            }
-
-            options.RequestHeaders.Add("X-Connect-Token", ConnectAccessKey);
-        }
-
-        public async Task RefreshAuthorizations(CancellationToken cancellationToken)
-        {
-            await _operationLock.WaitAsync(cancellationToken).ConfigureAwait(false);
-
-            try
-            {
-                await RefreshAuthorizationsInternal(true, cancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                _operationLock.Release();
-            }
-        }
-
-        private async Task RefreshAuthorizationsInternal(bool refreshImages, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                throw new ArgumentNullException("ConnectServerId");
-            }
-
-            var url = GetConnectUrl("ServerAuthorizations");
-
-            url += "?serverId=" + ConnectServerId;
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = cancellationToken,
-                BufferContent = false
-            };
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            try
-            {
-                using (var stream = (await _httpClient.SendAsync(options, "GET").ConfigureAwait(false)).Content)
-                {
-                    var list = _json.DeserializeFromStream<List<ServerUserAuthorizationResponse>>(stream);
-
-                    await RefreshAuthorizations(list, refreshImages).ConfigureAwait(false);
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error refreshing server authorizations.", ex);
-            }
-        }
-
-        private readonly SemaphoreSlim _connectImageSemaphore = new SemaphoreSlim(5, 5);
-        private async Task RefreshAuthorizations(List<ServerUserAuthorizationResponse> list, bool refreshImages)
-        {
-            var users = _userManager.Users.ToList();
-
-            // Handle existing authorizations that were removed by the Connect server
-            // Handle existing authorizations whose status may have been updated
-            foreach (var user in users)
-            {
-                if (!string.IsNullOrWhiteSpace(user.ConnectUserId))
-                {
-                    var connectEntry = list.FirstOrDefault(i => string.Equals(i.UserId, user.ConnectUserId, StringComparison.OrdinalIgnoreCase));
-
-                    if (connectEntry == null)
-                    {
-                        var deleteUser = user.ConnectLinkType.HasValue &&
-                                         user.ConnectLinkType.Value == UserLinkType.Guest;
-
-                        user.ConnectUserId = null;
-                        user.ConnectAccessKey = null;
-                        user.ConnectUserName = null;
-                        user.ConnectLinkType = null;
-
-                        await _userManager.UpdateUser(user).ConfigureAwait(false);
-
-                        if (deleteUser)
-                        {
-                            _logger.Debug("Deleting guest user {0}", user.Name);
-                            await _userManager.DeleteUser(user).ConfigureAwait(false);
-                        }
-                    }
-                    else
-                    {
-                        var changed = !string.Equals(user.ConnectAccessKey, connectEntry.AccessToken, StringComparison.OrdinalIgnoreCase);
-
-                        if (changed)
-                        {
-                            user.ConnectUserId = connectEntry.UserId;
-                            user.ConnectAccessKey = connectEntry.AccessToken;
-
-                            await _userManager.UpdateUser(user).ConfigureAwait(false);
-                        }
-                    }
-                }
-            }
-
-            var currentPendingList = _data.PendingAuthorizations.ToList();
-            var newPendingList = new List<ConnectAuthorizationInternal>();
-
-            foreach (var connectEntry in list)
-            {
-                if (string.Equals(connectEntry.UserType, "guest", StringComparison.OrdinalIgnoreCase))
-                {
-                    var currentPendingEntry = currentPendingList.FirstOrDefault(i => string.Equals(i.Id, connectEntry.Id, StringComparison.OrdinalIgnoreCase));
-
-                    if (string.Equals(connectEntry.AcceptStatus, "accepted", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var user = _userManager.Users
-                            .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectEntry.UserId, StringComparison.OrdinalIgnoreCase));
-
-                        if (user == null)
-                        {
-                            // Add user
-                            user = await _userManager.CreateUser(_userManager.MakeValidUsername(connectEntry.UserName)).ConfigureAwait(false);
-
-                            user.ConnectUserName = connectEntry.UserName;
-                            user.ConnectUserId = connectEntry.UserId;
-                            user.ConnectLinkType = UserLinkType.Guest;
-                            user.ConnectAccessKey = connectEntry.AccessToken;
-
-                            await _userManager.UpdateUser(user).ConfigureAwait(false);
-
-                            user.Policy.IsHidden = true;
-                            user.Policy.EnableLiveTvManagement = false;
-                            user.Policy.EnableContentDeletion = false;
-                            user.Policy.EnableRemoteControlOfOtherUsers = false;
-                            user.Policy.EnableSharedDeviceControl = false;
-                            user.Policy.IsAdministrator = false;
-
-                            if (currentPendingEntry != null)
-                            {
-                                user.Policy.EnabledFolders = currentPendingEntry.EnabledLibraries;
-                                user.Policy.EnableAllFolders = false;
-
-                                user.Policy.EnabledChannels = currentPendingEntry.EnabledChannels;
-                                user.Policy.EnableAllChannels = false;
-
-                                user.Policy.EnableLiveTvAccess = currentPendingEntry.EnableLiveTv;
-                            }
-
-                            await _userManager.UpdateConfiguration(user.Id.ToString("N"), user.Configuration);
-                        }
-                    }
-                    else if (string.Equals(connectEntry.AcceptStatus, "waiting", StringComparison.OrdinalIgnoreCase))
-                    {
-                        currentPendingEntry = currentPendingEntry ?? new ConnectAuthorizationInternal();
-
-                        currentPendingEntry.ConnectUserId = connectEntry.UserId;
-                        currentPendingEntry.ImageUrl = connectEntry.UserImageUrl;
-                        currentPendingEntry.UserName = connectEntry.UserName;
-                        currentPendingEntry.Id = connectEntry.Id;
-                        currentPendingEntry.AccessToken = connectEntry.AccessToken;
-
-                        newPendingList.Add(currentPendingEntry);
-                    }
-                }
-            }
-
-            _data.PendingAuthorizations = newPendingList;
-            CacheData();
-
-            await RefreshGuestNames(list, refreshImages).ConfigureAwait(false);
-        }
-
-        private async Task RefreshGuestNames(List<ServerUserAuthorizationResponse> list, bool refreshImages)
-        {
-            var users = _userManager.Users
-                .Where(i => !string.IsNullOrEmpty(i.ConnectUserId) && i.ConnectLinkType.HasValue && i.ConnectLinkType.Value == UserLinkType.Guest)
-                    .ToList();
-
-            foreach (var user in users)
-            {
-                var authorization = list.FirstOrDefault(i => string.Equals(i.UserId, user.ConnectUserId, StringComparison.Ordinal));
-
-                if (authorization == null)
-                {
-                    _logger.Warn("Unable to find connect authorization record for user {0}", user.Name);
-                    continue;
-                }
-
-                var syncConnectName = true;
-                var syncConnectImage = true;
-
-                if (syncConnectName)
-                {
-                    var changed = !string.Equals(authorization.UserName, user.Name, StringComparison.OrdinalIgnoreCase);
-
-                    if (changed)
-                    {
-                        await user.Rename(authorization.UserName).ConfigureAwait(false);
-                    }
-                }
-
-                if (syncConnectImage)
-                {
-                    var imageUrl = authorization.UserImageUrl;
-
-                    if (!string.IsNullOrWhiteSpace(imageUrl))
-                    {
-                        var changed = false;
-
-                        if (!user.HasImage(ImageType.Primary))
-                        {
-                            changed = true;
-                        }
-                        else if (refreshImages)
-                        {
-                            using (var response = await _httpClient.SendAsync(new HttpRequestOptions
-                            {
-                                Url = imageUrl,
-                                BufferContent = false
-
-                            }, "HEAD").ConfigureAwait(false))
-                            {
-                                var length = response.ContentLength;
-
-                                if (length != _fileSystem.GetFileInfo(user.GetImageInfo(ImageType.Primary, 0).Path).Length)
-                                {
-                                    changed = true;
-                                }
-                            }
-                        }
-
-                        if (changed)
-                        {
-                            await _providerManager.SaveImage(user, imageUrl, _connectImageSemaphore, ImageType.Primary, null, CancellationToken.None).ConfigureAwait(false);
-
-                            await user.RefreshMetadata(new MetadataRefreshOptions(_fileSystem)
-                            {
-                                ForceSave = true,
-
-                            }, CancellationToken.None).ConfigureAwait(false);
-                        }
-                    }
-                }
-            }
-        }
-
-        public async Task<List<ConnectAuthorization>> GetPendingGuests()
-        {
-            var time = DateTime.UtcNow - _data.LastAuthorizationsRefresh;
-
-            if (time.TotalMinutes >= 5)
-            {
-                await _operationLock.WaitAsync(CancellationToken.None).ConfigureAwait(false);
-
-                try
-                {
-                    await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
-
-                    _data.LastAuthorizationsRefresh = DateTime.UtcNow;
-                    CacheData();
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error refreshing authorization", ex);
-                }
-                finally
-                {
-                    _operationLock.Release();
-                }
-            }
-
-            return _data.PendingAuthorizations.Select(i => new ConnectAuthorization
-            {
-                ConnectUserId = i.ConnectUserId,
-                EnableLiveTv = i.EnableLiveTv,
-                EnabledChannels = i.EnabledChannels,
-                EnabledLibraries = i.EnabledLibraries,
-                Id = i.Id,
-                ImageUrl = i.ImageUrl,
-                UserName = i.UserName
-
-            }).ToList();
-        }
-
-        public async Task CancelAuthorization(string id)
-        {
-            await _operationLock.WaitAsync().ConfigureAwait(false);
-
-            try
-            {
-                await CancelAuthorizationInternal(id).ConfigureAwait(false);
-            }
-            finally
-            {
-                _operationLock.Release();
-            }
-        }
-
-        private async Task CancelAuthorizationInternal(string id)
-        {
-            var connectUserId = _data.PendingAuthorizations
-                .First(i => string.Equals(i.Id, id, StringComparison.Ordinal))
-                .ConnectUserId;
-
-            await CancelAuthorizationByConnectUserId(connectUserId).ConfigureAwait(false);
-
-            await RefreshAuthorizationsInternal(false, CancellationToken.None).ConfigureAwait(false);
-        }
-
-        private async Task CancelAuthorizationByConnectUserId(string connectUserId)
-        {
-            if (string.IsNullOrWhiteSpace(connectUserId))
-            {
-                throw new ArgumentNullException("connectUserId");
-            }
-            if (string.IsNullOrWhiteSpace(ConnectServerId))
-            {
-                throw new ArgumentNullException("ConnectServerId");
-            }
-
-            var url = GetConnectUrl("ServerAuthorizations");
-
-            var options = new HttpRequestOptions
-            {
-                Url = url,
-                CancellationToken = CancellationToken.None,
-                BufferContent = false
-            };
-
-            var postData = new Dictionary<string, string>
-                {
-                    {"serverId", ConnectServerId},
-                    {"userId", connectUserId}
-                };
-
-            options.SetPostData(postData);
-
-            SetServerAccessToken(options);
-            SetApplicationHeader(options);
-
-            try
-            {
-                // No need to examine the response
-                using (var stream = (await _httpClient.SendAsync(options, "DELETE").ConfigureAwait(false)).Content)
-                {
-                }
-            }
-            catch (HttpException ex)
-            {
-                // If connect says the auth doesn't exist, we can handle that gracefully since this is a remove operation
-
-                if (!ex.StatusCode.HasValue || ex.StatusCode.Value != HttpStatusCode.NotFound)
-                {
-                    throw;
-                }
-
-                _logger.Debug("Connect returned a 404 when removing a user auth link. Handling it.");
-            }
-        }
-
-        public async Task Authenticate(string username, string passwordMd5)
-        {
-            if (string.IsNullOrWhiteSpace(username))
-            {
-                throw new ArgumentNullException("username");
-            }
-
-            if (string.IsNullOrWhiteSpace(passwordMd5))
-            {
-                throw new ArgumentNullException("passwordMd5");
-            }
-
-            var options = new HttpRequestOptions
-            {
-                Url = GetConnectUrl("user/authenticate"),
-                BufferContent = false
-            };
-
-            options.SetPostData(new Dictionary<string, string>
-                {
-                    {"userName",username},
-                    {"password",passwordMd5}
-                });
-
-            SetApplicationHeader(options);
-
-            // No need to examine the response
-            using (var response = (await _httpClient.SendAsync(options, "POST").ConfigureAwait(false)).Content)
-            {
-            }
-        }
-
-        public async Task<User> GetLocalUser(string connectUserId)
-        {
-            var user = _userManager.Users
-                .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUserId, StringComparison.OrdinalIgnoreCase));
-
-            if (user == null)
-            {
-                await RefreshAuthorizations(CancellationToken.None).ConfigureAwait(false);
-            }
-
-            return _userManager.Users
-                .FirstOrDefault(i => string.Equals(i.ConnectUserId, connectUserId, StringComparison.OrdinalIgnoreCase));
-        }
-
-        public User GetUserFromExchangeToken(string token)
-        {
-            if (string.IsNullOrWhiteSpace(token))
-            {
-                throw new ArgumentNullException("token");
-            }
-
-            return _userManager.Users.FirstOrDefault(u => string.Equals(token, u.ConnectAccessKey, StringComparison.OrdinalIgnoreCase));
-        }
-
-        public bool IsAuthorizationTokenValid(string token)
-        {
-            if (string.IsNullOrWhiteSpace(token))
-            {
-                throw new ArgumentNullException("token");
-            }
-
-            return _userManager.Users.Any(u => string.Equals(token, u.ConnectAccessKey, StringComparison.OrdinalIgnoreCase)) ||
-                _data.PendingAuthorizations.Select(i => i.AccessToken).Contains(token, StringComparer.OrdinalIgnoreCase);
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Connect/Responses.cs b/MediaBrowser.Server.Implementations/Connect/Responses.cs
deleted file mode 100644
index f86527829..000000000
--- a/MediaBrowser.Server.Implementations/Connect/Responses.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using MediaBrowser.Model.Configuration;
-using MediaBrowser.Model.Connect;
-
-namespace MediaBrowser.Server.Implementations.Connect
-{
-    public class ServerRegistrationResponse
-    {
-        public string Id { get; set; }
-        public string Url { get; set; }
-        public string Name { get; set; }
-        public string AccessKey { get; set; }
-    }
-
-    public class UpdateServerRegistrationResponse
-    {
-        public string Id { get; set; }
-        public string Url { get; set; }
-        public string Name { get; set; }
-    }
-
-    public class GetConnectUserResponse
-    {
-        public string Id { get; set; }
-        public string Name { get; set; }
-        public string DisplayName { get; set; }
-        public string Email { get; set; }
-        public bool IsActive { get; set; }
-        public string ImageUrl { get; set; }
-    }
-
-    public class ServerUserAuthorizationResponse
-    {
-        public string Id { get; set; }
-        public string ServerId { get; set; }
-        public string UserId { get; set; }
-        public string AccessToken { get; set; }
-        public string DateCreated { get; set; }
-        public bool IsActive { get; set; }
-        public string AcceptStatus { get; set; }
-        public string UserType { get; set; }
-        public string UserImageUrl { get; set; }
-        public string UserName { get; set; }
-    }
-
-    public class ConnectUserPreferences
-    {
-        public string[] PreferredAudioLanguages { get; set; }
-        public bool PlayDefaultAudioTrack { get; set; }
-        public string[] PreferredSubtitleLanguages { get; set; }
-        public SubtitlePlaybackMode SubtitleMode { get; set; }
-        public bool GroupMoviesIntoBoxSets { get; set; }
-
-        public ConnectUserPreferences()
-        {
-            PreferredAudioLanguages = new string[] { };
-            PreferredSubtitleLanguages = new string[] { };
-        }
-
-        public static ConnectUserPreferences FromUserConfiguration(UserConfiguration config)
-        {
-            return new ConnectUserPreferences
-            {
-                PlayDefaultAudioTrack = config.PlayDefaultAudioTrack,
-                SubtitleMode = config.SubtitleMode,
-                PreferredAudioLanguages = string.IsNullOrWhiteSpace(config.AudioLanguagePreference) ? new string[] { } : new[] { config.AudioLanguagePreference },
-                PreferredSubtitleLanguages = string.IsNullOrWhiteSpace(config.SubtitleLanguagePreference) ? new string[] { } : new[] { config.SubtitleLanguagePreference }
-            };
-        }
-
-        public void MergeInto(UserConfiguration config)
-        {
-
-        }
-    }
-
-    public class UserPreferencesDto<T>
-    {
-        public T data { get; set; }
-    }
-
-    public class ConnectAuthorizationInternal : ConnectAuthorization
-    {
-        public string AccessToken { get; set; }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Connect/Validator.cs b/MediaBrowser.Server.Implementations/Connect/Validator.cs
deleted file mode 100644
index 8cdfc4a6b..000000000
--- a/MediaBrowser.Server.Implementations/Connect/Validator.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System.Text.RegularExpressions;
-
-namespace MediaBrowser.Server.Implementations.Connect
-{
-    public static class Validator
-    {
-        static readonly Regex ValidEmailRegex = CreateValidEmailRegex();
-
-        /// <summary>
-        /// Taken from http://haacked.com/archive/2007/08/21/i-knew-how-to-validate-an-email-address-until-i.aspx
-        /// </summary>
-        /// <returns></returns>
-        private static Regex CreateValidEmailRegex()
-        {
-            const string validEmailPattern = @"^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|"
-                                             + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)"
-                                             + @"@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$";
-
-            return new Regex(validEmailPattern, RegexOptions.IgnoreCase);
-        }
-
-        internal static bool EmailIsValid(string emailAddress)
-        {
-            bool isValid = ValidEmailRegex.IsMatch(emailAddress);
-
-            return isValid;
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs b/MediaBrowser.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
deleted file mode 100644
index 1febcdd40..000000000
--- a/MediaBrowser.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-using System;
-using MediaBrowser.Common.Net;
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Plugins;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Serialization;
-using MediaBrowser.Server.Implementations.Udp;
-
-namespace MediaBrowser.Server.Implementations.EntryPoints
-{
-    /// <summary>
-    /// Class UdpServerEntryPoint
-    /// </summary>
-    public class UdpServerEntryPoint : IServerEntryPoint
-    {
-        /// <summary>
-        /// Gets or sets the UDP server.
-        /// </summary>
-        /// <value>The UDP server.</value>
-        private UdpServer UdpServer { get; set; }
-
-        /// <summary>
-        /// The _logger
-        /// </summary>
-        private readonly ILogger _logger;
-        /// <summary>
-        /// The _network manager
-        /// </summary>
-        private readonly INetworkManager _networkManager;
-        private readonly IServerApplicationHost _appHost;
-        private readonly IJsonSerializer _json;
-
-        public const int PortNumber = 7359;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="networkManager">The network manager.</param>
-        /// <param name="appHost">The application host.</param>
-        /// <param name="json">The json.</param>
-        public UdpServerEntryPoint(ILogger logger, INetworkManager networkManager, IServerApplicationHost appHost, IJsonSerializer json)
-        {
-            _logger = logger;
-            _networkManager = networkManager;
-            _appHost = appHost;
-            _json = json;
-        }
-
-        /// <summary>
-        /// Runs this instance.
-        /// </summary>
-        public void Run()
-        {
-            var udpServer = new UdpServer(_logger, _networkManager, _appHost, _json);
-
-            try
-            {
-                udpServer.Start(PortNumber);
-
-                UdpServer = udpServer;
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Failed to start UDP Server", ex);
-            }
-        }
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool dispose)
-        {
-            if (dispose)
-            {
-                if (UdpServer != null)
-                {
-                    UdpServer.Dispose();
-                }
-            }
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
index 20d89d2eb..561934854 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
@@ -1,13 +1,13 @@
 using System.Collections.Specialized;
 using MediaBrowser.Controller.Net;
 using MediaBrowser.Model.Logging;
-using MediaBrowser.Server.Implementations.Logging;
 using SocketHttpListener.Net;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Emby.Server.Implementations.HttpServer;
+using Emby.Server.Implementations.Logging;
 using MediaBrowser.Common.IO;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Services;
diff --git a/MediaBrowser.Server.Implementations/IO/FileRefresher.cs b/MediaBrowser.Server.Implementations/IO/FileRefresher.cs
deleted file mode 100644
index 2742e1a26..000000000
--- a/MediaBrowser.Server.Implementations/IO/FileRefresher.cs
+++ /dev/null
@@ -1,323 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Common.Events;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Controller.Configuration;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.IO;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.Extensions;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Tasks;
-using MediaBrowser.Model.Threading;
-
-namespace MediaBrowser.Server.Implementations.IO
-{
-    public class FileRefresher : IDisposable
-    {
-        private ILogger Logger { get; set; }
-        private ITaskManager TaskManager { get; set; }
-        private ILibraryManager LibraryManager { get; set; }
-        private IServerConfigurationManager ConfigurationManager { get; set; }
-        private readonly IFileSystem _fileSystem;
-        private readonly List<string> _affectedPaths = new List<string>();
-        private ITimer _timer;
-        private readonly ITimerFactory _timerFactory;
-        private readonly object _timerLock = new object();
-        public string Path { get; private set; }
-
-        public event EventHandler<EventArgs> Completed;
-
-        public FileRefresher(string path, IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ITaskManager taskManager, ILogger logger, ITimerFactory timerFactory)
-        {
-            logger.Debug("New file refresher created for {0}", path);
-            Path = path;
-
-            _fileSystem = fileSystem;
-            ConfigurationManager = configurationManager;
-            LibraryManager = libraryManager;
-            TaskManager = taskManager;
-            Logger = logger;
-            _timerFactory = timerFactory;
-            AddPath(path);
-        }
-
-        private void AddAffectedPath(string path)
-        {
-            if (string.IsNullOrWhiteSpace(path))
-            {
-                throw new ArgumentNullException("path");
-            }
-
-            if (!_affectedPaths.Contains(path, StringComparer.Ordinal))
-            {
-                _affectedPaths.Add(path);
-            }
-        }
-
-        public void AddPath(string path)
-        {
-            if (string.IsNullOrWhiteSpace(path))
-            {
-                throw new ArgumentNullException("path");
-            }
-
-            lock (_timerLock)
-            {
-                AddAffectedPath(path);
-            }
-            RestartTimer();
-        }
-
-        public void RestartTimer()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            lock (_timerLock)
-            {
-                if (_disposed)
-                {
-                    return;
-                }
-
-                if (_timer == null)
-                {
-                    _timer = _timerFactory.Create(OnTimerCallback, null, TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
-                }
-                else
-                {
-                    _timer.Change(TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
-                }
-            }
-        }
-
-        public void ResetPath(string path, string affectedFile)
-        {
-            lock (_timerLock)
-            {
-                Logger.Debug("Resetting file refresher from {0} to {1}", Path, path);
-
-                Path = path;
-                AddAffectedPath(path);
-
-                if (!string.IsNullOrWhiteSpace(affectedFile))
-                {
-                    AddAffectedPath(affectedFile);
-                }
-            }
-            RestartTimer();
-        }
-
-        private async void OnTimerCallback(object state)
-        {
-            List<string> paths;
-
-            lock (_timerLock)
-            {
-                paths = _affectedPaths.ToList();
-            }
-
-            // Extend the timer as long as any of the paths are still being written to.
-            if (paths.Any(IsFileLocked))
-            {
-                Logger.Info("Timer extended.");
-                RestartTimer();
-                return;
-            }
-
-            Logger.Debug("Timer stopped.");
-
-            DisposeTimer();
-            EventHelper.FireEventIfNotNull(Completed, this, EventArgs.Empty, Logger);
-
-            try
-            {
-                await ProcessPathChanges(paths.ToList()).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                Logger.ErrorException("Error processing directory changes", ex);
-            }
-        }
-
-        private async Task ProcessPathChanges(List<string> paths)
-        {
-            var itemsToRefresh = paths
-                .Distinct(StringComparer.OrdinalIgnoreCase)
-                .Select(GetAffectedBaseItem)
-                .Where(item => item != null)
-                .DistinctBy(i => i.Id)
-                .ToList();
-
-            foreach (var p in paths)
-            {
-                Logger.Info(p + " reports change.");
-            }
-
-            // If the root folder changed, run the library task so the user can see it
-            if (itemsToRefresh.Any(i => i is AggregateFolder))
-            {
-                LibraryManager.ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
-                return;
-            }
-
-            foreach (var item in itemsToRefresh)
-            {
-                Logger.Info(item.Name + " (" + item.Path + ") will be refreshed.");
-
-                try
-                {
-                    await item.ChangedExternally().ConfigureAwait(false);
-                }
-                catch (IOException ex)
-                {
-                    // For now swallow and log. 
-                    // Research item: If an IOException occurs, the item may be in a disconnected state (media unavailable)
-                    // Should we remove it from it's parent?
-                    Logger.ErrorException("Error refreshing {0}", ex, item.Name);
-                }
-                catch (Exception ex)
-                {
-                    Logger.ErrorException("Error refreshing {0}", ex, item.Name);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the affected base item.
-        /// </summary>
-        /// <param name="path">The path.</param>
-        /// <returns>BaseItem.</returns>
-        private BaseItem GetAffectedBaseItem(string path)
-        {
-            BaseItem item = null;
-
-            while (item == null && !string.IsNullOrEmpty(path))
-            {
-                item = LibraryManager.FindByPath(path, null);
-
-                path = System.IO.Path.GetDirectoryName(path);
-            }
-
-            if (item != null)
-            {
-                // If the item has been deleted find the first valid parent that still exists
-                while (!_fileSystem.DirectoryExists(item.Path) && !_fileSystem.FileExists(item.Path))
-                {
-                    item = item.GetParent();
-
-                    if (item == null)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            return item;
-        }
-
-        private bool IsFileLocked(string path)
-        {
-            if (Environment.OSVersion.Platform != PlatformID.Win32NT)
-            {
-                // Causing lockups on linux
-                return false;
-            }
-
-            try
-            {
-                var data = _fileSystem.GetFileSystemInfo(path);
-
-                if (!data.Exists
-                    || data.IsDirectory
-
-                    // Opening a writable stream will fail with readonly files
-                    || data.IsReadOnly)
-                {
-                    return false;
-                }
-            }
-            catch (IOException)
-            {
-                return false;
-            }
-            catch (Exception ex)
-            {
-                Logger.ErrorException("Error getting file system info for: {0}", ex, path);
-                return false;
-            }
-
-            // In order to determine if the file is being written to, we have to request write access
-            // But if the server only has readonly access, this is going to cause this entire algorithm to fail
-            // So we'll take a best guess about our access level
-            var requestedFileAccess = ConfigurationManager.Configuration.SaveLocalMeta
-                ? FileAccessMode.ReadWrite
-                : FileAccessMode.Read;
-
-            try
-            {
-                using (_fileSystem.GetFileStream(path, FileOpenMode.Open, requestedFileAccess, FileShareMode.ReadWrite))
-                {
-                    //file is not locked
-                    return false;
-                }
-            }
-            //catch (DirectoryNotFoundException)
-            //{
-            //    // File may have been deleted
-            //    return false;
-            //}
-            catch (FileNotFoundException)
-            {
-                // File may have been deleted
-                return false;
-            }
-            catch (UnauthorizedAccessException)
-            {
-                Logger.Debug("No write permission for: {0}.", path);
-                return false;
-            }
-            catch (IOException)
-            {
-                //the file is unavailable because it is:
-                //still being written to
-                //or being processed by another thread
-                //or does not exist (has already been processed)
-                Logger.Debug("{0} is locked.", path);
-                return true;
-            }
-            catch (Exception ex)
-            {
-                Logger.ErrorException("Error determining if file is locked: {0}", ex, path);
-                return false;
-            }
-        }
-
-        private void DisposeTimer()
-        {
-            lock (_timerLock)
-            {
-                if (_timer != null)
-                {
-                    _timer.Dispose();
-                    _timer = null;
-                }
-            }
-        }
-
-        private bool _disposed;
-        public void Dispose()
-        {
-            _disposed = true;
-            DisposeTimer();
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/IO/LibraryMonitor.cs b/MediaBrowser.Server.Implementations/IO/LibraryMonitor.cs
index 49cb1e75f..34fc85e7b 100644
--- a/MediaBrowser.Server.Implementations/IO/LibraryMonitor.cs
+++ b/MediaBrowser.Server.Implementations/IO/LibraryMonitor.cs
@@ -10,13 +10,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using Emby.Server.Implementations.IO;
 using MediaBrowser.Common.IO;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.System;
 using MediaBrowser.Model.Tasks;
 using MediaBrowser.Model.Threading;
-using Microsoft.Win32;
 
 namespace MediaBrowser.Server.Implementations.IO
 {
@@ -142,7 +143,7 @@ namespace MediaBrowser.Server.Implementations.IO
         /// <summary>
         /// Initializes a new instance of the <see cref="LibraryMonitor" /> class.
         /// </summary>
-        public LibraryMonitor(ILogManager logManager, ITaskManager taskManager, ILibraryManager libraryManager, IServerConfigurationManager configurationManager, IFileSystem fileSystem, ITimerFactory timerFactory)
+        public LibraryMonitor(ILogManager logManager, ITaskManager taskManager, ILibraryManager libraryManager, IServerConfigurationManager configurationManager, IFileSystem fileSystem, ITimerFactory timerFactory, ISystemEvents systemEvents)
         {
             if (taskManager == null)
             {
@@ -156,15 +157,10 @@ namespace MediaBrowser.Server.Implementations.IO
             _fileSystem = fileSystem;
             _timerFactory = timerFactory;
 
-            SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
+            systemEvents.Resume += _systemEvents_Resume;
         }
 
-        /// <summary>
-        /// Handles the PowerModeChanged event of the SystemEvents control.
-        /// </summary>
-        /// <param name="sender">The source of the event.</param>
-        /// <param name="e">The <see cref="PowerModeChangedEventArgs"/> instance containing the event data.</param>
-        void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
+        private void _systemEvents_Resume(object sender, EventArgs e)
         {
             Restart();
         }
diff --git a/MediaBrowser.Server.Implementations/Logging/PatternsLogger.cs b/MediaBrowser.Server.Implementations/Logging/PatternsLogger.cs
deleted file mode 100644
index 00b6cc5a8..000000000
--- a/MediaBrowser.Server.Implementations/Logging/PatternsLogger.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-using Patterns.Logging;
-using System;
-
-namespace MediaBrowser.Server.Implementations.Logging
-{
-    public class PatternsLogger : ILogger
-    {
-        private readonly Model.Logging.ILogger _logger;
-
-        public PatternsLogger()
-            : this(new Model.Logging.NullLogger())
-        {
-        }
-
-        public PatternsLogger(Model.Logging.ILogger logger)
-        {
-            _logger = logger;
-        }
-
-        public void Debug(string message, params object[] paramList)
-        {
-            _logger.Debug(message, paramList);
-        }
-
-        public void Error(string message, params object[] paramList)
-        {
-            _logger.Error(message, paramList);
-        }
-
-        public void ErrorException(string message, Exception exception, params object[] paramList)
-        {
-            _logger.ErrorException(message, exception, paramList);
-        }
-
-        public void Fatal(string message, params object[] paramList)
-        {
-            _logger.Fatal(message, paramList);
-        }
-
-        public void FatalException(string message, Exception exception, params object[] paramList)
-        {
-            _logger.FatalException(message, exception, paramList);
-        }
-
-        public void Info(string message, params object[] paramList)
-        {
-            _logger.Info(message, paramList);
-        }
-
-        public void Warn(string message, params object[] paramList)
-        {
-            _logger.Warn(message, paramList);
-        }
-
-        public void Log(LogSeverity severity, string message, params object[] paramList)
-        {
-        }
-
-        public void LogMultiline(string message, LogSeverity severity, System.Text.StringBuilder additionalContent)
-        {
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
index d6223c465..066ee8e30 100644
--- a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
+++ b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
@@ -113,15 +113,9 @@
     <Compile Include="Archiving\ZipClient.cs" />
     <Compile Include="Collections\CollectionsDynamicFolder.cs" />
     <Compile Include="Configuration\ServerConfigurationManager.cs" />
-    <Compile Include="Connect\ConnectData.cs" />
-    <Compile Include="Connect\ConnectEntryPoint.cs" />
-    <Compile Include="Connect\ConnectManager.cs" />
-    <Compile Include="Connect\Responses.cs" />
-    <Compile Include="Connect\Validator.cs" />
     <Compile Include="Devices\DeviceRepository.cs" />
     <Compile Include="Devices\CameraUploadsFolder.cs" />
     <Compile Include="EntryPoints\ExternalPortForwarding.cs" />
-    <Compile Include="EntryPoints\UdpServerEntryPoint.cs" />
     <Compile Include="HttpServer\ContainerAdapter.cs" />
     <Compile Include="HttpServer\GetSwaggerResource.cs" />
     <Compile Include="HttpServer\HttpListenerHost.cs" />
@@ -140,7 +134,6 @@
     <Compile Include="HttpServer\SocketSharp\WebSocketSharpListener.cs" />
     <Compile Include="HttpServer\SocketSharp\WebSocketSharpRequest.cs" />
     <Compile Include="HttpServer\SocketSharp\WebSocketSharpResponse.cs" />
-    <Compile Include="IO\FileRefresher.cs" />
     <Compile Include="IO\LibraryMonitor.cs" />
     <Compile Include="IO\MemoryStreamProvider.cs" />
     <Compile Include="LiveTv\TunerHosts\SatIp\ChannelScan.cs" />
@@ -166,7 +159,6 @@
     <Compile Include="LiveTv\TunerHosts\SatIp\TransmissionMode.cs" />
     <Compile Include="LiveTv\TunerHosts\SatIp\Utils.cs" />
     <Compile Include="Localization\LocalizationManager.cs" />
-    <Compile Include="Logging\PatternsLogger.cs" />
     <Compile Include="Persistence\BaseSqliteRepository.cs" />
     <Compile Include="Persistence\DataExtensions.cs" />
     <Compile Include="Persistence\IDbConnector.cs" />
@@ -180,15 +172,12 @@
     <Compile Include="Playlists\ManualPlaylistsFolder.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Security\AuthenticationRepository.cs" />
-    <Compile Include="Security\EncryptionManager.cs" />
     <Compile Include="ServerApplicationPaths.cs" />
     <Compile Include="Persistence\SqliteDisplayPreferencesRepository.cs" />
     <Compile Include="Persistence\SqliteItemRepository.cs" />
     <Compile Include="Persistence\SqliteUserDataRepository.cs" />
     <Compile Include="Persistence\SqliteUserRepository.cs" />
     <Compile Include="Sync\SyncRepository.cs" />
-    <Compile Include="Udp\UdpMessageReceivedEventArgs.cs" />
-    <Compile Include="Udp\UdpServer.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Emby.Server.Implementations\Emby.Server.Implementations.csproj">
diff --git a/MediaBrowser.Server.Implementations/Security/EncryptionManager.cs b/MediaBrowser.Server.Implementations/Security/EncryptionManager.cs
deleted file mode 100644
index cd9b9651e..000000000
--- a/MediaBrowser.Server.Implementations/Security/EncryptionManager.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using MediaBrowser.Controller.Security;
-using System;
-using System.Text;
-
-namespace MediaBrowser.Server.Implementations.Security
-{
-    public class EncryptionManager : IEncryptionManager
-    {
-        /// <summary>
-        /// Encrypts the string.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        /// <returns>System.String.</returns>
-        /// <exception cref="System.ArgumentNullException">value</exception>
-        public string EncryptString(string value)
-        {
-            if (value == null) throw new ArgumentNullException("value");
-
-            return EncryptStringUniversal(value);
-        }
-
-        /// <summary>
-        /// Decrypts the string.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        /// <returns>System.String.</returns>
-        /// <exception cref="System.ArgumentNullException">value</exception>
-        public string DecryptString(string value)
-        {
-            if (value == null) throw new ArgumentNullException("value");
-
-            return DecryptStringUniversal(value);
-        }
-
-        private string EncryptStringUniversal(string value)
-        {
-            // Yes, this isn't good, but ProtectedData in mono is throwing exceptions, so use this for now
-
-            var bytes = Encoding.UTF8.GetBytes(value);
-            return Convert.ToBase64String(bytes);
-        }
-
-        private string DecryptStringUniversal(string value)
-        {
-            // Yes, this isn't good, but ProtectedData in mono is throwing exceptions, so use this for now
-
-            var bytes = Convert.FromBase64String(value);
-            return Encoding.UTF8.GetString(bytes);
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Udp/UdpMessageReceivedEventArgs.cs b/MediaBrowser.Server.Implementations/Udp/UdpMessageReceivedEventArgs.cs
deleted file mode 100644
index 5c83a1300..000000000
--- a/MediaBrowser.Server.Implementations/Udp/UdpMessageReceivedEventArgs.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-
-namespace MediaBrowser.Server.Implementations.Udp
-{
-    /// <summary>
-    /// Class UdpMessageReceivedEventArgs
-    /// </summary>
-    public class UdpMessageReceivedEventArgs : EventArgs
-    {
-        /// <summary>
-        /// Gets or sets the bytes.
-        /// </summary>
-        /// <value>The bytes.</value>
-        public byte[] Bytes { get; set; }
-        /// <summary>
-        /// Gets or sets the remote end point.
-        /// </summary>
-        /// <value>The remote end point.</value>
-        public string RemoteEndPoint { get; set; }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/Udp/UdpServer.cs b/MediaBrowser.Server.Implementations/Udp/UdpServer.cs
deleted file mode 100644
index c2082f0d2..000000000
--- a/MediaBrowser.Server.Implementations/Udp/UdpServer.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-using MediaBrowser.Common.Net;
-using MediaBrowser.Controller;
-using MediaBrowser.Model.ApiClient;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Serialization;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net;
-using System.Net.Sockets;
-using System.Text;
-using System.Threading.Tasks;
-using Emby.Common.Implementations.Networking;
-
-namespace MediaBrowser.Server.Implementations.Udp
-{
-    /// <summary>
-    /// Provides a Udp Server
-    /// </summary>
-    public class UdpServer : IDisposable
-    {
-        /// <summary>
-        /// The _logger
-        /// </summary>
-        private readonly ILogger _logger;
-
-        /// <summary>
-        /// The _network manager
-        /// </summary>
-        private readonly INetworkManager _networkManager;
-
-        private bool _isDisposed;
-
-        private readonly List<Tuple<string, bool, Func<string, string, Encoding, Task>>> _responders = new List<Tuple<string, bool, Func<string, string, Encoding, Task>>>();
-
-        private readonly IServerApplicationHost _appHost;
-        private readonly IJsonSerializer _json;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="UdpServer" /> class.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="networkManager">The network manager.</param>
-        /// <param name="appHost">The application host.</param>
-        /// <param name="json">The json.</param>
-        public UdpServer(ILogger logger, INetworkManager networkManager, IServerApplicationHost appHost, IJsonSerializer json)
-        {
-            _logger = logger;
-            _networkManager = networkManager;
-            _appHost = appHost;
-            _json = json;
-
-            AddMessageResponder("who is EmbyServer?", true, RespondToV2Message);
-            AddMessageResponder("who is MediaBrowserServer_v2?", false, RespondToV2Message);
-        }
-
-        private void AddMessageResponder(string message, bool isSubstring, Func<string, string, Encoding, Task> responder)
-        {
-            _responders.Add(new Tuple<string, bool, Func<string, string, Encoding, Task>>(message, isSubstring, responder));
-        }
-
-        /// <summary>
-        /// Raises the <see cref="E:MessageReceived" /> event.
-        /// </summary>
-        /// <param name="e">The <see cref="UdpMessageReceivedEventArgs"/> instance containing the event data.</param>
-        private async void OnMessageReceived(UdpMessageReceivedEventArgs e)
-        {
-            var encoding = Encoding.UTF8;
-            var responder = GetResponder(e.Bytes, encoding);
-
-            if (responder == null)
-            {
-                encoding = Encoding.Unicode;
-                responder = GetResponder(e.Bytes, encoding);
-            }
-
-            if (responder != null)
-            {
-                try
-                {
-                    await responder.Item2.Item3(responder.Item1, e.RemoteEndPoint, encoding).ConfigureAwait(false);
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error in OnMessageReceived", ex);
-                }
-            }
-        }
-
-        private Tuple<string, Tuple<string, bool, Func<string, string, Encoding, Task>>> GetResponder(byte[] bytes, Encoding encoding)
-        {
-            var text = encoding.GetString(bytes);
-            var responder = _responders.FirstOrDefault(i =>
-            {
-                if (i.Item2)
-                {
-                    return text.IndexOf(i.Item1, StringComparison.OrdinalIgnoreCase) != -1;
-                }
-                return string.Equals(i.Item1, text, StringComparison.OrdinalIgnoreCase);
-            });
-
-            if (responder == null)
-            {
-                return null;
-            }
-            return new Tuple<string, Tuple<string, bool, Func<string, string, Encoding, Task>>>(text, responder);
-        }
-
-        private async Task RespondToV2Message(string messageText, string endpoint, Encoding encoding)
-        {
-            var parts = messageText.Split('|');
-
-            var localUrl = await _appHost.GetLocalApiUrl().ConfigureAwait(false);
-
-            if (!string.IsNullOrEmpty(localUrl))
-            {
-                var response = new ServerDiscoveryInfo
-                {
-                    Address = localUrl,
-                    Id = _appHost.SystemId,
-                    Name = _appHost.FriendlyName
-                };
-
-                await SendAsync(encoding.GetBytes(_json.SerializeToString(response)), endpoint).ConfigureAwait(false);
-                
-                if (parts.Length > 1)
-                {
-                    _appHost.EnableLoopback(parts[1]);
-                }
-            }
-            else
-            {
-                _logger.Warn("Unable to respond to udp request because the local ip address could not be determined.");
-            }
-        }
-
-        /// <summary>
-        /// The _udp client
-        /// </summary>
-        private UdpClient _udpClient;
-
-        /// <summary>
-        /// Starts the specified port.
-        /// </summary>
-        /// <param name="port">The port.</param>
-        public void Start(int port)
-        {
-            _udpClient = new UdpClient(new IPEndPoint(IPAddress.Any, port));
-
-            _udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
-
-            Task.Run(() => StartListening());
-        }
-
-        private async void StartListening()
-        {
-            while (!_isDisposed)
-            {
-                try
-                {
-                    var result = await GetResult().ConfigureAwait(false);
-
-                    OnMessageReceived(result);
-                }
-                catch (ObjectDisposedException)
-                {
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error in StartListening", ex);
-                }
-            }
-        }
-
-        private Task<UdpReceiveResult> GetResult()
-        {
-            try
-            {
-                return _udpClient.ReceiveAsync();
-            }
-            catch (ObjectDisposedException)
-            {
-                return Task.FromResult(new UdpReceiveResult(new byte[] { }, new IPEndPoint(IPAddress.Any, 0)));
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error receiving udp message", ex);
-                return Task.FromResult(new UdpReceiveResult(new byte[] { }, new IPEndPoint(IPAddress.Any, 0)));
-            }
-        }
-
-        /// <summary>
-        /// Called when [message received].
-        /// </summary>
-        /// <param name="message">The message.</param>
-        private void OnMessageReceived(UdpReceiveResult message)
-        {
-            if (message.RemoteEndPoint.Port == 0)
-            {
-                return;
-            }
-            var bytes = message.Buffer;
-
-            try
-            {
-                OnMessageReceived(new UdpMessageReceivedEventArgs
-                {
-                    Bytes = bytes,
-                    RemoteEndPoint = message.RemoteEndPoint.ToString()
-                });
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error handling UDP message", ex);
-            }
-        }
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        /// <summary>
-        /// Stops this instance.
-        /// </summary>
-        public void Stop()
-        {
-            _isDisposed = true;
-
-            if (_udpClient != null)
-            {
-                _udpClient.Close();
-            }
-        }
-
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool dispose)
-        {
-            if (dispose)
-            {
-                Stop();
-            }
-        }
-
-        /// <summary>
-        /// Sends the async.
-        /// </summary>
-        /// <param name="data">The data.</param>
-        /// <param name="ipAddress">The ip address.</param>
-        /// <param name="port">The port.</param>
-        /// <returns>Task{System.Int32}.</returns>
-        /// <exception cref="System.ArgumentNullException">data</exception>
-        public Task SendAsync(string data, string ipAddress, int port)
-        {
-            return SendAsync(Encoding.UTF8.GetBytes(data), ipAddress, port);
-        }
-
-        /// <summary>
-        /// Sends the async.
-        /// </summary>
-        /// <param name="bytes">The bytes.</param>
-        /// <param name="ipAddress">The ip address.</param>
-        /// <param name="port">The port.</param>
-        /// <returns>Task{System.Int32}.</returns>
-        /// <exception cref="System.ArgumentNullException">bytes</exception>
-        public Task SendAsync(byte[] bytes, string ipAddress, int port)
-        {
-            if (bytes == null)
-            {
-                throw new ArgumentNullException("bytes");
-            }
-
-            if (string.IsNullOrEmpty(ipAddress))
-            {
-                throw new ArgumentNullException("ipAddress");
-            }
-
-            return _udpClient.SendAsync(bytes, bytes.Length, ipAddress, port);
-        }
-
-        /// <summary>
-        /// Sends the async.
-        /// </summary>
-        /// <param name="bytes">The bytes.</param>
-        /// <param name="remoteEndPoint">The remote end point.</param>
-        /// <returns>Task.</returns>
-        /// <exception cref="System.ArgumentNullException">
-        /// bytes
-        /// or
-        /// remoteEndPoint
-        /// </exception>
-        public async Task SendAsync(byte[] bytes, string remoteEndPoint)
-        {
-            if (bytes == null)
-            {
-                throw new ArgumentNullException("bytes");
-            }
-
-            if (string.IsNullOrEmpty(remoteEndPoint))
-            {
-                throw new ArgumentNullException("remoteEndPoint");
-            }
-
-            try
-            {
-                // Need to do this until Common will compile with this method
-                var nativeNetworkManager = (BaseNetworkManager) _networkManager;
-
-                await _udpClient.SendAsync(bytes, bytes.Length, nativeNetworkManager.Parse(remoteEndPoint)).ConfigureAwait(false);
-
-                _logger.Info("Udp message sent to {0}", remoteEndPoint);
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("Error sending message to {0}", ex, remoteEndPoint);
-            }
-        }
-    }
-
-}
diff --git a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
index 5f609de27..79f7b5f05 100644
--- a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
+++ b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
@@ -51,12 +51,9 @@ using MediaBrowser.Providers.Subtitles;
 using MediaBrowser.Server.Implementations;
 using MediaBrowser.Server.Implementations.Activity;
 using MediaBrowser.Server.Implementations.Configuration;
-using MediaBrowser.Server.Implementations.Connect;
 using MediaBrowser.Server.Implementations.Devices;
-using MediaBrowser.Server.Implementations.EntryPoints;
 using MediaBrowser.Server.Implementations.HttpServer;
 using MediaBrowser.Server.Implementations.IO;
-using MediaBrowser.Server.Implementations.LiveTv;
 using MediaBrowser.Server.Implementations.Localization;
 using MediaBrowser.Server.Implementations.Notifications;
 using MediaBrowser.Server.Implementations.Persistence;
@@ -102,8 +99,10 @@ using Emby.Dlna.Ssdp;
 using Emby.Server.Implementations.Activity;
 using Emby.Server.Implementations.Channels;
 using Emby.Server.Implementations.Collections;
+using Emby.Server.Implementations.Connect;
 using Emby.Server.Implementations.Devices;
 using Emby.Server.Implementations.Dto;
+using Emby.Server.Implementations.EntryPoints;
 using Emby.Server.Implementations.FileOrganization;
 using Emby.Server.Implementations.HttpServer.Security;
 using Emby.Server.Implementations.Library;
@@ -593,7 +592,7 @@ namespace MediaBrowser.Server.Startup.Common
             var musicManager = new MusicManager(LibraryManager);
             RegisterSingleInstance<IMusicManager>(new MusicManager(LibraryManager));
 
-            LibraryMonitor = new LibraryMonitor(LogManager, TaskManager, LibraryManager, ServerConfigurationManager, FileSystemManager, TimerFactory);
+            LibraryMonitor = new LibraryMonitor(LogManager, TaskManager, LibraryManager, ServerConfigurationManager, FileSystemManager, TimerFactory, SystemEvents);
             RegisterSingleInstance(LibraryMonitor);
 
             ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, LibraryMonitor, LogManager, FileSystemManager, ApplicationPaths, () => LibraryManager, JsonSerializer, MemoryStreamProvider);
diff --git a/RSSDP/SsdpCommunicationsServer.cs b/RSSDP/SsdpCommunicationsServer.cs
index 64278fe4e..dadb1bff4 100644
--- a/RSSDP/SsdpCommunicationsServer.cs
+++ b/RSSDP/SsdpCommunicationsServer.cs
@@ -260,7 +260,7 @@ namespace Rssdp.Infrastructure
             var socket = _SendSocket;
             if (socket != null)
             {
-                await _SendSocket.SendTo(messageData, destination).ConfigureAwait(false);
+                await _SendSocket.SendAsync(messageData, messageData.Length, destination).ConfigureAwait(false);
             }
             else
             {
@@ -290,7 +290,7 @@ namespace Rssdp.Infrastructure
 
         private IUdpSocket CreateSocketAndListenForResponsesAsync()
         {
-            _SendSocket = _SocketFactory.CreateUdpSocket(_LocalPort);
+            _SendSocket = _SocketFactory.CreateSsdpUdpSocket(_LocalPort);
 
             ListenToSocket(_SendSocket);
 
@@ -316,7 +316,7 @@ namespace Rssdp.Infrastructure
                             // Strange cannot convert compiler error here if I don't explicitly
                             // assign or cast to Action first. Assignment is easier to read,
                             // so went with that.
-                            Action processWork = () => ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(result.Buffer, 0, result.ReceivedBytes), result.ReceivedFrom);
+                            Action processWork = () => ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(result.Buffer, 0, result.ReceivedBytes), result.RemoteEndPoint);
                             var processTask = Task.Run(processWork);
                         }
                     }
-- 
cgit v1.2.3


From a8b340cbb29dbcf7fd5d101e640d66470c6d32bf Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Tue, 8 Nov 2016 13:44:23 -0500
Subject: update portable projects

---
 BDInfo/BDROM.cs                                    |   4 +-
 BDInfo/TSPlaylistFile.cs                           |  10 +-
 BDInfo/TSStreamClipFile.cs                         |  14 +-
 Emby.Common.Implementations/BaseApplicationHost.cs |  10 +-
 .../Cryptography/CryptographyProvider.cs           |  17 +-
 .../HttpClientManager/HttpClientManager.cs         |   4 +-
 Emby.Common.Implementations/Net/NetSocket.cs       |  85 +++++
 Emby.Common.Implementations/Net/SocketAcceptor.cs  | 111 ++++++
 Emby.Common.Implementations/Net/SocketFactory.cs   |  37 +-
 Emby.Common.Implementations/Net/UdpSocket.cs       |  12 +-
 .../Networking/BaseNetworkManager.cs               |  91 ++++-
 .../TextEncoding/TextEncoding.cs                   |  13 +-
 Emby.Dlna/Main/DlnaEntryPoint.cs                   |   6 +-
 Emby.Dlna/PlayTo/PlayToManager.cs                  |  11 +-
 .../Connect/ConnectEntryPoint.cs                   |   8 +-
 .../Connect/ConnectManager.cs                      |   2 +-
 .../Emby.Server.Implementations.csproj             |  10 +
 .../HttpServer/LoggerUtils.cs                      |  43 +++
 .../HttpServer/RangeRequestWriter.cs               | 224 +++++++++++++
 .../HttpServer/ResponseFilter.cs                   | 129 +++++++
 .../HttpServer/SocketSharp/Extensions.cs           |  12 +
 .../HttpServer/SocketSharp/SharpWebSocket.cs       | 166 +++++++++
 .../SocketSharp/WebSocketSharpListener.cs          | 203 +++++++++++
 .../SocketSharp/WebSocketSharpResponse.cs          | 204 +++++++++++
 Emby.Server.Implementations/Library/UserManager.cs |   6 +-
 .../Security/MBLicenseFile.cs                      |  10 +-
 .../Security/PluginSecurityManager.cs              |   4 +-
 .../ServerManager/ServerManager.cs                 |   8 +-
 .../ServerManager/WebSocketConnection.cs           |  10 +-
 Emby.Server.Implementations/Sync/MediaSync.cs      |   6 +-
 .../Sync/MultiProviderSync.cs                      |   4 +-
 .../Sync/ServerSyncScheduledTask.cs                |   4 +-
 Emby.Server.Implementations/Sync/SyncManager.cs    |   4 +-
 .../Sync/TargetDataProvider.cs                     |   4 +-
 .../Updates/InstallationManager.cs                 |   6 +-
 MediaBrowser.Api/Dlna/DlnaServerService.cs         |   4 +-
 MediaBrowser.Api/Playback/BaseStreamingService.cs  |   1 +
 MediaBrowser.Common/Extensions/BaseExtensions.cs   |   2 +-
 MediaBrowser.Common/Net/INetworkManager.cs         |   5 +
 MediaBrowser.Controller/IServerApplicationHost.cs  |   2 +-
 .../MediaEncoding/MediaStreamSelector.cs           |   3 +-
 .../Net/AuthenticatedAttribute.cs                  |  14 +-
 .../BdInfo/BdInfoExaminer.cs                       |   6 +-
 MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs |   4 +-
 .../Probing/ProbeResultNormalizer.cs               |   4 +-
 .../Subtitles/SubtitleEncoder.cs                   |   8 +-
 MediaBrowser.Model/Cryptography/ICryptoProvider.cs |  13 +
 .../Cryptography/ICryptographyProvider.cs          |  14 -
 MediaBrowser.Model/IO/IMemoryStreamFactory.cs      |  12 +
 MediaBrowser.Model/IO/IMemoryStreamProvider.cs     |  11 -
 MediaBrowser.Model/MediaBrowser.Model.csproj       |   8 +-
 MediaBrowser.Model/Net/ISocket.cs                  |  16 +
 MediaBrowser.Model/Net/ISocketFactory.cs           |  14 +-
 MediaBrowser.Model/Net/IpAddressInfo.cs            |  29 +-
 MediaBrowser.Model/Net/IpEndPointInfo.cs           |  14 +-
 MediaBrowser.Model/Services/IHasRequestFilter.cs   |  13 +-
 MediaBrowser.Model/Services/IHttpResult.cs         |  47 +++
 MediaBrowser.Model/Services/IRequest.cs            |  10 -
 .../Services/QueryParamCollection.cs               |  31 +-
 MediaBrowser.Model/Text/ITextEncoding.cs           |  10 +
 MediaBrowser.Model/TextEncoding/IEncoding.cs       |  12 -
 MediaBrowser.Providers/Manager/ImageSaver.cs       |   4 +-
 MediaBrowser.Providers/Manager/ProviderManager.cs  |   4 +-
 .../MediaInfo/SubtitleResolver.cs                  |  13 +-
 .../TV/TheTVDB/TvdbSeriesProvider.cs               |   4 +-
 .../HttpServer/ContainerAdapter.cs                 |  11 +-
 .../HttpServer/HttpListenerHost.cs                 | 371 ++++++++++++---------
 .../HttpServer/HttpResultFactory.cs                |   1 +
 .../HttpServer/LoggerUtils.cs                      |  43 ---
 .../HttpServer/RangeRequestWriter.cs               | 230 -------------
 .../HttpServer/ResponseFilter.cs                   | 127 -------
 .../HttpServer/ServerFactory.cs                    |  15 +-
 .../HttpServer/ServerLogFactory.cs                 |  46 ---
 .../HttpServer/ServerLogger.cs                     | 194 -----------
 .../HttpServer/SocketSharp/Extensions.cs           |  28 --
 .../HttpServer/SocketSharp/RequestMono.cs          |  13 +-
 .../HttpServer/SocketSharp/SharpWebSocket.cs       | 172 ----------
 .../SocketSharp/WebSocketSharpListener.cs          | 216 ------------
 .../SocketSharp/WebSocketSharpRequest.cs           | 100 ++----
 .../SocketSharp/WebSocketSharpResponse.cs          | 152 ---------
 .../IO/MemoryStreamProvider.cs                     |  16 +-
 .../MediaBrowser.Server.Implementations.csproj     |  18 +-
 .../Persistence/DataExtensions.cs                  |   4 +-
 .../SqliteDisplayPreferencesRepository.cs          |   4 +-
 .../Persistence/SqliteItemRepository.cs            |   4 +-
 .../Persistence/SqliteUserRepository.cs            |   4 +-
 .../packages.config                                |   1 -
 .../ApplicationHost.cs                             |  54 ++-
 Nuget/MediaBrowser.Common.nuspec                   |   2 +-
 Nuget/MediaBrowser.Server.Core.nuspec              |   4 +-
 OpenSubtitlesHandler/Utilities.cs                  |  10 +-
 91 files changed, 1899 insertions(+), 1765 deletions(-)
 create mode 100644 Emby.Common.Implementations/Net/NetSocket.cs
 create mode 100644 Emby.Common.Implementations/Net/SocketAcceptor.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/LoggerUtils.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/RangeRequestWriter.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/ResponseFilter.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs
 create mode 100644 MediaBrowser.Model/Cryptography/ICryptoProvider.cs
 delete mode 100644 MediaBrowser.Model/Cryptography/ICryptographyProvider.cs
 create mode 100644 MediaBrowser.Model/IO/IMemoryStreamFactory.cs
 delete mode 100644 MediaBrowser.Model/IO/IMemoryStreamProvider.cs
 create mode 100644 MediaBrowser.Model/Net/ISocket.cs
 create mode 100644 MediaBrowser.Model/Services/IHttpResult.cs
 create mode 100644 MediaBrowser.Model/Text/ITextEncoding.cs
 delete mode 100644 MediaBrowser.Model/TextEncoding/IEncoding.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/LoggerUtils.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/ResponseFilter.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/ServerLogFactory.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/ServerLogger.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs

(limited to 'MediaBrowser.Model/Net/ISocketFactory.cs')

diff --git a/BDInfo/BDROM.cs b/BDInfo/BDROM.cs
index 2a23645b1..97dbfbf3b 100644
--- a/BDInfo/BDROM.cs
+++ b/BDInfo/BDROM.cs
@@ -22,7 +22,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace BDInfo
 {
@@ -75,7 +75,7 @@ namespace BDInfo
         public event OnPlaylistFileScanError PlaylistFileScanError;
 
         public BDROM(
-            string path, IFileSystem fileSystem, IEncoding textEncoding)
+            string path, IFileSystem fileSystem, ITextEncoding textEncoding)
         {
             _fileSystem = fileSystem;
             //
diff --git a/BDInfo/TSPlaylistFile.cs b/BDInfo/TSPlaylistFile.cs
index 2826b3c80..46d66f513 100644
--- a/BDInfo/TSPlaylistFile.cs
+++ b/BDInfo/TSPlaylistFile.cs
@@ -23,14 +23,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace BDInfo
 {
     public class TSPlaylistFile
     {
         private readonly IFileSystem _fileSystem;
-        private readonly IEncoding _textEncoding;
+        private readonly ITextEncoding _textEncoding;
         private FileSystemMetadata FileInfo = null;
         public string FileType = null;
         public bool IsInitialized = false;
@@ -67,7 +67,7 @@ namespace BDInfo
 
         public TSPlaylistFile(
             BDROM bdrom,
-            FileSystemMetadata fileInfo, IFileSystem fileSystem, IEncoding textEncoding)
+            FileSystemMetadata fileInfo, IFileSystem fileSystem, ITextEncoding textEncoding)
         {
             BDROM = bdrom;
             FileInfo = fileInfo;
@@ -79,7 +79,7 @@ namespace BDInfo
         public TSPlaylistFile(
             BDROM bdrom,
             string name,
-            List<TSStreamClip> clips, IFileSystem fileSystem, IEncoding textEncoding)
+            List<TSStreamClip> clips, IFileSystem fileSystem, ITextEncoding textEncoding)
         {
             BDROM = bdrom;
             Name = name;
@@ -1247,7 +1247,7 @@ namespace BDInfo
             ref int pos)
         {
             string val =
-                _textEncoding.GetASCIIString(data, pos, count);
+                _textEncoding.GetASCIIEncoding().GetString(data, pos, count);
 
             pos += count;
 
diff --git a/BDInfo/TSStreamClipFile.cs b/BDInfo/TSStreamClipFile.cs
index 118e3b5fc..f2accb88d 100644
--- a/BDInfo/TSStreamClipFile.cs
+++ b/BDInfo/TSStreamClipFile.cs
@@ -23,14 +23,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace BDInfo
 {
     public class TSStreamClipFile
     {
         private readonly IFileSystem _fileSystem;
-        private readonly IEncoding _textEncoding;
+        private readonly ITextEncoding _textEncoding;
         public FileSystemMetadata FileInfo = null;
         public string FileType = null;
         public bool IsValid = false;
@@ -40,7 +40,7 @@ namespace BDInfo
             new Dictionary<ushort,TSStream>();
 
         public TSStreamClipFile(
-            FileSystemMetadata fileInfo, IFileSystem fileSystem, IEncoding textEncoding)
+            FileSystemMetadata fileInfo, IFileSystem fileSystem, ITextEncoding textEncoding)
         {
             FileInfo = fileInfo;
             _fileSystem = fileSystem;
@@ -70,7 +70,7 @@ namespace BDInfo
                 byte[] fileType = new byte[8];
                 Array.Copy(data, 0, fileType, 0, fileType.Length);
                 
-                FileType = _textEncoding.GetASCIIString(fileType, 0, fileType.Length);
+                FileType = _textEncoding.GetASCIIEncoding().GetString(fileType, 0, fileType.Length);
                 if (FileType != "HDMV0100" &&
                     FileType != "HDMV0200")
                 {
@@ -167,7 +167,7 @@ namespace BDInfo
                             Array.Copy(clipData, streamOffset + 3,
                                 languageBytes, 0, languageBytes.Length);
                             string languageCode =
-                                _textEncoding.GetASCIIString(languageBytes, 0, languageBytes.Length);
+                                _textEncoding.GetASCIIEncoding().GetString(languageBytes, 0, languageBytes.Length);
 
                             TSChannelLayout channelLayout = (TSChannelLayout)
                                 (clipData[streamOffset + 2] >> 4);
@@ -198,7 +198,7 @@ namespace BDInfo
                             Array.Copy(clipData, streamOffset + 2,
                                 languageBytes, 0, languageBytes.Length);
                             string languageCode =
-                                _textEncoding.GetASCIIString(languageBytes, 0, languageBytes.Length);
+                                _textEncoding.GetASCIIEncoding().GetString(languageBytes, 0, languageBytes.Length);
 
                                 stream = new TSGraphicsStream();
                             stream.LanguageCode = languageCode;
@@ -218,7 +218,7 @@ namespace BDInfo
                             Array.Copy(clipData, streamOffset + 3,
                                 languageBytes, 0, languageBytes.Length);
                             string languageCode =
-                                _textEncoding.GetASCIIString(languageBytes, 0, languageBytes.Length);
+                                _textEncoding.GetASCIIEncoding().GetString(languageBytes, 0, languageBytes.Length);
 #if DEBUG
                             Debug.WriteLine(string.Format(
                                 "\t{0} {1} {2}",
diff --git a/Emby.Common.Implementations/BaseApplicationHost.cs b/Emby.Common.Implementations/BaseApplicationHost.cs
index 9585abb2a..0cf11e825 100644
--- a/Emby.Common.Implementations/BaseApplicationHost.cs
+++ b/Emby.Common.Implementations/BaseApplicationHost.cs
@@ -170,7 +170,7 @@ namespace Emby.Common.Implementations
         /// <value><c>true</c> if this instance is running as service; otherwise, <c>false</c>.</value>
         public abstract bool IsRunningAsService { get; }
 
-        protected ICryptographyProvider CryptographyProvider = new CryptographyProvider();
+        protected ICryptoProvider CryptographyProvider = new CryptographyProvider();
 
         protected IEnvironmentInfo EnvironmentInfo = new Emby.Common.Implementations.EnvironmentInfo.EnvironmentInfo();
 
@@ -183,7 +183,7 @@ namespace Emby.Common.Implementations
                 {
                     _deviceId = new DeviceId(ApplicationPaths, LogManager.GetLogger("SystemId"), FileSystemManager);
                 }
-
+             
                 return _deviceId.Value;
             }
         }
@@ -193,7 +193,7 @@ namespace Emby.Common.Implementations
             get { return EnvironmentInfo.OperatingSystemName; }
         }
 
-        public IMemoryStreamProvider MemoryStreamProvider { get; set; }
+        public IMemoryStreamFactory MemoryStreamProvider { get; set; }
 
         /// <summary>
         /// The container
@@ -209,7 +209,7 @@ namespace Emby.Common.Implementations
         {
             // hack alert, until common can target .net core
             BaseExtensions.CryptographyProvider = CryptographyProvider;
-
+            
             XmlSerializer = new MyXmlSerializer(fileSystem, logManager.GetLogger("XmlSerializer"));
             FailedAssemblies = new List<string>();
 
@@ -267,7 +267,7 @@ namespace Emby.Common.Implementations
             progress.Report(100);
         }
 
-        protected abstract IMemoryStreamProvider CreateMemoryStreamProvider();
+        protected abstract IMemoryStreamFactory CreateMemoryStreamProvider();
         protected abstract ISystemEvents CreateSystemEvents();
 
         protected virtual void OnLoggerLoaded(bool isFirstLoad)
diff --git a/Emby.Common.Implementations/Cryptography/CryptographyProvider.cs b/Emby.Common.Implementations/Cryptography/CryptographyProvider.cs
index 7b8d95b96..01a31bcc0 100644
--- a/Emby.Common.Implementations/Cryptography/CryptographyProvider.cs
+++ b/Emby.Common.Implementations/Cryptography/CryptographyProvider.cs
@@ -6,21 +6,14 @@ using MediaBrowser.Model.Cryptography;
 
 namespace Emby.Common.Implementations.Cryptography
 {
-    public class CryptographyProvider : ICryptographyProvider
+    public class CryptographyProvider : ICryptoProvider
     {
         public Guid GetMD5(string str)
         {
-            return new Guid(GetMD5Bytes(str));
-        }
-        public byte[] GetMD5Bytes(string str)
-        {
-            using (var provider = MD5.Create())
-            {
-                return provider.ComputeHash(Encoding.Unicode.GetBytes(str));
-            }
+            return new Guid(ComputeMD5(Encoding.Unicode.GetBytes(str)));
         }
 
-        public byte[] GetSHA1Bytes(byte[] bytes)
+        public byte[] ComputeSHA1(byte[] bytes)
         {
             using (var provider = SHA1.Create())
             {
@@ -28,7 +21,7 @@ namespace Emby.Common.Implementations.Cryptography
             }
         }
 
-        public byte[] GetMD5Bytes(Stream str)
+        public byte[] ComputeMD5(Stream str)
         {
             using (var provider = MD5.Create())
             {
@@ -36,7 +29,7 @@ namespace Emby.Common.Implementations.Cryptography
             }
         }
 
-        public byte[] GetMD5Bytes(byte[] bytes)
+        public byte[] ComputeMD5(byte[] bytes)
         {
             using (var provider = MD5.Create())
             {
diff --git a/Emby.Common.Implementations/HttpClientManager/HttpClientManager.cs b/Emby.Common.Implementations/HttpClientManager/HttpClientManager.cs
index 85fcb556f..06af5af53 100644
--- a/Emby.Common.Implementations/HttpClientManager/HttpClientManager.cs
+++ b/Emby.Common.Implementations/HttpClientManager/HttpClientManager.cs
@@ -42,7 +42,7 @@ namespace Emby.Common.Implementations.HttpClientManager
         private readonly IApplicationPaths _appPaths;
 
         private readonly IFileSystem _fileSystem;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="HttpClientManager" /> class.
@@ -53,7 +53,7 @@ namespace Emby.Common.Implementations.HttpClientManager
         /// <exception cref="System.ArgumentNullException">appPaths
         /// or
         /// logger</exception>
-        public HttpClientManager(IApplicationPaths appPaths, ILogger logger, IFileSystem fileSystem, IMemoryStreamProvider memoryStreamProvider)
+        public HttpClientManager(IApplicationPaths appPaths, ILogger logger, IFileSystem fileSystem, IMemoryStreamFactory memoryStreamProvider)
         {
             if (appPaths == null)
             {
diff --git a/Emby.Common.Implementations/Net/NetSocket.cs b/Emby.Common.Implementations/Net/NetSocket.cs
new file mode 100644
index 000000000..72faa41a9
--- /dev/null
+++ b/Emby.Common.Implementations/Net/NetSocket.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Emby.Common.Implementations.Networking;
+using MediaBrowser.Model.Net;
+using MediaBrowser.Model.Logging;
+
+namespace Emby.Common.Implementations.Net
+{
+    public class NetSocket : ISocket
+    {
+        public Socket Socket { get; private set; }
+        private readonly ILogger _logger;
+
+        public NetSocket(Socket socket, ILogger logger)
+        {
+            Socket = socket;
+            _logger = logger;
+        }
+
+        public IpEndPointInfo LocalEndPoint
+        {
+            get
+            {
+                return BaseNetworkManager.ToIpEndPointInfo((IPEndPoint)Socket.LocalEndPoint);
+            }
+        }
+
+        public IpEndPointInfo RemoteEndPoint
+        {
+            get
+            {
+                return BaseNetworkManager.ToIpEndPointInfo((IPEndPoint)Socket.RemoteEndPoint);
+            }
+        }
+
+        public void Close()
+        {
+#if NET46
+            Socket.Close();
+#else
+                        Socket.Dispose();
+#endif
+        }
+
+        public void Shutdown(bool both)
+        {
+            if (both)
+            {
+                Socket.Shutdown(SocketShutdown.Both);
+            }
+            else
+            {
+                // Change interface if ever needed
+                throw new NotImplementedException();
+            }
+        }
+
+        public void Listen(int backlog)
+        {
+            Socket.Listen(backlog);
+        }
+
+        public void Bind(IpEndPointInfo endpoint)
+        {
+            var nativeEndpoint = BaseNetworkManager.ToIPEndPoint(endpoint);
+
+            Socket.Bind(nativeEndpoint);
+        }
+
+        private SocketAcceptor _acceptor;
+        public void StartAccept(Action<ISocket> onAccept, Func<bool> isClosed)
+        {
+            _acceptor = new SocketAcceptor(_logger, Socket, onAccept, isClosed);
+
+            _acceptor.StartAccept();
+        }
+
+        public void Dispose()
+        {
+            Socket.Dispose();
+        }
+    }
+}
diff --git a/Emby.Common.Implementations/Net/SocketAcceptor.cs b/Emby.Common.Implementations/Net/SocketAcceptor.cs
new file mode 100644
index 000000000..fd65e9fbc
--- /dev/null
+++ b/Emby.Common.Implementations/Net/SocketAcceptor.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Net.Sockets;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Net;
+
+namespace Emby.Common.Implementations.Net
+{
+    public class SocketAcceptor
+    {
+        private readonly ILogger _logger;
+        private readonly Socket _originalSocket;
+        private readonly Func<bool> _isClosed;
+        private readonly Action<ISocket> _onAccept;
+
+        public SocketAcceptor(ILogger logger, Socket originalSocket, Action<ISocket> onAccept, Func<bool> isClosed)
+        {
+            _logger = logger;
+            _originalSocket = originalSocket;
+            _isClosed = isClosed;
+            _onAccept = onAccept;
+        }
+
+        public void StartAccept()
+        {
+            Socket dummy = null;
+            StartAccept(null, ref dummy);
+        }
+
+        public void StartAccept(SocketAsyncEventArgs acceptEventArg, ref Socket accepted)
+        {
+            if (acceptEventArg == null)
+            {
+                acceptEventArg = new SocketAsyncEventArgs();
+                acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed);
+            }
+            else
+            {
+                // socket must be cleared since the context object is being reused
+                acceptEventArg.AcceptSocket = null;
+            }
+
+            try
+            {
+                bool willRaiseEvent = _originalSocket.AcceptAsync(acceptEventArg);
+
+                if (!willRaiseEvent)
+                {
+                    ProcessAccept(acceptEventArg);
+                }
+            }
+            catch (Exception ex)
+            {
+                if (accepted != null)
+                {
+                    try
+                    {
+#if NET46
+                        accepted.Close();
+#else
+                        accepted.Dispose();
+#endif
+                    }
+                    catch
+                    {
+                    }
+                    accepted = null;
+                }
+            }
+        }
+
+        // This method is the callback method associated with Socket.AcceptAsync  
+        // operations and is invoked when an accept operation is complete 
+        // 
+        void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
+        {
+            ProcessAccept(e);
+        }
+
+        private void ProcessAccept(SocketAsyncEventArgs e)
+        {
+            if (_isClosed())
+            {
+                return;
+            }
+
+            // http://msdn.microsoft.com/en-us/library/system.net.sockets.socket.acceptasync%28v=vs.110%29.aspx
+            // Under certain conditions ConnectionReset can occur
+            // Need to attept to re-accept
+            if (e.SocketError == SocketError.ConnectionReset)
+            {
+                _logger.Error("SocketError.ConnectionReset reported. Attempting to re-accept.");
+                Socket dummy = null;
+                StartAccept(e, ref dummy);
+                return;
+            }
+
+            var acceptSocket = e.AcceptSocket;
+            if (acceptSocket != null)
+            {
+                //ProcessAccept(acceptSocket);
+                _onAccept(new NetSocket(acceptSocket, _logger));
+            }
+
+            if (_originalSocket != null)
+            {
+                // Accept the next connection request
+                StartAccept(e, ref acceptSocket);
+            }
+        }
+    }
+}
diff --git a/Emby.Common.Implementations/Net/SocketFactory.cs b/Emby.Common.Implementations/Net/SocketFactory.cs
index bb38c72da..922b0f3cc 100644
--- a/Emby.Common.Implementations/Net/SocketFactory.cs
+++ b/Emby.Common.Implementations/Net/SocketFactory.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading.Tasks;
+using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Net;
 
 namespace Emby.Common.Implementations.Net
@@ -22,16 +23,28 @@ namespace Emby.Common.Implementations.Net
         /// </summary>
         private IPAddress _LocalIP;
 
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        /// <param name="localIP">A string containing the IP address of the local network adapter to bind sockets to. Null or empty string will use <see cref="IPAddress.Any"/>.</param>
-        public SocketFactory(string localIP)
+        private ILogger _logger;
+
+        public SocketFactory(ILogger logger)
+        {
+            _logger = logger;
+            _LocalIP = IPAddress.Any;
+        }
+
+        public ISocket CreateSocket(IpAddressFamily family, MediaBrowser.Model.Net.SocketType socketType, MediaBrowser.Model.Net.ProtocolType protocolType, bool dualMode)
         {
-            if (String.IsNullOrEmpty(localIP))
-                _LocalIP = IPAddress.Any;
-            else
-                _LocalIP = IPAddress.Parse(localIP);
+            var addressFamily = family == IpAddressFamily.InterNetwork
+                ? AddressFamily.InterNetwork
+                : AddressFamily.InterNetworkV6;
+
+            var socket = new Socket(addressFamily, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
+
+            if (dualMode)
+            {
+                socket.DualMode = true;
+            }
+
+            return new NetSocket(socket, _logger);
         }
 
         #region ISocketFactory Members
@@ -44,7 +57,7 @@ namespace Emby.Common.Implementations.Net
         {
             if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort");
 
-            var retVal = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            var retVal = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
             try
             {
                 retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
@@ -68,7 +81,7 @@ namespace Emby.Common.Implementations.Net
         {
             if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort");
 
-            var retVal = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            var retVal = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
             try
             {
                 retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
@@ -99,7 +112,7 @@ namespace Emby.Common.Implementations.Net
             if (multicastTimeToLive <= 0) throw new ArgumentException("multicastTimeToLive cannot be zero or less.", "multicastTimeToLive");
             if (localPort < 0) throw new ArgumentException("localPort cannot be less than zero.", "localPort");
 
-            var retVal = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            var retVal = new Socket(AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp);
 
             try
             {
diff --git a/Emby.Common.Implementations/Net/UdpSocket.cs b/Emby.Common.Implementations/Net/UdpSocket.cs
index d999d3fe8..244b37bb4 100644
--- a/Emby.Common.Implementations/Net/UdpSocket.cs
+++ b/Emby.Common.Implementations/Net/UdpSocket.cs
@@ -5,6 +5,7 @@ using System.Net;
 using System.Net.Sockets;
 using System.Security;
 using System.Threading.Tasks;
+using Emby.Common.Implementations.Networking;
 using MediaBrowser.Model.Net;
 
 namespace Emby.Common.Implementations.Net
@@ -174,16 +175,7 @@ namespace Emby.Common.Implementations.Net
                 return null;
             }
 
-            return new IpEndPointInfo
-            {
-                IpAddress = new IpAddressInfo
-                {
-                    Address = endpoint.Address.ToString(),
-                    IsIpv6 = endpoint.AddressFamily == AddressFamily.InterNetworkV6
-                },
-
-                Port = endpoint.Port
-            };
+            return BaseNetworkManager.ToIpEndPointInfo(endpoint);
         }
 
         private void ProcessResponse(IAsyncResult asyncResult)
diff --git a/Emby.Common.Implementations/Networking/BaseNetworkManager.cs b/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
index 10d0db968..f1ac8413b 100644
--- a/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
+++ b/Emby.Common.Implementations/Networking/BaseNetworkManager.cs
@@ -22,14 +22,10 @@ namespace Emby.Common.Implementations.Networking
             Logger = logger;
         }
 
-        private List<IPAddress> _localIpAddresses;
+        private List<IpAddressInfo> _localIpAddresses;
         private readonly object _localIpAddressSyncLock = new object();
 
-        /// <summary>
-        /// Gets the machine's local ip address
-        /// </summary>
-        /// <returns>IPAddress.</returns>
-		public IEnumerable<IPAddress> GetLocalIpAddresses()
+        public IEnumerable<IpAddressInfo> GetLocalIpAddresses()
         {
             const int cacheMinutes = 5;
 
@@ -39,7 +35,7 @@ namespace Emby.Common.Implementations.Networking
 
                 if (_localIpAddresses == null || forceRefresh)
                 {
-                    var addresses = GetLocalIpAddressesInternal().ToList();
+                    var addresses = GetLocalIpAddressesInternal().Select(ToIpAddressInfo).ToList();
 
                     _localIpAddresses = addresses;
                     _lastRefresh = DateTime.UtcNow;
@@ -405,18 +401,85 @@ namespace Emby.Common.Implementations.Networking
             IPAddress address;
             if (IPAddress.TryParse(ipAddress, out address))
             {
-
-                ipAddressInfo = new IpAddressInfo
-                {
-                    Address = address.ToString(),
-                    IsIpv6 = address.AddressFamily == AddressFamily.InterNetworkV6
-                };
-
+                ipAddressInfo = ToIpAddressInfo(address);
                 return true;
             }
 
             ipAddressInfo = null;
             return false;
         }
+
+        public static IpEndPointInfo ToIpEndPointInfo(IPEndPoint endpoint)
+        {
+            if (endpoint == null)
+            {
+                return null;
+            }
+
+            return new IpEndPointInfo(ToIpAddressInfo(endpoint.Address), endpoint.Port);
+        }
+
+        public static IPEndPoint ToIPEndPoint(IpEndPointInfo endpoint)
+        {
+            if (endpoint == null)
+            {
+                return null;
+            }
+
+            return new IPEndPoint(ToIPAddress(endpoint.IpAddress), endpoint.Port);
+        }
+
+        public static IPAddress ToIPAddress(IpAddressInfo address)
+        {
+            if (address.Equals(IpAddressInfo.Any))
+            {
+                return IPAddress.Any;
+            }
+            if (address.Equals(IpAddressInfo.IPv6Any))
+            {
+                return IPAddress.IPv6Any;
+            }
+            if (address.Equals(IpAddressInfo.Loopback))
+            {
+                return IPAddress.Loopback;
+            }
+            if (address.Equals(IpAddressInfo.IPv6Loopback))
+            {
+                return IPAddress.IPv6Loopback;
+            }
+
+            return IPAddress.Parse(address.Address);
+        }
+
+        public static IpAddressInfo ToIpAddressInfo(IPAddress address)
+        {
+            if (address.Equals(IPAddress.Any))
+            {
+                return IpAddressInfo.Any;
+            }
+            if (address.Equals(IPAddress.IPv6Any))
+            {
+                return IpAddressInfo.IPv6Any;
+            }
+            if (address.Equals(IPAddress.Loopback))
+            {
+                return IpAddressInfo.Loopback;
+            }
+            if (address.Equals(IPAddress.IPv6Loopback))
+            {
+                return IpAddressInfo.IPv6Loopback;
+            }
+            return new IpAddressInfo
+            {
+                Address = address.ToString(),
+                AddressFamily = address.AddressFamily == AddressFamily.InterNetworkV6 ? IpAddressFamily.InterNetworkV6 : IpAddressFamily.InterNetwork
+            };
+        }
+
+        public async Task<IpAddressInfo[]> GetHostAddressesAsync(string host)
+        {
+            var addresses = await Dns.GetHostAddressesAsync(host).ConfigureAwait(false);
+            return addresses.Select(ToIpAddressInfo).ToArray();
+        }
     }
 }
diff --git a/Emby.Common.Implementations/TextEncoding/TextEncoding.cs b/Emby.Common.Implementations/TextEncoding/TextEncoding.cs
index 35b869e43..254d35222 100644
--- a/Emby.Common.Implementations/TextEncoding/TextEncoding.cs
+++ b/Emby.Common.Implementations/TextEncoding/TextEncoding.cs
@@ -1,10 +1,10 @@
 using System.Text;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace Emby.Common.Implementations.TextEncoding
 {
-    public class TextEncoding : IEncoding
+    public class TextEncoding : ITextEncoding
     {
         private readonly IFileSystem _fileSystem;
 
@@ -13,14 +13,9 @@ namespace Emby.Common.Implementations.TextEncoding
             _fileSystem = fileSystem;
         }
 
-        public byte[] GetASCIIBytes(string text)
+        public Encoding GetASCIIEncoding()
         {
-            return Encoding.ASCII.GetBytes(text);
-        }
-
-        public string GetASCIIString(byte[] bytes, int startIndex, int length)
-        {
-            return Encoding.ASCII.GetString(bytes, 0, bytes.Length);
+            return Encoding.ASCII;
         }
 
         public Encoding GetFileEncoding(string srcFile)
diff --git a/Emby.Dlna/Main/DlnaEntryPoint.cs b/Emby.Dlna/Main/DlnaEntryPoint.cs
index 142b9f96e..ef27c029d 100644
--- a/Emby.Dlna/Main/DlnaEntryPoint.cs
+++ b/Emby.Dlna/Main/DlnaEntryPoint.cs
@@ -250,14 +250,12 @@ namespace Emby.Dlna.Main
                 //    continue;
                 //}
 
-                var addressString = address.ToString();
-
                 var fullService = "urn:schemas-upnp-org:device:MediaServer:1";
 
-                _logger.Info("Registering publisher for {0} on {1}", fullService, addressString);
+                _logger.Info("Registering publisher for {0} on {1}", fullService, address.ToString());
 
                 var descriptorUri = "/dlna/" + udn + "/description.xml";
-                var uri = new Uri(_appHost.GetLocalApiUrl(addressString, address.IsIpv6) + descriptorUri);
+                var uri = new Uri(_appHost.GetLocalApiUrl(address) + descriptorUri);
 
                 var device = new SsdpRootDevice
                 {
diff --git a/Emby.Dlna/PlayTo/PlayToManager.cs b/Emby.Dlna/PlayTo/PlayToManager.cs
index b714f4ac0..a93f7da14 100644
--- a/Emby.Dlna/PlayTo/PlayToManager.cs
+++ b/Emby.Dlna/PlayTo/PlayToManager.cs
@@ -16,6 +16,7 @@ using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Events;
 using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.Net;
 using MediaBrowser.Model.Threading;
 
 namespace Emby.Dlna.PlayTo
@@ -131,11 +132,11 @@ namespace Emby.Dlna.PlayTo
                     string serverAddress;
                     if (info.LocalIpAddress == null)
                     {
-                        serverAddress = await GetServerAddress(null, false).ConfigureAwait(false);
+                        serverAddress = await GetServerAddress(null).ConfigureAwait(false);
                     }
                     else
                     {
-                        serverAddress = await GetServerAddress(info.LocalIpAddress.Address, info.LocalIpAddress.IsIpv6).ConfigureAwait(false);
+                        serverAddress = await GetServerAddress(info.LocalIpAddress).ConfigureAwait(false);
                     }
 
                     string accessToken = null;
@@ -189,14 +190,14 @@ namespace Emby.Dlna.PlayTo
             }
         }
 
-        private Task<string> GetServerAddress(string ipAddress, bool isIpv6)
+        private Task<string> GetServerAddress(IpAddressInfo address)
         {
-            if (string.IsNullOrWhiteSpace(ipAddress))
+            if (address == null)
             {
                 return _appHost.GetLocalApiUrl();
             }
 
-            return Task.FromResult(_appHost.GetLocalApiUrl(ipAddress, isIpv6));
+            return Task.FromResult(_appHost.GetLocalApiUrl(address));
         }
 
         public void Dispose()
diff --git a/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs b/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
index d7574d466..170ef07f3 100644
--- a/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
+++ b/Emby.Server.Implementations/Connect/ConnectEntryPoint.cs
@@ -64,7 +64,7 @@ namespace Emby.Server.Implementations.Connect
                     validIpAddress = await GetIpAddress(ipLookupUrl).ConfigureAwait(false);
 
                     // Try to find the ipv4 address, if present
-                    if (!validIpAddress.IsIpv6)
+                    if (validIpAddress.AddressFamily != IpAddressFamily.InterNetworkV6)
                     {
                         break;
                     }
@@ -77,9 +77,9 @@ namespace Emby.Server.Implementations.Connect
                     _logger.ErrorException("Error getting connection info", ex);
                 }
             }
-
+           
             // If this produced an ipv6 address, try again
-            if (validIpAddress != null && validIpAddress.IsIpv6)
+            if (validIpAddress != null && validIpAddress.AddressFamily == IpAddressFamily.InterNetworkV6)
             {
                 foreach (var ipLookupUrl in _ipLookups)
                 {
@@ -88,7 +88,7 @@ namespace Emby.Server.Implementations.Connect
                         var newAddress = await GetIpAddress(ipLookupUrl, true).ConfigureAwait(false);
 
                         // Try to find the ipv4 address, if present
-                        if (!newAddress.IsIpv6)
+                        if (newAddress.AddressFamily != IpAddressFamily.InterNetworkV6)
                         {
                             validIpAddress = newAddress;
                             break;
diff --git a/Emby.Server.Implementations/Connect/ConnectManager.cs b/Emby.Server.Implementations/Connect/ConnectManager.cs
index 6c2ac40c3..079bfe868 100644
--- a/Emby.Server.Implementations/Connect/ConnectManager.cs
+++ b/Emby.Server.Implementations/Connect/ConnectManager.cs
@@ -74,7 +74,7 @@ namespace Emby.Server.Implementations.Connect
 
                 if (string.IsNullOrWhiteSpace(address) && DiscoveredWanIpAddress != null)
                 {
-                    if (DiscoveredWanIpAddress.IsIpv6)
+                    if (DiscoveredWanIpAddress.AddressFamily == IpAddressFamily.InterNetworkV6)
                     {
                         address = "[" + DiscoveredWanIpAddress + "]";
                     }
diff --git a/Emby.Server.Implementations/Emby.Server.Implementations.csproj b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
index 894ba334d..806702dfd 100644
--- a/Emby.Server.Implementations/Emby.Server.Implementations.csproj
+++ b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
@@ -68,11 +68,18 @@
     <Compile Include="FileOrganization\OrganizerScheduledTask.cs" />
     <Compile Include="FileOrganization\TvFolderOrganizer.cs" />
     <Compile Include="HttpServer\GetSwaggerResource.cs" />
+    <Compile Include="HttpServer\LoggerUtils.cs" />
+    <Compile Include="HttpServer\RangeRequestWriter.cs" />
+    <Compile Include="HttpServer\ResponseFilter.cs" />
+    <Compile Include="HttpServer\SocketSharp\Extensions.cs" />
     <Compile Include="HttpServer\SocketSharp\HttpUtility.cs" />
     <Compile Include="HttpServer\IHttpListener.cs" />
     <Compile Include="HttpServer\Security\AuthorizationContext.cs" />
     <Compile Include="HttpServer\Security\AuthService.cs" />
     <Compile Include="HttpServer\Security\SessionContext.cs" />
+    <Compile Include="HttpServer\SocketSharp\SharpWebSocket.cs" />
+    <Compile Include="HttpServer\SocketSharp\WebSocketSharpListener.cs" />
+    <Compile Include="HttpServer\SocketSharp\WebSocketSharpResponse.cs" />
     <Compile Include="HttpServer\StreamWriter.cs" />
     <Compile Include="HttpServer\SwaggerService.cs" />
     <Compile Include="Images\BaseDynamicImageProvider.cs" />
@@ -254,6 +261,9 @@
       <Project>{442b5058-dcaf-4263-bb6a-f21e31120a1b}</Project>
       <Name>MediaBrowser.Providers</Name>
     </ProjectReference>
+    <Reference Include="SocketHttpListener.Portable">
+      <HintPath>..\ThirdParty\emby\SocketHttpListener.Portable.dll</HintPath>
+    </Reference>
     <Reference Include="UniversalDetector, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\UniversalDetector.1.0.1\lib\portable-net45+sl4+wp71+win8+wpa81\UniversalDetector.dll</HintPath>
       <Private>True</Private>
diff --git a/Emby.Server.Implementations/HttpServer/LoggerUtils.cs b/Emby.Server.Implementations/HttpServer/LoggerUtils.cs
new file mode 100644
index 000000000..8fc92a09a
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/LoggerUtils.cs
@@ -0,0 +1,43 @@
+using MediaBrowser.Model.Logging;
+using System;
+using System.Globalization;
+using SocketHttpListener.Net;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    public static class LoggerUtils
+    {
+        /// <summary>
+        /// Logs the request.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="request">The request.</param>
+        public static void LogRequest(ILogger logger, HttpListenerRequest request)
+        {
+            var url = request.Url.ToString();
+
+            logger.Info("{0} {1}. UserAgent: {2}", request.IsWebSocketRequest ? "WS" : "HTTP " + request.HttpMethod, url, request.UserAgent ?? string.Empty);
+        }
+
+        public static void LogRequest(ILogger logger, string url, string method, string userAgent)
+        {
+            logger.Info("{0} {1}. UserAgent: {2}", "HTTP " + method, url, userAgent ?? string.Empty);
+        }
+
+        /// <summary>
+        /// Logs the response.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="statusCode">The status code.</param>
+        /// <param name="url">The URL.</param>
+        /// <param name="endPoint">The end point.</param>
+        /// <param name="duration">The duration.</param>
+        public static void LogResponse(ILogger logger, int statusCode, string url, string endPoint, TimeSpan duration)
+        {
+            var durationMs = duration.TotalMilliseconds;
+            var logSuffix = durationMs >= 1000 && durationMs < 60000 ? "ms (slow)" : "ms";
+
+            logger.Info("HTTP Response {0} to {1}. Time: {2}{3}. {4}", statusCode, endPoint, Convert.ToInt32(durationMs).ToString(CultureInfo.InvariantCulture), logSuffix, url);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/HttpServer/RangeRequestWriter.cs b/Emby.Server.Implementations/HttpServer/RangeRequestWriter.cs
new file mode 100644
index 000000000..e88994bec
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/RangeRequestWriter.cs
@@ -0,0 +1,224 @@
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Services;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    public class RangeRequestWriter : IAsyncStreamWriter, IHttpResult
+    {
+        /// <summary>
+        /// Gets or sets the source stream.
+        /// </summary>
+        /// <value>The source stream.</value>
+        private Stream SourceStream { get; set; }
+        private string RangeHeader { get; set; }
+        private bool IsHeadRequest { get; set; }
+
+        private long RangeStart { get; set; }
+        private long RangeEnd { get; set; }
+        private long RangeLength { get; set; }
+        private long TotalContentLength { get; set; }
+
+        public Action OnComplete { get; set; }
+        private readonly ILogger _logger;
+
+        private const int BufferSize = 81920;
+
+        /// <summary>
+        /// The _options
+        /// </summary>
+        private readonly Dictionary<string, string> _options = new Dictionary<string, string>();
+
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        public List<Cookie> Cookies { get; private set; }
+
+        /// <summary>
+        /// Additional HTTP Headers
+        /// </summary>
+        /// <value>The headers.</value>
+        public IDictionary<string, string> Headers
+        {
+            get { return _options; }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StreamWriter" /> class.
+        /// </summary>
+        /// <param name="rangeHeader">The range header.</param>
+        /// <param name="source">The source.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
+        public RangeRequestWriter(string rangeHeader, Stream source, string contentType, bool isHeadRequest, ILogger logger)
+        {
+            if (string.IsNullOrEmpty(contentType))
+            {
+                throw new ArgumentNullException("contentType");
+            }
+
+            RangeHeader = rangeHeader;
+            SourceStream = source;
+            IsHeadRequest = isHeadRequest;
+            this._logger = logger;
+
+            ContentType = contentType;
+            Headers["Content-Type"] = contentType;
+            Headers["Accept-Ranges"] = "bytes";
+            StatusCode = HttpStatusCode.PartialContent;
+
+            Cookies = new List<Cookie>();
+            SetRangeValues();
+        }
+
+        /// <summary>
+        /// Sets the range values.
+        /// </summary>
+        private void SetRangeValues()
+        {
+            var requestedRange = RequestedRanges[0];
+
+            TotalContentLength = SourceStream.Length;
+
+            // If the requested range is "0-", we can optimize by just doing a stream copy
+            if (!requestedRange.Value.HasValue)
+            {
+                RangeEnd = TotalContentLength - 1;
+            }
+            else
+            {
+                RangeEnd = requestedRange.Value.Value;
+            }
+
+            RangeStart = requestedRange.Key;
+            RangeLength = 1 + RangeEnd - RangeStart;
+
+            // Content-Length is the length of what we're serving, not the original content
+            Headers["Content-Length"] = RangeLength.ToString(UsCulture);
+            Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", RangeStart, RangeEnd, TotalContentLength);
+
+            if (RangeStart > 0)
+            {
+                SourceStream.Position = RangeStart;
+            }
+        }
+
+        /// <summary>
+        /// The _requested ranges
+        /// </summary>
+        private List<KeyValuePair<long, long?>> _requestedRanges;
+        /// <summary>
+        /// Gets the requested ranges.
+        /// </summary>
+        /// <value>The requested ranges.</value>
+        protected List<KeyValuePair<long, long?>> RequestedRanges
+        {
+            get
+            {
+                if (_requestedRanges == null)
+                {
+                    _requestedRanges = new List<KeyValuePair<long, long?>>();
+
+                    // Example: bytes=0-,32-63
+                    var ranges = RangeHeader.Split('=')[1].Split(',');
+
+                    foreach (var range in ranges)
+                    {
+                        var vals = range.Split('-');
+
+                        long start = 0;
+                        long? end = null;
+
+                        if (!string.IsNullOrEmpty(vals[0]))
+                        {
+                            start = long.Parse(vals[0], UsCulture);
+                        }
+                        if (!string.IsNullOrEmpty(vals[1]))
+                        {
+                            end = long.Parse(vals[1], UsCulture);
+                        }
+
+                        _requestedRanges.Add(new KeyValuePair<long, long?>(start, end));
+                    }
+                }
+
+                return _requestedRanges;
+            }
+        }
+
+        public async Task WriteToAsync(Stream responseStream, CancellationToken cancellationToken)
+        {
+            try
+            {
+                // Headers only
+                if (IsHeadRequest)
+                {
+                    return;
+                }
+
+                using (var source = SourceStream)
+                {
+                    // If the requested range is "0-", we can optimize by just doing a stream copy
+                    if (RangeEnd >= TotalContentLength - 1)
+                    {
+                        await source.CopyToAsync(responseStream, BufferSize).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        await CopyToInternalAsync(source, responseStream, RangeLength).ConfigureAwait(false);
+                    }
+                }
+            }
+            finally
+            {
+                if (OnComplete != null)
+                {
+                    OnComplete();
+                }
+            }
+        }
+
+        private async Task CopyToInternalAsync(Stream source, Stream destination, long copyLength)
+        {
+            var array = new byte[BufferSize];
+            int count;
+            while ((count = await source.ReadAsync(array, 0, array.Length).ConfigureAwait(false)) != 0)
+            {
+                var bytesToCopy = Math.Min(count, copyLength);
+
+                await destination.WriteAsync(array, 0, Convert.ToInt32(bytesToCopy)).ConfigureAwait(false);
+
+                copyLength -= bytesToCopy;
+
+                if (copyLength <= 0)
+                {
+                    break;
+                }
+            }
+        }
+
+        public string ContentType { get; set; }
+
+        public IRequest RequestContext { get; set; }
+
+        public object Response { get; set; }
+
+        public int Status { get; set; }
+
+        public HttpStatusCode StatusCode
+        {
+            get { return (HttpStatusCode)Status; }
+            set { Status = (int)value; }
+        }
+
+        public string StatusDescription { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Emby.Server.Implementations/HttpServer/ResponseFilter.cs b/Emby.Server.Implementations/HttpServer/ResponseFilter.cs
new file mode 100644
index 000000000..6d9d7d921
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/ResponseFilter.cs
@@ -0,0 +1,129 @@
+using MediaBrowser.Model.Logging;
+using System;
+using System.Globalization;
+using System.Text;
+using Emby.Server.Implementations.HttpServer.SocketSharp;
+using MediaBrowser.Model.Services;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    public class ResponseFilter
+    {
+        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+        private readonly ILogger _logger;
+
+        public ResponseFilter(ILogger logger)
+        {
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// Filters the response.
+        /// </summary>
+        /// <param name="req">The req.</param>
+        /// <param name="res">The res.</param>
+        /// <param name="dto">The dto.</param>
+        public void FilterResponse(IRequest req, IResponse res, object dto)
+        {
+            // Try to prevent compatibility view
+            res.AddHeader("X-UA-Compatible", "IE=Edge");
+            res.AddHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Range, X-MediaBrowser-Token, X-Emby-Authorization");
+            res.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+            res.AddHeader("Access-Control-Allow-Origin", "*");
+
+            var exception = dto as Exception;
+
+            if (exception != null)
+            {
+                _logger.ErrorException("Error processing request for {0}", exception, req.RawUrl);
+
+                if (!string.IsNullOrEmpty(exception.Message))
+                {
+                    var error = exception.Message.Replace(Environment.NewLine, " ");
+                    error = RemoveControlCharacters(error);
+
+                    res.AddHeader("X-Application-Error-Code", error);
+                }
+            }
+
+            var vary = "Accept-Encoding";
+
+            var hasHeaders = dto as IHasHeaders;
+            var sharpResponse = res as WebSocketSharpResponse;
+
+            if (hasHeaders != null)
+            {
+                if (!hasHeaders.Headers.ContainsKey("Server"))
+                {
+                    hasHeaders.Headers["Server"] = "Mono-HTTPAPI/1.1, UPnP/1.0 DLNADOC/1.50";
+                    //hasHeaders.Headers["Server"] = "Mono-HTTPAPI/1.1";
+                }
+
+                // Content length has to be explicitly set on on HttpListenerResponse or it won't be happy
+                string contentLength;
+
+                if (hasHeaders.Headers.TryGetValue("Content-Length", out contentLength) && !string.IsNullOrEmpty(contentLength))
+                {
+                    var length = long.Parse(contentLength, UsCulture);
+
+                    if (length > 0)
+                    {
+                        res.SetContentLength(length);
+                        
+                        //var listenerResponse = res.OriginalResponse as HttpListenerResponse;
+
+                        //if (listenerResponse != null)
+                        //{
+                        //    // Disable chunked encoding. Technically this is only needed when using Content-Range, but
+                        //    // anytime we know the content length there's no need for it
+                        //    listenerResponse.SendChunked = false;
+                        //    return;
+                        //}
+
+                        if (sharpResponse != null)
+                        {
+                            sharpResponse.SendChunked = false;
+                        }
+                    }
+                }
+
+                string hasHeadersVary;
+                if (hasHeaders.Headers.TryGetValue("Vary", out hasHeadersVary))
+                {
+                    vary = hasHeadersVary;
+                }
+
+                hasHeaders.Headers["Vary"] = vary;
+            }
+
+            //res.KeepAlive = false;
+
+            // Per Google PageSpeed
+            // This instructs the proxies to cache two versions of the resource: one compressed, and one uncompressed. 
+            // The correct version of the resource is delivered based on the client request header. 
+            // This is a good choice for applications that are singly homed and depend on public proxies for user locality.                        
+            res.AddHeader("Vary", vary);
+        }
+
+        /// <summary>
+        /// Removes the control characters.
+        /// </summary>
+        /// <param name="inString">The in string.</param>
+        /// <returns>System.String.</returns>
+        public static string RemoveControlCharacters(string inString)
+        {
+            if (inString == null) return null;
+
+            var newString = new StringBuilder();
+
+            foreach (var ch in inString)
+            {
+                if (!char.IsControl(ch))
+                {
+                    newString.Append(ch);
+                }
+            }
+            return newString.ToString();
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/HttpServer/SocketSharp/Extensions.cs b/Emby.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
new file mode 100644
index 000000000..07a338f19
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
@@ -0,0 +1,12 @@
+using SocketHttpListener.Net;
+
+namespace Emby.Server.Implementations.HttpServer.SocketSharp
+{
+    public static class Extensions
+    {
+        public static string GetOperationName(this HttpListenerRequest request)
+        {
+            return request.Url.Segments[request.Url.Segments.Length - 1];
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs b/Emby.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
new file mode 100644
index 000000000..0a312f7b9
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
@@ -0,0 +1,166 @@
+using MediaBrowser.Common.Events;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using WebSocketState = MediaBrowser.Model.Net.WebSocketState;
+
+namespace Emby.Server.Implementations.HttpServer.SocketSharp
+{
+    public class SharpWebSocket : IWebSocket
+    {
+        /// <summary>
+        /// The logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        public event EventHandler<EventArgs> Closed;
+
+        /// <summary>
+        /// Gets or sets the web socket.
+        /// </summary>
+        /// <value>The web socket.</value>
+        private SocketHttpListener.WebSocket WebSocket { get; set; }
+
+        private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+        public SharpWebSocket(SocketHttpListener.WebSocket socket, ILogger logger)
+        {
+            if (socket == null)
+            {
+                throw new ArgumentNullException("socket");
+            }
+
+            if (logger == null)
+            {
+                throw new ArgumentNullException("logger");
+            }
+
+            _logger = logger;
+            WebSocket = socket;
+
+            socket.OnMessage += socket_OnMessage;
+            socket.OnClose += socket_OnClose;
+            socket.OnError += socket_OnError;
+
+            WebSocket.ConnectAsServer();
+        }
+
+        void socket_OnError(object sender, SocketHttpListener.ErrorEventArgs e)
+        {
+            _logger.Error("Error in SharpWebSocket: {0}", e.Message ?? string.Empty);
+            //EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger);
+        }
+
+        void socket_OnClose(object sender, SocketHttpListener.CloseEventArgs e)
+        {
+            EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger);
+        }
+
+        void socket_OnMessage(object sender, SocketHttpListener.MessageEventArgs e)
+        {
+            //if (!string.IsNullOrWhiteSpace(e.Data))
+            //{
+            //    if (OnReceive != null)
+            //    {
+            //        OnReceive(e.Data);
+            //    }
+            //    return;
+            //}
+            if (OnReceiveBytes != null)
+            {
+                OnReceiveBytes(e.RawData);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the state.
+        /// </summary>
+        /// <value>The state.</value>
+        public WebSocketState State
+        {
+            get
+            {
+                WebSocketState commonState;
+
+                if (!Enum.TryParse(WebSocket.ReadyState.ToString(), true, out commonState))
+                {
+                    _logger.Warn("Unrecognized WebSocketState: {0}", WebSocket.ReadyState.ToString());
+                }
+
+                return commonState;
+            }
+        }
+
+        /// <summary>
+        /// Sends the async.
+        /// </summary>
+        /// <param name="bytes">The bytes.</param>
+        /// <param name="endOfMessage">if set to <c>true</c> [end of message].</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task SendAsync(byte[] bytes, bool endOfMessage, CancellationToken cancellationToken)
+        {
+            var completionSource = new TaskCompletionSource<bool>();
+
+            WebSocket.SendAsync(bytes, res => completionSource.TrySetResult(true));
+
+            return completionSource.Task;
+        }
+
+        /// <summary>
+        /// Sends the asynchronous.
+        /// </summary>
+        /// <param name="text">The text.</param>
+        /// <param name="endOfMessage">if set to <c>true</c> [end of message].</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task SendAsync(string text, bool endOfMessage, CancellationToken cancellationToken)
+        {
+            var completionSource = new TaskCompletionSource<bool>();
+
+            WebSocket.SendAsync(text, res => completionSource.TrySetResult(true));
+
+            return completionSource.Task;
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                WebSocket.OnMessage -= socket_OnMessage;
+                WebSocket.OnClose -= socket_OnClose;
+                WebSocket.OnError -= socket_OnError;
+
+                _cancellationTokenSource.Cancel();
+
+                WebSocket.Close();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the receive action.
+        /// </summary>
+        /// <value>The receive action.</value>
+        public Action<byte[]> OnReceiveBytes { get; set; }
+
+        /// <summary>
+        /// Gets or sets the on receive.
+        /// </summary>
+        /// <value>The on receive.</value>
+        public Action<string> OnReceive { get; set; }
+    }
+}
diff --git a/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs b/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
new file mode 100644
index 000000000..0cb4d428b
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
@@ -0,0 +1,203 @@
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Logging;
+using SocketHttpListener.Net;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Logging;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Model.Cryptography;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Net;
+using MediaBrowser.Model.Services;
+using MediaBrowser.Model.Text;
+using SocketHttpListener.Primitives;
+
+namespace Emby.Server.Implementations.HttpServer.SocketSharp
+{
+    public class WebSocketSharpListener : IHttpListener
+    {
+        private HttpListener _listener;
+
+        private readonly ILogger _logger;
+        private readonly ICertificate _certificate;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
+        private readonly ITextEncoding _textEncoding;
+        private readonly INetworkManager _networkManager;
+        private readonly ISocketFactory _socketFactory;
+        private readonly ICryptoProvider _cryptoProvider;
+        private readonly IStreamFactory _streamFactory;
+        private readonly Func<HttpListenerContext, IHttpRequest> _httpRequestFactory;
+
+        public WebSocketSharpListener(ILogger logger, ICertificate certificate, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding, INetworkManager networkManager, ISocketFactory socketFactory, ICryptoProvider cryptoProvider, IStreamFactory streamFactory, Func<HttpListenerContext, IHttpRequest> httpRequestFactory)
+        {
+            _logger = logger;
+            _certificate = certificate;
+            _memoryStreamProvider = memoryStreamProvider;
+            _textEncoding = textEncoding;
+            _networkManager = networkManager;
+            _socketFactory = socketFactory;
+            _cryptoProvider = cryptoProvider;
+            _streamFactory = streamFactory;
+            _httpRequestFactory = httpRequestFactory;
+        }
+
+        public Action<Exception, IRequest> ErrorHandler { get; set; }
+        public Func<IHttpRequest, Uri, Task> RequestHandler { get; set; }
+
+        public Action<WebSocketConnectingEventArgs> WebSocketConnecting { get; set; }
+
+        public Action<WebSocketConnectEventArgs> WebSocketConnected { get; set; }
+
+        public void Start(IEnumerable<string> urlPrefixes)
+        {
+            if (_listener == null)
+                _listener = new HttpListener(new PatternsLogger(_logger), _cryptoProvider, _streamFactory, _socketFactory, _networkManager, _textEncoding, _memoryStreamProvider);
+
+            if (_certificate != null)
+            {
+                _listener.LoadCert(_certificate);
+            }
+
+            foreach (var prefix in urlPrefixes)
+            {
+                _logger.Info("Adding HttpListener prefix " + prefix);
+                _listener.Prefixes.Add(prefix);
+            }
+
+            _listener.OnContext = ProcessContext;
+
+            _listener.Start();
+        }
+
+        private void ProcessContext(HttpListenerContext context)
+        {
+            Task.Factory.StartNew(() => InitTask(context));
+        }
+
+        private Task InitTask(HttpListenerContext context)
+        {
+            IHttpRequest httpReq = null;
+            var request = context.Request;
+
+            try
+            {
+                if (request.IsWebSocketRequest)
+                {
+                    LoggerUtils.LogRequest(_logger, request);
+
+                    ProcessWebSocketRequest(context);
+                    return Task.FromResult(true);
+                }
+
+                httpReq = GetRequest(context);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error processing request", ex);
+
+                httpReq = httpReq ?? GetRequest(context);
+                ErrorHandler(ex, httpReq);
+                return Task.FromResult(true);
+            }
+
+            return RequestHandler(httpReq, request.Url);
+        }
+
+        private void ProcessWebSocketRequest(HttpListenerContext ctx)
+        {
+            try
+            {
+                var endpoint = ctx.Request.RemoteEndPoint.ToString();
+                var url = ctx.Request.RawUrl;
+
+                var connectingArgs = new WebSocketConnectingEventArgs
+                {
+                    Url = url,
+                    QueryString = ctx.Request.QueryString,
+                    Endpoint = endpoint
+                };
+
+                if (WebSocketConnecting != null)
+                {
+                    WebSocketConnecting(connectingArgs);
+                }
+
+                if (connectingArgs.AllowConnection)
+                {
+                    _logger.Debug("Web socket connection allowed");
+
+                    var webSocketContext = ctx.AcceptWebSocket(null);
+
+                    if (WebSocketConnected != null)
+                    {
+                        WebSocketConnected(new WebSocketConnectEventArgs
+                        {
+                            Url = url,
+                            QueryString = ctx.Request.QueryString,
+                            WebSocket = new SharpWebSocket(webSocketContext.WebSocket, _logger),
+                            Endpoint = endpoint
+                        });
+                    }
+                }
+                else
+                {
+                    _logger.Warn("Web socket connection not allowed");
+                    ctx.Response.StatusCode = 401;
+                    ctx.Response.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("AcceptWebSocketAsync error", ex);
+                ctx.Response.StatusCode = 500;
+                ctx.Response.Close();
+            }
+        }
+
+        private IHttpRequest GetRequest(HttpListenerContext httpContext)
+        {
+            return _httpRequestFactory(httpContext);
+        }
+
+        public void Stop()
+        {
+            if (_listener != null)
+            {
+                foreach (var prefix in _listener.Prefixes.ToList())
+                {
+                    _listener.Prefixes.Remove(prefix);
+                }
+
+                _listener.Close();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        private bool _disposed;
+        private readonly object _disposeLock = new object();
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed) return;
+
+            lock (_disposeLock)
+            {
+                if (_disposed) return;
+
+                if (disposing)
+                {
+                    Stop();
+                }
+
+                //release unmanaged resources here...
+                _disposed = true;
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs b/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs
new file mode 100644
index 000000000..de0b33fe3
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs
@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Text;
+using MediaBrowser.Model.Logging;
+using HttpListenerResponse = SocketHttpListener.Net.HttpListenerResponse;
+using IHttpResponse = MediaBrowser.Model.Services.IHttpResponse;
+using IRequest = MediaBrowser.Model.Services.IRequest;
+
+namespace Emby.Server.Implementations.HttpServer.SocketSharp
+{
+    public class WebSocketSharpResponse : IHttpResponse
+    {
+        private readonly ILogger _logger;
+        private readonly HttpListenerResponse _response;
+
+        public WebSocketSharpResponse(ILogger logger, HttpListenerResponse response, IRequest request)
+        {
+            _logger = logger;
+            this._response = response;
+            Items = new Dictionary<string, object>();
+            Request = request;
+        }
+
+        public IRequest Request { get; private set; }
+        public bool UseBufferedStream { get; set; }
+        public Dictionary<string, object> Items { get; private set; }
+        public object OriginalResponse
+        {
+            get { return _response; }
+        }
+
+        public int StatusCode
+        {
+            get { return this._response.StatusCode; }
+            set { this._response.StatusCode = value; }
+        }
+
+        public string StatusDescription
+        {
+            get { return this._response.StatusDescription; }
+            set { this._response.StatusDescription = value; }
+        }
+
+        public string ContentType
+        {
+            get { return _response.ContentType; }
+            set { _response.ContentType = value; }
+        }
+
+        //public ICookies Cookies { get; set; }
+
+        public void AddHeader(string name, string value)
+        {
+            if (string.Equals(name, "Content-Type", StringComparison.OrdinalIgnoreCase))
+            {
+                ContentType = value;
+                return;
+            }
+
+            _response.AddHeader(name, value);
+        }
+
+        public string GetHeader(string name)
+        {
+            return _response.Headers[name];
+        }
+
+        public void Redirect(string url)
+        {
+            _response.Redirect(url);
+        }
+
+        public Stream OutputStream
+        {
+            get { return _response.OutputStream; }
+        }
+
+        public object Dto { get; set; }
+
+        public void Write(string text)
+        {
+            var bOutput = System.Text.Encoding.UTF8.GetBytes(text);
+            _response.ContentLength64 = bOutput.Length;
+
+            var outputStream = _response.OutputStream;
+            outputStream.Write(bOutput, 0, bOutput.Length);
+            Close();
+        }
+
+        public void Close()
+        {
+            if (!this.IsClosed)
+            {
+                this.IsClosed = true;
+
+                try
+                {
+                    CloseOutputStream(this._response);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error closing HttpListener output stream", ex);
+                }
+            }
+        }
+
+        public void CloseOutputStream(HttpListenerResponse response)
+        {
+            try
+            {
+                response.OutputStream.Flush();
+                response.OutputStream.Dispose();
+                response.Close();
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error in HttpListenerResponseWrapper: " + ex.Message, ex);
+            }
+        }
+
+        public void End()
+        {
+            Close();
+        }
+
+        public void Flush()
+        {
+            _response.OutputStream.Flush();
+        }
+
+        public bool IsClosed
+        {
+            get;
+            private set;
+        }
+
+        public void SetContentLength(long contentLength)
+        {
+            //you can happily set the Content-Length header in Asp.Net
+            //but HttpListener will complain if you do - you have to set ContentLength64 on the response.
+            //workaround: HttpListener throws "The parameter is incorrect" exceptions when we try to set the Content-Length header
+            _response.ContentLength64 = contentLength;
+        }
+
+        public void SetCookie(Cookie cookie)
+        {
+            var cookieStr = AsHeaderValue(cookie);
+            _response.Headers.Add("Set-Cookie", cookieStr);
+        }
+
+        public static string AsHeaderValue(Cookie cookie)
+        {
+            var defaultExpires = DateTime.MinValue;
+
+            var path = cookie.Expires == defaultExpires
+                ? "/"
+                : cookie.Path ?? "/";
+
+            var sb = new StringBuilder();
+
+            sb.Append($"{cookie.Name}={cookie.Value};path={path}");
+
+            if (cookie.Expires != defaultExpires)
+            {
+                sb.Append($";expires={cookie.Expires:R}");
+            }
+
+            if (!string.IsNullOrEmpty(cookie.Domain))
+            {
+                sb.Append($";domain={cookie.Domain}");
+            }
+            //else if (restrictAllCookiesToDomain != null)
+            //{
+            //    sb.Append($";domain={restrictAllCookiesToDomain}");
+            //}
+
+            if (cookie.Secure)
+            {
+                sb.Append(";Secure");
+            }
+            if (cookie.HttpOnly)
+            {
+                sb.Append(";HttpOnly");
+            }
+
+            return sb.ToString();
+        }
+
+
+        public bool SendChunked
+        {
+            get { return _response.SendChunked; }
+            set { _response.SendChunked = value; }
+        }
+
+        public bool KeepAlive { get; set; }
+
+        public void ClearCookies()
+        {
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/UserManager.cs b/Emby.Server.Implementations/Library/UserManager.cs
index 9c1d7fdf1..2a5706b3b 100644
--- a/Emby.Server.Implementations/Library/UserManager.cs
+++ b/Emby.Server.Implementations/Library/UserManager.cs
@@ -70,10 +70,10 @@ namespace Emby.Server.Implementations.Library
         private readonly Func<IConnectManager> _connectFactory;
         private readonly IServerApplicationHost _appHost;
         private readonly IFileSystem _fileSystem;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
         private readonly string _defaultUserName;
 
-        public UserManager(ILogger logger, IServerConfigurationManager configurationManager, IUserRepository userRepository, IXmlSerializer xmlSerializer, INetworkManager networkManager, Func<IImageProcessor> imageProcessorFactory, Func<IDtoService> dtoServiceFactory, Func<IConnectManager> connectFactory, IServerApplicationHost appHost, IJsonSerializer jsonSerializer, IFileSystem fileSystem, ICryptographyProvider cryptographyProvider, string defaultUserName)
+        public UserManager(ILogger logger, IServerConfigurationManager configurationManager, IUserRepository userRepository, IXmlSerializer xmlSerializer, INetworkManager networkManager, Func<IImageProcessor> imageProcessorFactory, Func<IDtoService> dtoServiceFactory, Func<IConnectManager> connectFactory, IServerApplicationHost appHost, IJsonSerializer jsonSerializer, IFileSystem fileSystem, ICryptoProvider cryptographyProvider, string defaultUserName)
         {
             _logger = logger;
             UserRepository = userRepository;
@@ -334,7 +334,7 @@ namespace Emby.Server.Implementations.Library
         /// <returns>System.String.</returns>
         private string GetSha1String(string str)
         {
-            return BitConverter.ToString(_cryptographyProvider.GetSHA1Bytes(Encoding.UTF8.GetBytes(str))).Replace("-", string.Empty);
+            return BitConverter.ToString(_cryptographyProvider.ComputeSHA1(Encoding.UTF8.GetBytes(str))).Replace("-", string.Empty);
         }
 
         /// <summary>
diff --git a/Emby.Server.Implementations/Security/MBLicenseFile.cs b/Emby.Server.Implementations/Security/MBLicenseFile.cs
index 7cb6165a5..4b6a82b6c 100644
--- a/Emby.Server.Implementations/Security/MBLicenseFile.cs
+++ b/Emby.Server.Implementations/Security/MBLicenseFile.cs
@@ -15,7 +15,7 @@ namespace Emby.Server.Implementations.Security
     {
         private readonly IApplicationPaths _appPaths;
         private readonly IFileSystem _fileSystem;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
         public string RegKey
         {
@@ -43,7 +43,7 @@ namespace Emby.Server.Implementations.Security
         private readonly object _fileLock = new object();
         private string _regKey;
 
-        public MBLicenseFile(IApplicationPaths appPaths, IFileSystem fileSystem, ICryptographyProvider cryptographyProvider)
+        public MBLicenseFile(IApplicationPaths appPaths, IFileSystem fileSystem, ICryptoProvider cryptographyProvider)
         {
             _appPaths = appPaths;
             _fileSystem = fileSystem;
@@ -59,7 +59,7 @@ namespace Emby.Server.Implementations.Security
 
         public void AddRegCheck(string featureId)
         {
-            var key = new Guid(_cryptographyProvider.GetMD5Bytes(Encoding.Unicode.GetBytes(featureId)));
+            var key = new Guid(_cryptographyProvider.ComputeMD5(Encoding.Unicode.GetBytes(featureId)));
             var value = DateTime.UtcNow;
 
             SetUpdateRecord(key, value);
@@ -68,7 +68,7 @@ namespace Emby.Server.Implementations.Security
 
         public void RemoveRegCheck(string featureId)
         {
-            var key = new Guid(_cryptographyProvider.GetMD5Bytes(Encoding.Unicode.GetBytes(featureId)));
+            var key = new Guid(_cryptographyProvider.ComputeMD5(Encoding.Unicode.GetBytes(featureId)));
             DateTime val;
 
             _updateRecords.TryRemove(key, out val);
@@ -79,7 +79,7 @@ namespace Emby.Server.Implementations.Security
         public DateTime LastChecked(string featureId)
         {
             DateTime last;
-            _updateRecords.TryGetValue(new Guid(_cryptographyProvider.GetMD5Bytes(Encoding.Unicode.GetBytes(featureId))), out last);
+            _updateRecords.TryGetValue(new Guid(_cryptographyProvider.ComputeMD5(Encoding.Unicode.GetBytes(featureId))), out last);
 
             // guard agains people just putting a large number in the file
             return last < DateTime.UtcNow ? last : DateTime.MinValue;
diff --git a/Emby.Server.Implementations/Security/PluginSecurityManager.cs b/Emby.Server.Implementations/Security/PluginSecurityManager.cs
index c3a7e9450..61d4f5252 100644
--- a/Emby.Server.Implementations/Security/PluginSecurityManager.cs
+++ b/Emby.Server.Implementations/Security/PluginSecurityManager.cs
@@ -64,7 +64,7 @@ namespace Emby.Server.Implementations.Security
         private readonly ILogger _logger;
         private readonly IApplicationPaths _appPaths;
         private readonly IFileSystem _fileSystem;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
         private IEnumerable<IRequiresRegistration> _registeredEntities;
         protected IEnumerable<IRequiresRegistration> RegisteredEntities
@@ -79,7 +79,7 @@ namespace Emby.Server.Implementations.Security
         /// Initializes a new instance of the <see cref="PluginSecurityManager" /> class.
         /// </summary>
         public PluginSecurityManager(IServerApplicationHost appHost, IHttpClient httpClient, IJsonSerializer jsonSerializer,
-            IApplicationPaths appPaths, ILogManager logManager, IFileSystem fileSystem, ICryptographyProvider cryptographyProvider)
+            IApplicationPaths appPaths, ILogManager logManager, IFileSystem fileSystem, ICryptoProvider cryptographyProvider)
         {
             if (httpClient == null)
             {
diff --git a/Emby.Server.Implementations/ServerManager/ServerManager.cs b/Emby.Server.Implementations/ServerManager/ServerManager.cs
index 83ce0b6a3..f660d01ec 100644
--- a/Emby.Server.Implementations/ServerManager/ServerManager.cs
+++ b/Emby.Server.Implementations/ServerManager/ServerManager.cs
@@ -15,7 +15,7 @@ using System.Threading.Tasks;
 using MediaBrowser.Common.IO;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Services;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace Emby.Server.Implementations.ServerManager
 {
@@ -75,8 +75,8 @@ namespace Emby.Server.Implementations.ServerManager
         private readonly List<IWebSocketListener> _webSocketListeners = new List<IWebSocketListener>();
 
         private bool _disposed;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
-        private readonly IEncoding _textEncoding;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
+        private readonly ITextEncoding _textEncoding;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ServerManager" /> class.
@@ -86,7 +86,7 @@ namespace Emby.Server.Implementations.ServerManager
         /// <param name="logger">The logger.</param>
         /// <param name="configurationManager">The configuration manager.</param>
         /// <exception cref="System.ArgumentNullException">applicationHost</exception>
-        public ServerManager(IServerApplicationHost applicationHost, IJsonSerializer jsonSerializer, ILogger logger, IServerConfigurationManager configurationManager, IMemoryStreamProvider memoryStreamProvider, IEncoding textEncoding)
+        public ServerManager(IServerApplicationHost applicationHost, IJsonSerializer jsonSerializer, ILogger logger, IServerConfigurationManager configurationManager, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding)
         {
             if (applicationHost == null)
             {
diff --git a/Emby.Server.Implementations/ServerManager/WebSocketConnection.cs b/Emby.Server.Implementations/ServerManager/WebSocketConnection.cs
index dd17edea5..4608a13e6 100644
--- a/Emby.Server.Implementations/ServerManager/WebSocketConnection.cs
+++ b/Emby.Server.Implementations/ServerManager/WebSocketConnection.cs
@@ -12,7 +12,7 @@ using System.Threading.Tasks;
 using MediaBrowser.Common.IO;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Services;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 using UniversalDetector;
 
 namespace Emby.Server.Implementations.ServerManager
@@ -77,8 +77,8 @@ namespace Emby.Server.Implementations.ServerManager
         /// </summary>
         /// <value>The query string.</value>
         public QueryParamCollection QueryString { get; set; }
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
-        private readonly IEncoding _textEncoding;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
+        private readonly ITextEncoding _textEncoding;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WebSocketConnection" /> class.
@@ -88,7 +88,7 @@ namespace Emby.Server.Implementations.ServerManager
         /// <param name="jsonSerializer">The json serializer.</param>
         /// <param name="logger">The logger.</param>
         /// <exception cref="System.ArgumentNullException">socket</exception>
-        public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger, IMemoryStreamProvider memoryStreamProvider, IEncoding textEncoding)
+        public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding)
         {
             if (socket == null)
             {
@@ -145,7 +145,7 @@ namespace Emby.Server.Implementations.ServerManager
             }
             else
             {
-                OnReceiveInternal(_textEncoding.GetASCIIString(bytes, 0, bytes.Length));
+                OnReceiveInternal(_textEncoding.GetASCIIEncoding().GetString(bytes, 0, bytes.Length));
             }
         }
         private string DetectCharset(byte[] bytes)
diff --git a/Emby.Server.Implementations/Sync/MediaSync.cs b/Emby.Server.Implementations/Sync/MediaSync.cs
index b420a3df4..fa8388b6c 100644
--- a/Emby.Server.Implementations/Sync/MediaSync.cs
+++ b/Emby.Server.Implementations/Sync/MediaSync.cs
@@ -29,12 +29,12 @@ namespace Emby.Server.Implementations.Sync
         private readonly ILogger _logger;
         private readonly IFileSystem _fileSystem;
         private readonly IConfigurationManager _config;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
         public const string PathSeparatorString = "/";
         public const char PathSeparatorChar = '/';
 
-        public MediaSync(ILogger logger, ISyncManager syncManager, IServerApplicationHost appHost, IFileSystem fileSystem, IConfigurationManager config, ICryptographyProvider cryptographyProvider)
+        public MediaSync(ILogger logger, ISyncManager syncManager, IServerApplicationHost appHost, IFileSystem fileSystem, IConfigurationManager config, ICryptoProvider cryptographyProvider)
         {
             _logger = logger;
             _syncManager = syncManager;
@@ -370,7 +370,7 @@ namespace Emby.Server.Implementations.Sync
 
         private byte[] CreateMd5(byte[] value)
         {
-            return _cryptographyProvider.GetMD5Bytes(value);
+            return _cryptographyProvider.ComputeMD5(value);
         }
 
         public LocalItem CreateLocalItem(IServerSyncProvider provider, SyncedItem syncedItem, SyncJob job, SyncTarget target, BaseItemDto libraryItem, string serverId, string serverName, string originalFileName)
diff --git a/Emby.Server.Implementations/Sync/MultiProviderSync.cs b/Emby.Server.Implementations/Sync/MultiProviderSync.cs
index db6cfcbd6..8189b8550 100644
--- a/Emby.Server.Implementations/Sync/MultiProviderSync.cs
+++ b/Emby.Server.Implementations/Sync/MultiProviderSync.cs
@@ -23,9 +23,9 @@ namespace Emby.Server.Implementations.Sync
         private readonly ILogger _logger;
         private readonly IFileSystem _fileSystem;
         private readonly IConfigurationManager _config;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
-        public MultiProviderSync(SyncManager syncManager, IServerApplicationHost appHost, ILogger logger, IFileSystem fileSystem, IConfigurationManager config, ICryptographyProvider cryptographyProvider)
+        public MultiProviderSync(SyncManager syncManager, IServerApplicationHost appHost, ILogger logger, IFileSystem fileSystem, IConfigurationManager config, ICryptoProvider cryptographyProvider)
         {
             _syncManager = syncManager;
             _appHost = appHost;
diff --git a/Emby.Server.Implementations/Sync/ServerSyncScheduledTask.cs b/Emby.Server.Implementations/Sync/ServerSyncScheduledTask.cs
index 17171633e..09a0bfde4 100644
--- a/Emby.Server.Implementations/Sync/ServerSyncScheduledTask.cs
+++ b/Emby.Server.Implementations/Sync/ServerSyncScheduledTask.cs
@@ -20,9 +20,9 @@ namespace Emby.Server.Implementations.Sync
         private readonly IFileSystem _fileSystem;
         private readonly IServerApplicationHost _appHost;
         private readonly IConfigurationManager _config;
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
-        public ServerSyncScheduledTask(ISyncManager syncManager, ILogger logger, IFileSystem fileSystem, IServerApplicationHost appHost, IConfigurationManager config, ICryptographyProvider cryptographyProvider)
+        public ServerSyncScheduledTask(ISyncManager syncManager, ILogger logger, IFileSystem fileSystem, IServerApplicationHost appHost, IConfigurationManager config, ICryptoProvider cryptographyProvider)
         {
             _syncManager = syncManager;
             _logger = logger;
diff --git a/Emby.Server.Implementations/Sync/SyncManager.cs b/Emby.Server.Implementations/Sync/SyncManager.cs
index d06ed49fd..13f60f5ee 100644
--- a/Emby.Server.Implementations/Sync/SyncManager.cs
+++ b/Emby.Server.Implementations/Sync/SyncManager.cs
@@ -51,7 +51,7 @@ namespace Emby.Server.Implementations.Sync
         private readonly Func<IMediaSourceManager> _mediaSourceManager;
         private readonly IJsonSerializer _json;
         private readonly ITaskManager _taskManager;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         private ISyncProvider[] _providers = { };
 
@@ -61,7 +61,7 @@ namespace Emby.Server.Implementations.Sync
         public event EventHandler<GenericEventArgs<SyncJobItem>> SyncJobItemUpdated;
         public event EventHandler<GenericEventArgs<SyncJobItem>> SyncJobItemCreated;
 
-        public SyncManager(ILibraryManager libraryManager, ISyncRepository repo, IImageProcessor imageProcessor, ILogger logger, IUserManager userManager, Func<IDtoService> dtoService, IServerApplicationHost appHost, ITVSeriesManager tvSeriesManager, Func<IMediaEncoder> mediaEncoder, IFileSystem fileSystem, Func<ISubtitleEncoder> subtitleEncoder, IConfigurationManager config, IUserDataManager userDataManager, Func<IMediaSourceManager> mediaSourceManager, IJsonSerializer json, ITaskManager taskManager, IMemoryStreamProvider memoryStreamProvider)
+        public SyncManager(ILibraryManager libraryManager, ISyncRepository repo, IImageProcessor imageProcessor, ILogger logger, IUserManager userManager, Func<IDtoService> dtoService, IServerApplicationHost appHost, ITVSeriesManager tvSeriesManager, Func<IMediaEncoder> mediaEncoder, IFileSystem fileSystem, Func<ISubtitleEncoder> subtitleEncoder, IConfigurationManager config, IUserDataManager userDataManager, Func<IMediaSourceManager> mediaSourceManager, IJsonSerializer json, ITaskManager taskManager, IMemoryStreamFactory memoryStreamProvider)
         {
             _libraryManager = libraryManager;
             _repo = repo;
diff --git a/Emby.Server.Implementations/Sync/TargetDataProvider.cs b/Emby.Server.Implementations/Sync/TargetDataProvider.cs
index a0e0f4313..fbd82aa7a 100644
--- a/Emby.Server.Implementations/Sync/TargetDataProvider.cs
+++ b/Emby.Server.Implementations/Sync/TargetDataProvider.cs
@@ -26,9 +26,9 @@ namespace Emby.Server.Implementations.Sync
         private readonly IFileSystem _fileSystem;
         private readonly IApplicationPaths _appPaths;
         private readonly IServerApplicationHost _appHost;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public TargetDataProvider(IServerSyncProvider provider, SyncTarget target, IServerApplicationHost appHost, ILogger logger, IJsonSerializer json, IFileSystem fileSystem, IApplicationPaths appPaths, IMemoryStreamProvider memoryStreamProvider)
+        public TargetDataProvider(IServerSyncProvider provider, SyncTarget target, IServerApplicationHost appHost, ILogger logger, IJsonSerializer json, IFileSystem fileSystem, IApplicationPaths appPaths, IMemoryStreamFactory memoryStreamProvider)
         {
             _logger = logger;
             _json = json;
diff --git a/Emby.Server.Implementations/Updates/InstallationManager.cs b/Emby.Server.Implementations/Updates/InstallationManager.cs
index 3c7a8242c..52bf09284 100644
--- a/Emby.Server.Implementations/Updates/InstallationManager.cs
+++ b/Emby.Server.Implementations/Updates/InstallationManager.cs
@@ -119,9 +119,9 @@ namespace Emby.Server.Implementations.Updates
         /// <value>The application host.</value>
         private readonly IApplicationHost _applicationHost;
 
-        private readonly ICryptographyProvider _cryptographyProvider;
+        private readonly ICryptoProvider _cryptographyProvider;
 
-        public InstallationManager(ILogger logger, IApplicationHost appHost, IApplicationPaths appPaths, IHttpClient httpClient, IJsonSerializer jsonSerializer, ISecurityManager securityManager, IConfigurationManager config, IFileSystem fileSystem, ICryptographyProvider cryptographyProvider)
+        public InstallationManager(ILogger logger, IApplicationHost appHost, IApplicationPaths appPaths, IHttpClient httpClient, IJsonSerializer jsonSerializer, ISecurityManager securityManager, IConfigurationManager config, IFileSystem fileSystem, ICryptoProvider cryptographyProvider)
         {
             if (logger == null)
             {
@@ -606,7 +606,7 @@ namespace Emby.Server.Implementations.Updates
             {
                 using (var stream = _fileSystem.OpenRead(tempFile))
                 {
-                    var check = Guid.Parse(BitConverter.ToString(_cryptographyProvider.GetMD5Bytes(stream)).Replace("-", String.Empty));
+                    var check = Guid.Parse(BitConverter.ToString(_cryptographyProvider.ComputeMD5(stream)).Replace("-", String.Empty));
                     if (check != packageChecksum)
                     {
                         throw new Exception(string.Format("Download validation failed for {0}.  Probably corrupted during transfer.", package.name));
diff --git a/MediaBrowser.Api/Dlna/DlnaServerService.cs b/MediaBrowser.Api/Dlna/DlnaServerService.cs
index 93d0b3d55..8125951b5 100644
--- a/MediaBrowser.Api/Dlna/DlnaServerService.cs
+++ b/MediaBrowser.Api/Dlna/DlnaServerService.cs
@@ -111,9 +111,9 @@ namespace MediaBrowser.Api.Dlna
         private readonly IMediaReceiverRegistrar _mediaReceiverRegistrar;
 
         private const string XMLContentType = "text/xml; charset=UTF-8";
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public DlnaServerService(IDlnaManager dlnaManager, IContentDirectory contentDirectory, IConnectionManager connectionManager, IMediaReceiverRegistrar mediaReceiverRegistrar, IMemoryStreamProvider memoryStreamProvider)
+        public DlnaServerService(IDlnaManager dlnaManager, IContentDirectory contentDirectory, IConnectionManager connectionManager, IMediaReceiverRegistrar mediaReceiverRegistrar, IMemoryStreamFactory memoryStreamProvider)
         {
             _dlnaManager = dlnaManager;
             _contentDirectory = contentDirectory;
diff --git a/MediaBrowser.Api/Playback/BaseStreamingService.cs b/MediaBrowser.Api/Playback/BaseStreamingService.cs
index c62889214..4fa663b19 100644
--- a/MediaBrowser.Api/Playback/BaseStreamingService.cs
+++ b/MediaBrowser.Api/Playback/BaseStreamingService.cs
@@ -1263,6 +1263,7 @@ namespace MediaBrowser.Api.Playback
 
         private bool EnableThrottling(StreamState state)
         {
+            return false;
             // do not use throttling with hardware encoders
             return state.InputProtocol == MediaProtocol.File &&
                 state.RunTimeTicks.HasValue &&
diff --git a/MediaBrowser.Common/Extensions/BaseExtensions.cs b/MediaBrowser.Common/Extensions/BaseExtensions.cs
index 09f6e8706..d7f4424fa 100644
--- a/MediaBrowser.Common/Extensions/BaseExtensions.cs
+++ b/MediaBrowser.Common/Extensions/BaseExtensions.cs
@@ -10,7 +10,7 @@ namespace MediaBrowser.Common.Extensions
     /// </summary>
     public static class BaseExtensions
     {
-        public static ICryptographyProvider CryptographyProvider { get; set; }
+        public static ICryptoProvider CryptographyProvider { get; set; }
 
         /// <summary>
         /// Strips the HTML.
diff --git a/MediaBrowser.Common/Net/INetworkManager.cs b/MediaBrowser.Common/Net/INetworkManager.cs
index fe60c7ebf..779db0a82 100644
--- a/MediaBrowser.Common/Net/INetworkManager.cs
+++ b/MediaBrowser.Common/Net/INetworkManager.cs
@@ -2,6 +2,7 @@ using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Net;
 using System.Collections.Generic;
 using System.Net;
+using System.Threading.Tasks;
 
 namespace MediaBrowser.Common.Net
 {
@@ -46,10 +47,14 @@ namespace MediaBrowser.Common.Net
         /// <returns><c>true</c> if [is in local network] [the specified endpoint]; otherwise, <c>false</c>.</returns>
         bool IsInLocalNetwork(string endpoint);
 
+        IEnumerable<IpAddressInfo> GetLocalIpAddresses();
+
         IpAddressInfo ParseIpAddress(string ipAddress);
 
         bool TryParseIpAddress(string ipAddress, out IpAddressInfo ipAddressInfo);
 
+        Task<IpAddressInfo[]> GetHostAddressesAsync(string host);
+
         /// <summary>
         /// Generates a self signed certificate at the locatation specified by <paramref name="certificatePath"/>.
         /// </summary>
diff --git a/MediaBrowser.Controller/IServerApplicationHost.cs b/MediaBrowser.Controller/IServerApplicationHost.cs
index 2fd96577a..d2cf23f43 100644
--- a/MediaBrowser.Controller/IServerApplicationHost.cs
+++ b/MediaBrowser.Controller/IServerApplicationHost.cs
@@ -85,7 +85,7 @@ namespace MediaBrowser.Controller
         /// <summary>
         /// Gets the local API URL.
         /// </summary>
-        string GetLocalApiUrl(string ipAddress, bool isIpv6);
+        string GetLocalApiUrl(IpAddressInfo address);
 
         void LaunchUrl(string url);
 
diff --git a/MediaBrowser.Controller/MediaEncoding/MediaStreamSelector.cs b/MediaBrowser.Controller/MediaEncoding/MediaStreamSelector.cs
index 52199c5a2..8169cc7d9 100644
--- a/MediaBrowser.Controller/MediaEncoding/MediaStreamSelector.cs
+++ b/MediaBrowser.Controller/MediaEncoding/MediaStreamSelector.cs
@@ -69,7 +69,8 @@ namespace MediaBrowser.Controller.MediaEncoding
                 // if the audio language is not understood by the user, load their preferred subs, if there are any
                 if (!ContainsOrdinal(preferredLanguages, audioTrackLanguage))
                 {
-                    stream = streams.Where(s => !s.IsForced).FirstOrDefault(s => ContainsOrdinal(preferredLanguages, s.Language));
+                    stream = streams.Where(s => !s.IsForced).FirstOrDefault(s => ContainsOrdinal(preferredLanguages, s.Language)) ??
+                        streams.FirstOrDefault(s => ContainsOrdinal(preferredLanguages, s.Language));
                 }
             }
             else if (mode == SubtitlePlaybackMode.Always)
diff --git a/MediaBrowser.Controller/Net/AuthenticatedAttribute.cs b/MediaBrowser.Controller/Net/AuthenticatedAttribute.cs
index d45416f53..b025011d7 100644
--- a/MediaBrowser.Controller/Net/AuthenticatedAttribute.cs
+++ b/MediaBrowser.Controller/Net/AuthenticatedAttribute.cs
@@ -7,7 +7,7 @@ namespace MediaBrowser.Controller.Net
 {
     public class AuthenticatedAttribute : Attribute, IHasRequestFilter, IAuthenticationAttributes
     {
-        public IAuthService AuthService { get; set; }
+        public static IAuthService AuthService { get; set; }
 
         /// <summary>
         /// Gets or sets the roles.
@@ -26,7 +26,7 @@ namespace MediaBrowser.Controller.Net
         /// </summary>
         /// <value><c>true</c> if [allow before startup wizard]; otherwise, <c>false</c>.</value>
         public bool AllowBeforeStartupWizard { get; set; }
-        
+
         /// <summary>
         /// The request filter is executed before the service.
         /// </summary>
@@ -40,15 +40,6 @@ namespace MediaBrowser.Controller.Net
             AuthService.Authenticate(serviceRequest, this);
         }
 
-        /// <summary>
-        /// A new shallow copy of this filter is used on every request.
-        /// </summary>
-        /// <returns>IHasRequestFilter.</returns>
-        public IHasRequestFilter Copy()
-        {
-            return this;
-        }
-
         /// <summary>
         /// Order in which Request Filters are executed.
         /// &lt;0 Executed before global request filters
@@ -60,7 +51,6 @@ namespace MediaBrowser.Controller.Net
             get { return 0; }
         }
 
-
         public IEnumerable<string> GetRoles()
         {
             return (Roles ?? string.Empty).Split(',')
diff --git a/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs b/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs
index ee7cb9dda..bf7343f3d 100644
--- a/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs
+++ b/MediaBrowser.MediaEncoding/BdInfo/BdInfoExaminer.cs
@@ -5,7 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace MediaBrowser.MediaEncoding.BdInfo
 {
@@ -15,9 +15,9 @@ namespace MediaBrowser.MediaEncoding.BdInfo
     public class BdInfoExaminer : IBlurayExaminer
     {
         private readonly IFileSystem _fileSystem;
-        private readonly IEncoding _textEncoding;
+        private readonly ITextEncoding _textEncoding;
 
-        public BdInfoExaminer(IFileSystem fileSystem, IEncoding textEncoding)
+        public BdInfoExaminer(IFileSystem fileSystem, ITextEncoding textEncoding)
         {
             _fileSystem = fileSystem;
             _textEncoding = textEncoding;
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index 098cd14db..0d7a7912a 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -79,7 +79,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
         private readonly IHttpClient _httpClient;
         private readonly IZipClient _zipClient;
         private readonly IProcessFactory _processFactory;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         private readonly List<ProcessWrapper> _runningProcesses = new List<ProcessWrapper>();
         private readonly bool _hasExternalEncoder;
@@ -88,7 +88,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
         private readonly int DefaultImageExtractionTimeoutMs;
         private readonly bool EnableEncoderFontFile;
 
-        public MediaEncoder(ILogger logger, IJsonSerializer jsonSerializer, string ffMpegPath, string ffProbePath, bool hasExternalEncoder, IServerConfigurationManager configurationManager, IFileSystem fileSystem, ILiveTvManager liveTvManager, IIsoManager isoManager, ILibraryManager libraryManager, IChannelManager channelManager, ISessionManager sessionManager, Func<ISubtitleEncoder> subtitleEncoder, Func<IMediaSourceManager> mediaSourceManager, IHttpClient httpClient, IZipClient zipClient, IMemoryStreamProvider memoryStreamProvider, IProcessFactory processFactory, 
+        public MediaEncoder(ILogger logger, IJsonSerializer jsonSerializer, string ffMpegPath, string ffProbePath, bool hasExternalEncoder, IServerConfigurationManager configurationManager, IFileSystem fileSystem, ILiveTvManager liveTvManager, IIsoManager isoManager, ILibraryManager libraryManager, IChannelManager channelManager, ISessionManager sessionManager, Func<ISubtitleEncoder> subtitleEncoder, Func<IMediaSourceManager> mediaSourceManager, IHttpClient httpClient, IZipClient zipClient, IMemoryStreamFactory memoryStreamProvider, IProcessFactory processFactory, 
             int defaultImageExtractionTimeoutMs, 
             bool enableEncoderFontFile)
         {
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index f0c4c465d..6a1583094 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -23,9 +23,9 @@ namespace MediaBrowser.MediaEncoding.Probing
         private readonly CultureInfo _usCulture = new CultureInfo("en-US");
         private readonly ILogger _logger;
         private readonly IFileSystem _fileSystem;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public ProbeResultNormalizer(ILogger logger, IFileSystem fileSystem, IMemoryStreamProvider memoryStreamProvider)
+        public ProbeResultNormalizer(ILogger logger, IFileSystem fileSystem, IMemoryStreamFactory memoryStreamProvider)
         {
             _logger = logger;
             _fileSystem = fileSystem;
diff --git a/MediaBrowser.MediaEncoding/Subtitles/SubtitleEncoder.cs b/MediaBrowser.MediaEncoding/Subtitles/SubtitleEncoder.cs
index 0baee67ea..5d065f528 100644
--- a/MediaBrowser.MediaEncoding/Subtitles/SubtitleEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Subtitles/SubtitleEncoder.cs
@@ -19,7 +19,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Diagnostics;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 using UniversalDetector;
 
 namespace MediaBrowser.MediaEncoding.Subtitles
@@ -34,11 +34,11 @@ namespace MediaBrowser.MediaEncoding.Subtitles
         private readonly IJsonSerializer _json;
         private readonly IHttpClient _httpClient;
         private readonly IMediaSourceManager _mediaSourceManager;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
         private readonly IProcessFactory _processFactory;
-        private readonly IEncoding _textEncoding;
+        private readonly ITextEncoding _textEncoding;
 
-        public SubtitleEncoder(ILibraryManager libraryManager, ILogger logger, IApplicationPaths appPaths, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IJsonSerializer json, IHttpClient httpClient, IMediaSourceManager mediaSourceManager, IMemoryStreamProvider memoryStreamProvider, IProcessFactory processFactory, IEncoding textEncoding)
+        public SubtitleEncoder(ILibraryManager libraryManager, ILogger logger, IApplicationPaths appPaths, IFileSystem fileSystem, IMediaEncoder mediaEncoder, IJsonSerializer json, IHttpClient httpClient, IMediaSourceManager mediaSourceManager, IMemoryStreamFactory memoryStreamProvider, IProcessFactory processFactory, ITextEncoding textEncoding)
         {
             _libraryManager = libraryManager;
             _logger = logger;
diff --git a/MediaBrowser.Model/Cryptography/ICryptoProvider.cs b/MediaBrowser.Model/Cryptography/ICryptoProvider.cs
new file mode 100644
index 000000000..7a82dee52
--- /dev/null
+++ b/MediaBrowser.Model/Cryptography/ICryptoProvider.cs
@@ -0,0 +1,13 @@
+using System;
+using System.IO;
+
+namespace MediaBrowser.Model.Cryptography
+{
+    public interface ICryptoProvider
+    {
+        Guid GetMD5(string str);
+        byte[] ComputeMD5(Stream str);
+        byte[] ComputeMD5(byte[] bytes);
+        byte[] ComputeSHA1(byte[] bytes);
+    }
+}
\ No newline at end of file
diff --git a/MediaBrowser.Model/Cryptography/ICryptographyProvider.cs b/MediaBrowser.Model/Cryptography/ICryptographyProvider.cs
deleted file mode 100644
index a3f86f9e2..000000000
--- a/MediaBrowser.Model/Cryptography/ICryptographyProvider.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System;
-using System.IO;
-
-namespace MediaBrowser.Model.Cryptography
-{
-    public interface ICryptographyProvider
-    {
-        Guid GetMD5(string str);
-        byte[] GetMD5Bytes(string str);
-        byte[] GetSHA1Bytes(byte[] bytes);
-        byte[] GetMD5Bytes(Stream str);
-        byte[] GetMD5Bytes(byte[] bytes);
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Model/IO/IMemoryStreamFactory.cs b/MediaBrowser.Model/IO/IMemoryStreamFactory.cs
new file mode 100644
index 000000000..f4f174643
--- /dev/null
+++ b/MediaBrowser.Model/IO/IMemoryStreamFactory.cs
@@ -0,0 +1,12 @@
+using System.IO;
+
+namespace MediaBrowser.Model.IO
+{
+    public interface IMemoryStreamFactory
+    {
+        MemoryStream CreateNew();
+        MemoryStream CreateNew(int capacity);
+        MemoryStream CreateNew(byte[] buffer);
+        bool TryGetBuffer(MemoryStream stream, out byte[] buffer);
+    }
+}
diff --git a/MediaBrowser.Model/IO/IMemoryStreamProvider.cs b/MediaBrowser.Model/IO/IMemoryStreamProvider.cs
deleted file mode 100644
index 82a758d9a..000000000
--- a/MediaBrowser.Model/IO/IMemoryStreamProvider.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System.IO;
-
-namespace MediaBrowser.Model.IO
-{
-    public interface IMemoryStreamProvider
-    {
-        MemoryStream CreateNew();
-        MemoryStream CreateNew(int capacity);
-        MemoryStream CreateNew(byte[] buffer);
-    }
-}
diff --git a/MediaBrowser.Model/MediaBrowser.Model.csproj b/MediaBrowser.Model/MediaBrowser.Model.csproj
index 52e477b1a..ee7582619 100644
--- a/MediaBrowser.Model/MediaBrowser.Model.csproj
+++ b/MediaBrowser.Model/MediaBrowser.Model.csproj
@@ -100,7 +100,7 @@
     <Compile Include="Connect\PinExchangeResult.cs" />
     <Compile Include="Connect\PinStatusResult.cs" />
     <Compile Include="Connect\UserLinkType.cs" />
-    <Compile Include="Cryptography\ICryptographyProvider.cs" />
+    <Compile Include="Cryptography\ICryptoProvider.cs" />
     <Compile Include="Devices\DeviceOptions.cs" />
     <Compile Include="Devices\DeviceQuery.cs" />
     <Compile Include="Devices\LocalFileInfo.cs" />
@@ -138,17 +138,19 @@
     <Compile Include="Dto\NameIdPair.cs" />
     <Compile Include="Dto\NameValuePair.cs" />
     <Compile Include="Net\IpEndPointInfo.cs" />
+    <Compile Include="Net\ISocket.cs" />
     <Compile Include="Net\ISocketFactory.cs" />
     <Compile Include="Net\IUdpSocket.cs" />
     <Compile Include="Net\SocketReceiveResult.cs" />
+    <Compile Include="Services\IHttpResult.cs" />
     <Compile Include="System\IEnvironmentInfo.cs" />
-    <Compile Include="TextEncoding\IEncoding.cs" />
+    <Compile Include="Text\ITextEncoding.cs" />
     <Compile Include="Extensions\LinqExtensions.cs" />
     <Compile Include="FileOrganization\SmartMatchInfo.cs" />
     <Compile Include="Health\IHealthMonitor.cs" />
     <Compile Include="IO\FileSystemMetadata.cs" />
     <Compile Include="IO\IFileSystem.cs" />
-    <Compile Include="IO\IMemoryStreamProvider.cs" />
+    <Compile Include="IO\IMemoryStreamFactory.cs" />
     <Compile Include="IO\IShortcutHandler.cs" />
     <Compile Include="IO\StreamDefaults.cs" />
     <Compile Include="Globalization\ILocalizationManager.cs" />
diff --git a/MediaBrowser.Model/Net/ISocket.cs b/MediaBrowser.Model/Net/ISocket.cs
new file mode 100644
index 000000000..371fbc567
--- /dev/null
+++ b/MediaBrowser.Model/Net/ISocket.cs
@@ -0,0 +1,16 @@
+using System;
+
+namespace MediaBrowser.Model.Net
+{
+    public interface ISocket : IDisposable
+    {
+        IpEndPointInfo LocalEndPoint { get; }
+        IpEndPointInfo RemoteEndPoint { get; }
+        void Close();
+        void Shutdown(bool both);
+        void Listen(int backlog);
+        void Bind(IpEndPointInfo endpoint);
+
+        void StartAccept(Action<ISocket> onAccept, Func<bool> isClosed);
+    }
+}
diff --git a/MediaBrowser.Model/Net/ISocketFactory.cs b/MediaBrowser.Model/Net/ISocketFactory.cs
index 3f1ddf84f..599292ddf 100644
--- a/MediaBrowser.Model/Net/ISocketFactory.cs
+++ b/MediaBrowser.Model/Net/ISocketFactory.cs
@@ -27,5 +27,17 @@ namespace MediaBrowser.Model.Net
         /// <param name="localPort">The local port to bind to.</param>
         /// <returns>A <see cref="IUdpSocket"/> implementation.</returns>
         IUdpSocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort);
-	}
+
+        ISocket CreateSocket(IpAddressFamily family, SocketType socketType, ProtocolType protocolType, bool dualMode);
+    }
+
+    public enum SocketType
+    {
+        Stream
+    }
+
+    public enum ProtocolType
+    {
+        Tcp
+    }
 }
diff --git a/MediaBrowser.Model/Net/IpAddressInfo.cs b/MediaBrowser.Model/Net/IpAddressInfo.cs
index b48347d1d..47ffe5118 100644
--- a/MediaBrowser.Model/Net/IpAddressInfo.cs
+++ b/MediaBrowser.Model/Net/IpAddressInfo.cs
@@ -4,12 +4,39 @@ namespace MediaBrowser.Model.Net
 {
     public class IpAddressInfo
     {
+        public static IpAddressInfo Any = new IpAddressInfo("0.0.0.0", IpAddressFamily.InterNetwork);
+        public static IpAddressInfo IPv6Any = new IpAddressInfo("00000000000000000000", IpAddressFamily.InterNetworkV6);
+        public static IpAddressInfo Loopback = new IpAddressInfo("127.0.0.1", IpAddressFamily.InterNetwork);
+        public static IpAddressInfo IPv6Loopback = new IpAddressInfo("IPv6Loopback", IpAddressFamily.InterNetworkV6);
+
         public string Address { get; set; }
-        public bool IsIpv6 { get; set; }
+        public IpAddressFamily AddressFamily { get; set; }
+
+        public IpAddressInfo()
+        {
+
+        }
+
+        public IpAddressInfo(string address, IpAddressFamily addressFamily)
+        {
+            Address = address;
+            AddressFamily = addressFamily;
+        }
+
+        public bool Equals(IpAddressInfo address)
+        {
+            return string.Equals(address.Address, Address, StringComparison.OrdinalIgnoreCase);
+        }
 
         public override String ToString()
         {
             return Address;
         }
     }
+
+    public enum IpAddressFamily
+    {
+        InterNetwork,
+        InterNetworkV6
+    }
 }
diff --git a/MediaBrowser.Model/Net/IpEndPointInfo.cs b/MediaBrowser.Model/Net/IpEndPointInfo.cs
index 5fd331a16..b5cadc429 100644
--- a/MediaBrowser.Model/Net/IpEndPointInfo.cs
+++ b/MediaBrowser.Model/Net/IpEndPointInfo.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 
 namespace MediaBrowser.Model.Net
 {
@@ -8,11 +9,22 @@ namespace MediaBrowser.Model.Net
 
         public int Port { get; set; }
 
+        public IpEndPointInfo()
+        {
+
+        }
+
+        public IpEndPointInfo(IpAddressInfo address, int port)
+        {
+            IpAddress = address;
+            Port = port;
+        }
+
         public override string ToString()
         {
             var ipAddresString = IpAddress == null ? string.Empty : IpAddress.ToString();
 
-            return ipAddresString + ":" + this.Port.ToString();
+            return ipAddresString + ":" + Port.ToString(CultureInfo.InvariantCulture);
         }
     }
 }
diff --git a/MediaBrowser.Model/Services/IHasRequestFilter.cs b/MediaBrowser.Model/Services/IHasRequestFilter.cs
index c5c6ccf59..2164179d5 100644
--- a/MediaBrowser.Model/Services/IHasRequestFilter.cs
+++ b/MediaBrowser.Model/Services/IHasRequestFilter.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+
 namespace MediaBrowser.Model.Services
 {
     public interface IHasRequestFilter
@@ -22,11 +17,5 @@ namespace MediaBrowser.Model.Services
         /// <param name="res">The http response wrapper</param>
         /// <param name="requestDto">The request DTO</param>
         void RequestFilter(IRequest req, IResponse res, object requestDto);
-
-        /// <summary>
-        /// A new shallow copy of this filter is used on every request.
-        /// </summary>
-        /// <returns></returns>
-        IHasRequestFilter Copy();
     }
 }
diff --git a/MediaBrowser.Model/Services/IHttpResult.cs b/MediaBrowser.Model/Services/IHttpResult.cs
new file mode 100644
index 000000000..36ffeb284
--- /dev/null
+++ b/MediaBrowser.Model/Services/IHttpResult.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Model.Services
+{
+    public interface IHttpResult : IHasHeaders
+    {
+        /// <summary>
+        /// The HTTP Response Status
+        /// </summary>
+        int Status { get; set; }
+
+        /// <summary>
+        /// The HTTP Response Status Code
+        /// </summary>
+        HttpStatusCode StatusCode { get; set; }
+
+        /// <summary>
+        /// The HTTP Status Description
+        /// </summary>
+        string StatusDescription { get; set; }
+
+        /// <summary>
+        /// The HTTP Response ContentType
+        /// </summary>
+        string ContentType { get; set; }
+
+        /// <summary>
+        /// Additional HTTP Cookies
+        /// </summary>
+        List<Cookie> Cookies { get; }
+
+        /// <summary>
+        /// Response DTO
+        /// </summary>
+        object Response { get; set; }
+
+        /// <summary>
+        /// Holds the request call context
+        /// </summary>
+        IRequest RequestContext { get; set; }
+    }
+}
diff --git a/MediaBrowser.Model/Services/IRequest.cs b/MediaBrowser.Model/Services/IRequest.cs
index 45dc97b76..5dc995b06 100644
--- a/MediaBrowser.Model/Services/IRequest.cs
+++ b/MediaBrowser.Model/Services/IRequest.cs
@@ -60,16 +60,6 @@ namespace MediaBrowser.Model.Services
         QueryParamCollection QueryString { get; }
 
         QueryParamCollection FormData { get; }
-        /// <summary>
-        /// Buffer the Request InputStream so it can be re-read
-        /// </summary>
-        bool UseBufferedStream { get; set; }
-
-        /// <summary>
-        /// The entire string contents of Request.InputStream
-        /// </summary>
-        /// <returns></returns>
-        string GetRawBody();
 
         string RawUrl { get; }
 
diff --git a/MediaBrowser.Model/Services/QueryParamCollection.cs b/MediaBrowser.Model/Services/QueryParamCollection.cs
index 1ab3f0bfb..dfea62821 100644
--- a/MediaBrowser.Model/Services/QueryParamCollection.cs
+++ b/MediaBrowser.Model/Services/QueryParamCollection.cs
@@ -9,7 +9,7 @@ namespace MediaBrowser.Model.Services
     {
         public QueryParamCollection()
         {
-            
+
         }
 
         public QueryParamCollection(IDictionary<string, string> headers)
@@ -30,15 +30,30 @@ namespace MediaBrowser.Model.Services
             return StringComparer.OrdinalIgnoreCase;
         }
 
+        public string GetKey(int index)
+        {
+            return this[index].Name;
+        }
+
+        public string Get(int index)
+        {
+            return this[index].Value;
+        }
+
+        public virtual string[] GetValues(int index)
+        {
+            return new[] { Get(index) };
+        }
+
         /// <summary>
         /// Adds a new query parameter.
         /// </summary>
-        public void Add(string key, string value)
+        public virtual void Add(string key, string value)
         {
             Add(new NameValuePair(key, value));
         }
 
-        public void Set(string key, string value)
+        public virtual void Set(string key, string value)
         {
             if (string.IsNullOrWhiteSpace(value))
             {
@@ -81,17 +96,21 @@ namespace MediaBrowser.Model.Services
         /// </summary>
         /// <returns>The number of parameters that were removed</returns>
         /// <exception cref="ArgumentNullException"><paramref name="name" /> is null.</exception>
-        public int Remove(string name)
+        public virtual int Remove(string name)
         {
             return RemoveAll(p => p.Name == name);
         }
 
         public string Get(string name)
         {
-            return GetValues(name).FirstOrDefault();
+            var stringComparison = GetStringComparison();
+
+            return this.Where(p => string.Equals(p.Name, name, stringComparison))
+                .Select(p => p.Value)
+                .FirstOrDefault();
         }
 
-        public string[] GetValues(string name)
+        public virtual string[] GetValues(string name)
         {
             var stringComparison = GetStringComparison();
 
diff --git a/MediaBrowser.Model/Text/ITextEncoding.cs b/MediaBrowser.Model/Text/ITextEncoding.cs
new file mode 100644
index 000000000..6901f1f94
--- /dev/null
+++ b/MediaBrowser.Model/Text/ITextEncoding.cs
@@ -0,0 +1,10 @@
+using System.Text;
+
+namespace MediaBrowser.Model.Text
+{
+    public interface ITextEncoding
+    {
+        Encoding GetASCIIEncoding();
+        Encoding GetFileEncoding(string path);
+    }
+}
diff --git a/MediaBrowser.Model/TextEncoding/IEncoding.cs b/MediaBrowser.Model/TextEncoding/IEncoding.cs
deleted file mode 100644
index 3d884c9d2..000000000
--- a/MediaBrowser.Model/TextEncoding/IEncoding.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System.Text;
-
-namespace MediaBrowser.Model.TextEncoding
-{
-    public interface IEncoding
-    {
-        byte[] GetASCIIBytes(string text);
-        string GetASCIIString(byte[] bytes, int startIndex, int length);
-
-        Encoding GetFileEncoding(string path);
-    }
-}
diff --git a/MediaBrowser.Providers/Manager/ImageSaver.cs b/MediaBrowser.Providers/Manager/ImageSaver.cs
index d4bfad174..59d67740d 100644
--- a/MediaBrowser.Providers/Manager/ImageSaver.cs
+++ b/MediaBrowser.Providers/Manager/ImageSaver.cs
@@ -40,7 +40,7 @@ namespace MediaBrowser.Providers.Manager
         private readonly ILibraryMonitor _libraryMonitor;
         private readonly IFileSystem _fileSystem;
         private readonly ILogger _logger;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageSaver" /> class.
@@ -49,7 +49,7 @@ namespace MediaBrowser.Providers.Manager
         /// <param name="libraryMonitor">The directory watchers.</param>
         /// <param name="fileSystem">The file system.</param>
         /// <param name="logger">The logger.</param>
-        public ImageSaver(IServerConfigurationManager config, ILibraryMonitor libraryMonitor, IFileSystem fileSystem, ILogger logger, IMemoryStreamProvider memoryStreamProvider)
+        public ImageSaver(IServerConfigurationManager config, ILibraryMonitor libraryMonitor, IFileSystem fileSystem, ILogger logger, IMemoryStreamFactory memoryStreamProvider)
         {
             _config = config;
             _libraryMonitor = libraryMonitor;
diff --git a/MediaBrowser.Providers/Manager/ProviderManager.cs b/MediaBrowser.Providers/Manager/ProviderManager.cs
index 67ad21dbb..5e00b356a 100644
--- a/MediaBrowser.Providers/Manager/ProviderManager.cs
+++ b/MediaBrowser.Providers/Manager/ProviderManager.cs
@@ -66,7 +66,7 @@ namespace MediaBrowser.Providers.Manager
         private IExternalId[] _externalIds;
 
         private readonly Func<ILibraryManager> _libraryManagerFactory;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ProviderManager" /> class.
@@ -76,7 +76,7 @@ namespace MediaBrowser.Providers.Manager
         /// <param name="libraryMonitor">The directory watchers.</param>
         /// <param name="logManager">The log manager.</param>
         /// <param name="fileSystem">The file system.</param>
-        public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, ILibraryMonitor libraryMonitor, ILogManager logManager, IFileSystem fileSystem, IServerApplicationPaths appPaths, Func<ILibraryManager> libraryManagerFactory, IJsonSerializer json, IMemoryStreamProvider memoryStreamProvider)
+        public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, ILibraryMonitor libraryMonitor, ILogManager logManager, IFileSystem fileSystem, IServerApplicationPaths appPaths, Func<ILibraryManager> libraryManagerFactory, IJsonSerializer json, IMemoryStreamFactory memoryStreamProvider)
         {
             _logger = logManager.GetLogger("ProviderManager");
             _httpClient = httpClient;
diff --git a/MediaBrowser.Providers/MediaInfo/SubtitleResolver.cs b/MediaBrowser.Providers/MediaInfo/SubtitleResolver.cs
index e4becec56..313feda52 100644
--- a/MediaBrowser.Providers/MediaInfo/SubtitleResolver.cs
+++ b/MediaBrowser.Providers/MediaInfo/SubtitleResolver.cs
@@ -45,6 +45,11 @@ namespace MediaBrowser.Providers.MediaInfo
 
                 var codec = Path.GetExtension(fullName).ToLower().TrimStart('.');
 
+                if (string.Equals(codec, "txt", StringComparison.OrdinalIgnoreCase))
+                {
+                    codec = "srt";
+                }
+
                 // If the subtitle file matches the video file name
                 if (string.Equals(videoFileNameWithoutExtension, fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
                 {
@@ -74,9 +79,9 @@ namespace MediaBrowser.Providers.MediaInfo
                     // Try to translate to three character code
                     // Be flexible and check against both the full and three character versions
                     var culture = _localization.GetCultures()
-                        .FirstOrDefault(i => string.Equals(i.DisplayName, language, StringComparison.OrdinalIgnoreCase) || 
-                        string.Equals(i.Name, language, StringComparison.OrdinalIgnoreCase) || 
-                        string.Equals(i.ThreeLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase) || 
+                        .FirstOrDefault(i => string.Equals(i.DisplayName, language, StringComparison.OrdinalIgnoreCase) ||
+                        string.Equals(i.Name, language, StringComparison.OrdinalIgnoreCase) ||
+                        string.Equals(i.ThreeLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase) ||
                         string.Equals(i.TwoLetterISOLanguageName, language, StringComparison.OrdinalIgnoreCase));
 
                     if (culture != null)
@@ -119,7 +124,7 @@ namespace MediaBrowser.Providers.MediaInfo
         {
             get
             {
-                return new[] { ".srt", ".ssa", ".ass", ".sub", ".smi", ".sami" };
+                return new[] { ".srt", ".ssa", ".ass", ".sub", ".smi", ".sami", ".txt" };
             }
         }
 
diff --git a/MediaBrowser.Providers/TV/TheTVDB/TvdbSeriesProvider.cs b/MediaBrowser.Providers/TV/TheTVDB/TvdbSeriesProvider.cs
index 66adf6c8a..5147e9d10 100644
--- a/MediaBrowser.Providers/TV/TheTVDB/TvdbSeriesProvider.cs
+++ b/MediaBrowser.Providers/TV/TheTVDB/TvdbSeriesProvider.cs
@@ -40,10 +40,10 @@ namespace MediaBrowser.Providers.TV
         private readonly CultureInfo _usCulture = new CultureInfo("en-US");
         private readonly ILogger _logger;
         private readonly ILibraryManager _libraryManager;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
         private readonly ILocalizationManager _localizationManager;
 
-        public TvdbSeriesProvider(IZipClient zipClient, IHttpClient httpClient, IFileSystem fileSystem, IServerConfigurationManager config, ILogger logger, ILibraryManager libraryManager, IMemoryStreamProvider memoryStreamProvider, IXmlReaderSettingsFactory xmlSettings, ILocalizationManager localizationManager)
+        public TvdbSeriesProvider(IZipClient zipClient, IHttpClient httpClient, IFileSystem fileSystem, IServerConfigurationManager config, ILogger logger, ILibraryManager libraryManager, IMemoryStreamFactory memoryStreamProvider, IXmlReaderSettingsFactory xmlSettings, ILocalizationManager localizationManager)
         {
             _zipClient = zipClient;
             _httpClient = httpClient;
diff --git a/MediaBrowser.Server.Implementations/HttpServer/ContainerAdapter.cs b/MediaBrowser.Server.Implementations/HttpServer/ContainerAdapter.cs
index 93d224b8d..235b62f69 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/ContainerAdapter.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/ContainerAdapter.cs
@@ -6,7 +6,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer
     /// <summary>
     /// Class ContainerAdapter
     /// </summary>
-    class ContainerAdapter : IContainerAdapter, IRelease
+    class ContainerAdapter : IContainerAdapter
     {
         /// <summary>
         /// The _app host
@@ -40,14 +40,5 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         {
             return _appHost.TryResolve<T>();
         }
-
-        /// <summary>
-        /// Releases the specified instance.
-        /// </summary>
-        /// <param name="instance">The instance.</param>
-        public void Release(object instance)
-        {
-            // Leave this empty so SS doesn't try to dispose our objects
-        }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
index 805cb0353..ebb282503 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
@@ -8,24 +8,31 @@ using MediaBrowser.Server.Implementations.HttpServer.SocketSharp;
 using ServiceStack;
 using ServiceStack.Host;
 using ServiceStack.Host.Handlers;
-using ServiceStack.Logging;
 using ServiceStack.Web;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net.Security;
+using System.Net.Sockets;
 using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
+using Emby.Common.Implementations.Net;
 using Emby.Server.Implementations.HttpServer;
 using Emby.Server.Implementations.HttpServer.SocketSharp;
 using MediaBrowser.Common.Net;
 using MediaBrowser.Common.Security;
 using MediaBrowser.Controller;
+using MediaBrowser.Model.Cryptography;
 using MediaBrowser.Model.Extensions;
 using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Net;
 using MediaBrowser.Model.Services;
-using ServiceStack.Api.Swagger;
+using MediaBrowser.Model.Text;
+using SocketHttpListener.Net;
+using SocketHttpListener.Primitives;
 
 namespace MediaBrowser.Server.Implementations.HttpServer
 {
@@ -49,21 +56,28 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
         private readonly IServerConfigurationManager _config;
         private readonly INetworkManager _networkManager;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         private readonly IServerApplicationHost _appHost;
 
+        private readonly ITextEncoding _textEncoding;
+        private readonly ISocketFactory _socketFactory;
+        private readonly ICryptoProvider _cryptoProvider;
+
         public HttpListenerHost(IServerApplicationHost applicationHost,
             ILogManager logManager,
             IServerConfigurationManager config,
             string serviceName,
-            string defaultRedirectPath, INetworkManager networkManager, IMemoryStreamProvider memoryStreamProvider, params Assembly[] assembliesWithServices)
-            : base(serviceName, assembliesWithServices)
+            string defaultRedirectPath, INetworkManager networkManager, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding, ISocketFactory socketFactory, ICryptoProvider cryptoProvider)
+            : base(serviceName, new Assembly[] { })
         {
             _appHost = applicationHost;
             DefaultRedirectPath = defaultRedirectPath;
             _networkManager = networkManager;
             _memoryStreamProvider = memoryStreamProvider;
+            _textEncoding = textEncoding;
+            _socketFactory = socketFactory;
+            _cryptoProvider = cryptoProvider;
             _config = config;
 
             _logger = logManager.GetLogger("HttpServer");
@@ -73,10 +87,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
         public string GlobalResponse { get; set; }
 
-        public override void Configure(Container container)
+        public override void Configure()
         {
             HostConfig.Instance.DefaultRedirectPath = DefaultRedirectPath;
-            HostConfig.Instance.LogUnobservedTaskExceptions = false;
 
             HostConfig.Instance.MapExceptionToStatusCode = new Dictionary<Type, int>
             {
@@ -94,19 +107,12 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             };
 
             HostConfig.Instance.GlobalResponseHeaders = new Dictionary<string, string>();
-            HostConfig.Instance.DebugMode = false;
-
-            HostConfig.Instance.LogFactory = LogManager.LogFactory;
-            HostConfig.Instance.AllowJsonpRequests = false;
 
             // The Markdown feature causes slow startup times (5 mins+) on cold boots for some users
             // Custom format allows images
             HostConfig.Instance.EnableFeatures = Feature.Html | Feature.Json | Feature.Xml | Feature.CustomFormat;
 
-            container.Adapter = _containerAdapter;
-
-            Plugins.Add(new SwaggerFeature());
-            Plugins.Add(new CorsFeature(allowedHeaders: "Content-Type, Authorization, Range, X-MediaBrowser-Token, X-Emby-Authorization"));
+            Container.Adapter = _containerAdapter;
 
             //Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] {
             //    new SessionAuthProvider(_containerAdapter.Resolve<ISessionContext>()),
@@ -130,6 +136,14 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             HostContext.GlobalResponseFilters.Add(new ResponseFilter(_logger).FilterResponse);
         }
 
+        protected override ILogger Logger
+        {
+            get
+            {
+                return _logger;
+            }
+        }
+
         public override void OnAfterInit()
         {
             SetAppDomainData();
@@ -207,7 +221,33 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
         private IHttpListener GetListener()
         {
-            return new WebSocketSharpListener(_logger, CertificatePath, _memoryStreamProvider);
+            var cert = !string.IsNullOrWhiteSpace(CertificatePath) && File.Exists(CertificatePath)
+                ? GetCert(CertificatePath) :
+                null;
+
+            return new WebSocketSharpListener(_logger, cert, _memoryStreamProvider, _textEncoding, _networkManager, _socketFactory, _cryptoProvider, new StreamFactory(), GetRequest);
+        }
+
+        public static ICertificate GetCert(string certificateLocation)
+        {
+            X509Certificate2 localCert = new X509Certificate2(certificateLocation);
+            //localCert.PrivateKey = PrivateKey.CreateFromFile(pvk_file).RSA;
+            if (localCert.PrivateKey == null)
+            {
+                //throw new FileNotFoundException("Secure requested, no private key included", certificateLocation);
+                return null;
+            }
+
+            return new Certificate(localCert);
+        }
+
+        private IHttpRequest GetRequest(HttpListenerContext httpContext)
+        {
+            var operationName = httpContext.Request.GetOperationName();
+
+            var req = new WebSocketSharpRequest(httpContext, operationName, _logger, _memoryStreamProvider);
+
+            return req;
         }
 
         private void OnWebSocketConnecting(WebSocketConnectingEventArgs args)
@@ -259,11 +299,11 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
                 var contentType = httpReq.ResponseContentType;
 
-                var serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
+                var serializer = ContentTypes.Instance.GetResponseSerializer(contentType);
                 if (serializer == null)
                 {
                     contentType = HostContext.Config.DefaultContentType;
-                    serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
+                    serializer = ContentTypes.Instance.GetResponseSerializer(contentType);
                 }
 
                 var httpError = ex as IHttpError;
@@ -411,171 +451,170 @@ namespace MediaBrowser.Server.Implementations.HttpServer
         protected async Task RequestHandler(IHttpRequest httpReq, Uri url)
         {
             var date = DateTime.Now;
-
             var httpRes = httpReq.Response;
+            bool enableLog = false;
+            string urlToLog = null;
+            string remoteIp = null;
 
-            if (_disposed)
+            try
             {
-                httpRes.StatusCode = 503;
-                httpRes.Close();
-                return ;
-            }
+                if (_disposed)
+                {
+                    httpRes.StatusCode = 503;
+                    return;
+                }
 
-            if (!ValidateHost(url))
-            {
-                httpRes.StatusCode = 400;
-                httpRes.ContentType = "text/plain";
-                httpRes.Write("Invalid host");
+                if (!ValidateHost(url))
+                {
+                    httpRes.StatusCode = 400;
+                    httpRes.ContentType = "text/plain";
+                    httpRes.Write("Invalid host");
+                    return;
+                }
 
-                httpRes.Close();
-                return;
-            }
+                if (string.Equals(httpReq.Verb, "OPTIONS", StringComparison.OrdinalIgnoreCase))
+                {
+                    httpRes.StatusCode = 200;
+                    httpRes.AddHeader("Access-Control-Allow-Origin", "*");
+                    httpRes.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+                    httpRes.AddHeader("Access-Control-Allow-Headers",
+                        "Content-Type, Authorization, Range, X-MediaBrowser-Token, X-Emby-Authorization");
+                    httpRes.ContentType = "text/html";
+                    return;
+                }
 
-            if (string.Equals(httpReq.Verb, "OPTIONS", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.StatusCode = 200;
-                httpRes.AddHeader("Access-Control-Allow-Origin", "*");
-                httpRes.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-                httpRes.AddHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Range, X-MediaBrowser-Token, X-Emby-Authorization");
-                httpRes.ContentType = "text/html";
+                var operationName = httpReq.OperationName;
+                var localPath = url.LocalPath;
 
-                httpRes.Close();
-            }
+                var urlString = url.OriginalString;
+                enableLog = EnableLogging(urlString, localPath);
+                urlToLog = urlString;
 
-            var operationName = httpReq.OperationName;
-            var localPath = url.LocalPath;
+                if (enableLog)
+                {
+                    urlToLog = GetUrlToLog(urlString);
+                    remoteIp = httpReq.RemoteIp;
 
-            var urlString = url.OriginalString;
-            var enableLog = EnableLogging(urlString, localPath);
-            var urlToLog = urlString;
+                    LoggerUtils.LogRequest(_logger, urlToLog, httpReq.HttpMethod, httpReq.UserAgent);
+                }
 
-            if (enableLog)
-            {
-                urlToLog = GetUrlToLog(urlString);
-                LoggerUtils.LogRequest(_logger, urlToLog, httpReq.HttpMethod, httpReq.UserAgent);
-            }
+                if (string.Equals(localPath, "/emby/", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(localPath, "/mediabrowser/", StringComparison.OrdinalIgnoreCase))
+                {
+                    RedirectToUrl(httpRes, DefaultRedirectPath);
+                    return;
+                }
+                if (string.Equals(localPath, "/emby", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(localPath, "/mediabrowser", StringComparison.OrdinalIgnoreCase))
+                {
+                    RedirectToUrl(httpRes, "emby/" + DefaultRedirectPath);
+                    return;
+                }
 
-            if (string.Equals(localPath, "/emby/", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(localPath, "/mediabrowser/", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl(DefaultRedirectPath);
-                return;
-            }
-            if (string.Equals(localPath, "/emby", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(localPath, "/mediabrowser", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl("emby/" + DefaultRedirectPath);
-                return;
-            }
+                if (string.Equals(localPath, "/mediabrowser/", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(localPath, "/mediabrowser", StringComparison.OrdinalIgnoreCase) ||
+                    localPath.IndexOf("mediabrowser/web", StringComparison.OrdinalIgnoreCase) != -1)
+                {
+                    httpRes.StatusCode = 200;
+                    httpRes.ContentType = "text/html";
+                    var newUrl = urlString.Replace("mediabrowser", "emby", StringComparison.OrdinalIgnoreCase)
+                        .Replace("/dashboard/", "/web/", StringComparison.OrdinalIgnoreCase);
 
-            if (string.Equals(localPath, "/mediabrowser/", StringComparison.OrdinalIgnoreCase) ||
-                string.Equals(localPath, "/mediabrowser", StringComparison.OrdinalIgnoreCase) ||
-                localPath.IndexOf("mediabrowser/web", StringComparison.OrdinalIgnoreCase) != -1)
-            {
-                httpRes.StatusCode = 200;
-                httpRes.ContentType = "text/html";
-                var newUrl = urlString.Replace("mediabrowser", "emby", StringComparison.OrdinalIgnoreCase)
-                    .Replace("/dashboard/", "/web/", StringComparison.OrdinalIgnoreCase);
+                    if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
+                    {
+                        httpRes.Write(
+                            "<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" +
+                            newUrl + "\">" + newUrl + "</a></body></html>");
+                        return;
+                    }
+                }
 
-                if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
+                if (localPath.IndexOf("dashboard/", StringComparison.OrdinalIgnoreCase) != -1 &&
+                    localPath.IndexOf("web/dashboard", StringComparison.OrdinalIgnoreCase) == -1)
                 {
-                    httpRes.Write("<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" + newUrl + "\">" + newUrl + "</a></body></html>");
+                    httpRes.StatusCode = 200;
+                    httpRes.ContentType = "text/html";
+                    var newUrl = urlString.Replace("mediabrowser", "emby", StringComparison.OrdinalIgnoreCase)
+                        .Replace("/dashboard/", "/web/", StringComparison.OrdinalIgnoreCase);
 
-                    httpRes.Close();
-                    return;
+                    if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
+                    {
+                        httpRes.Write(
+                            "<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" +
+                            newUrl + "\">" + newUrl + "</a></body></html>");
+                        return;
+                    }
                 }
-            }
 
-            if (localPath.IndexOf("dashboard/", StringComparison.OrdinalIgnoreCase) != -1 && 
-                localPath.IndexOf("web/dashboard", StringComparison.OrdinalIgnoreCase) == -1)
-            {
-                httpRes.StatusCode = 200;
-                httpRes.ContentType = "text/html";
-                var newUrl = urlString.Replace("mediabrowser", "emby", StringComparison.OrdinalIgnoreCase)
-                    .Replace("/dashboard/", "/web/", StringComparison.OrdinalIgnoreCase);
+                if (string.Equals(localPath, "/web", StringComparison.OrdinalIgnoreCase))
+                {
+                    RedirectToUrl(httpRes, DefaultRedirectPath);
+                    return;
+                }
+                if (string.Equals(localPath, "/web/", StringComparison.OrdinalIgnoreCase))
+                {
+                    RedirectToUrl(httpRes, "../" + DefaultRedirectPath);
+                    return;
+                }
+                if (string.Equals(localPath, "/", StringComparison.OrdinalIgnoreCase))
+                {
+                    RedirectToUrl(httpRes, DefaultRedirectPath);
+                    return;
+                }
+                if (string.IsNullOrEmpty(localPath))
+                {
+                    RedirectToUrl(httpRes, "/" + DefaultRedirectPath);
+                    return;
+                }
 
-                if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
+                if (string.Equals(localPath, "/emby/pin", StringComparison.OrdinalIgnoreCase))
                 {
-                    httpRes.Write("<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" + newUrl + "\">" + newUrl + "</a></body></html>");
+                    RedirectToUrl(httpRes, "web/pin.html");
+                    return;
+                }
 
-                    httpRes.Close();
+                if (!string.IsNullOrWhiteSpace(GlobalResponse))
+                {
+                    httpRes.StatusCode = 503;
+                    httpRes.ContentType = "text/html";
+                    httpRes.Write(GlobalResponse);
                     return;
                 }
-            }
 
-            if (string.Equals(localPath, "/web", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl(DefaultRedirectPath);
-                return;
-            }
-            if (string.Equals(localPath, "/web/", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl("../" + DefaultRedirectPath);
-                return;
-            }
-            if (string.Equals(localPath, "/", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl(DefaultRedirectPath);
-                return;
-            }
-            if (string.IsNullOrEmpty(localPath))
-            {
-                httpRes.RedirectToUrl("/" + DefaultRedirectPath);
-                return;
-            }
+                var handler = HttpHandlerFactory.GetHandler(httpReq);
 
-            if (string.Equals(localPath, "/emby/pin", StringComparison.OrdinalIgnoreCase))
-            {
-                httpRes.RedirectToUrl("web/pin.html");
-                return;
+                if (handler != null)
+                {
+                    await handler.ProcessRequestAsync(httpReq, httpRes, operationName).ConfigureAwait(false);
+                }
             }
-
-            if (!string.IsNullOrWhiteSpace(GlobalResponse))
+            catch (Exception ex)
             {
-                httpRes.StatusCode = 503;
-                httpRes.ContentType = "text/html";
-                httpRes.Write(GlobalResponse);
-
-                httpRes.Close();
-                return;
+                ErrorHandler(ex, httpReq);
             }
-
-            var handler = HttpHandlerFactory.GetHandler(httpReq);
-
-            var remoteIp = httpReq.RemoteIp;
-
-            var serviceStackHandler = handler as IServiceStackHandler;
-            if (serviceStackHandler != null)
+            finally
             {
-                var restHandler = serviceStackHandler as RestHandler;
-                if (restHandler != null)
-                {
-                    httpReq.OperationName = operationName = restHandler.RestPath.RequestType.GetOperationName();
-                }
+                httpRes.Close();
 
-                try
-                {
-                    await serviceStackHandler.ProcessRequestAsync(httpReq, httpRes, operationName).ConfigureAwait(false);
-                }
-                finally
+                if (enableLog)
                 {
-                    httpRes.Close();
                     var statusCode = httpRes.StatusCode;
 
                     var duration = DateTime.Now - date;
 
-                    if (enableLog)
-                    {
-                        LoggerUtils.LogResponse(_logger, statusCode, urlToLog, remoteIp, duration);
-                    }
+                    LoggerUtils.LogResponse(_logger, statusCode, urlToLog, remoteIp, duration);
                 }
             }
-            else
-            {
-                httpRes.Close();
-            }
         }
 
+        public static void RedirectToUrl(IResponse httpRes, string url)
+        {
+            httpRes.StatusCode = 302;
+            httpRes.AddHeader(HttpHeaders.Location, url);
+            httpRes.EndRequest();
+        }
+
+
         /// <summary>
         /// Adds the rest handlers.
         /// </summary>
@@ -653,15 +692,6 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             return "mediabrowser/" + path;
         }
 
-        /// <summary>
-        /// Releases the specified instance.
-        /// </summary>
-        /// <param name="instance">The instance.</param>
-        public override void Release(object instance)
-        {
-            // Leave this empty so SS doesn't try to dispose our objects
-        }
-
         private bool _disposed;
         private readonly object _disposeLock = new object();
         protected virtual void Dispose(bool disposing)
@@ -696,4 +726,37 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             Start(UrlPrefixes.First());
         }
     }
+
+    public class StreamFactory : IStreamFactory
+    {
+        public Stream CreateNetworkStream(ISocket socket, bool ownsSocket)
+        {
+            var netSocket = (NetSocket)socket;
+
+            return new NetworkStream(netSocket.Socket, ownsSocket);
+        }
+
+        public Task AuthenticateSslStreamAsServer(Stream stream, ICertificate certificate)
+        {
+            var sslStream = (SslStream)stream;
+            var cert = (Certificate)certificate;
+
+            return sslStream.AuthenticateAsServerAsync(cert.X509Certificate);
+        }
+
+        public Stream CreateSslStream(Stream innerStream, bool leaveInnerStreamOpen)
+        {
+            return new SslStream(innerStream, leaveInnerStreamOpen);
+        }
+    }
+
+    public class Certificate : ICertificate
+    {
+        public Certificate(X509Certificate x509Certificate)
+        {
+            X509Certificate = x509Certificate;
+        }
+
+        public X509Certificate X509Certificate { get; private set; }
+    }
 }
\ No newline at end of file
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
index 95e1a35e6..4c251ba24 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
@@ -9,6 +9,7 @@ using System.IO;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
+using Emby.Server.Implementations.HttpServer;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Services;
 using ServiceStack;
diff --git a/MediaBrowser.Server.Implementations/HttpServer/LoggerUtils.cs b/MediaBrowser.Server.Implementations/HttpServer/LoggerUtils.cs
deleted file mode 100644
index bfbb228ed..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/LoggerUtils.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using MediaBrowser.Model.Logging;
-using System;
-using System.Globalization;
-using SocketHttpListener.Net;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    public static class LoggerUtils
-    {
-        /// <summary>
-        /// Logs the request.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="request">The request.</param>
-        public static void LogRequest(ILogger logger, HttpListenerRequest request)
-        {
-            var url = request.Url.ToString();
-
-            logger.Info("{0} {1}. UserAgent: {2}", request.IsWebSocketRequest ? "WS" : "HTTP " + request.HttpMethod, url, request.UserAgent ?? string.Empty);
-        }
-
-        public static void LogRequest(ILogger logger, string url, string method, string userAgent)
-        {
-            logger.Info("{0} {1}. UserAgent: {2}", "HTTP " + method, url, userAgent ?? string.Empty);
-        }
-
-        /// <summary>
-        /// Logs the response.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="statusCode">The status code.</param>
-        /// <param name="url">The URL.</param>
-        /// <param name="endPoint">The end point.</param>
-        /// <param name="duration">The duration.</param>
-        public static void LogResponse(ILogger logger, int statusCode, string url, string endPoint, TimeSpan duration)
-        {
-            var durationMs = duration.TotalMilliseconds;
-            var logSuffix = durationMs >= 1000 && durationMs < 60000 ? "ms (slow)" : "ms";
-
-            logger.Info("HTTP Response {0} to {1}. Time: {2}{3}. {4}", statusCode, endPoint, Convert.ToInt32(durationMs).ToString(CultureInfo.InvariantCulture), logSuffix, url);
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs b/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
deleted file mode 100644
index 7d4cd3b4d..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/RangeRequestWriter.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-using MediaBrowser.Model.Logging;
-using ServiceStack.Web;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Net;
-using System.Threading;
-using System.Threading.Tasks;
-using MediaBrowser.Model.Services;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    public class RangeRequestWriter : IAsyncStreamWriter, IHttpResult
-    {
-        /// <summary>
-        /// Gets or sets the source stream.
-        /// </summary>
-        /// <value>The source stream.</value>
-        private Stream SourceStream { get; set; }
-        private string RangeHeader { get; set; }
-        private bool IsHeadRequest { get; set; }
-
-        private long RangeStart { get; set; }
-        private long RangeEnd { get; set; }
-        private long RangeLength { get; set; }
-        private long TotalContentLength { get; set; }
-
-        public Action OnComplete { get; set; }
-        private readonly ILogger _logger;
-
-        private const int BufferSize = 81920;
-
-        /// <summary>
-        /// The _options
-        /// </summary>
-        private readonly Dictionary<string, string> _options = new Dictionary<string, string>();
-
-        /// <summary>
-        /// The us culture
-        /// </summary>
-        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
-
-        public Func<IDisposable> ResultScope { get; set; }
-        public List<Cookie> Cookies { get; private set; }
-
-        /// <summary>
-        /// Additional HTTP Headers
-        /// </summary>
-        /// <value>The headers.</value>
-        public IDictionary<string, string> Headers
-        {
-            get { return _options; }
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="StreamWriter" /> class.
-        /// </summary>
-        /// <param name="rangeHeader">The range header.</param>
-        /// <param name="source">The source.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
-        public RangeRequestWriter(string rangeHeader, Stream source, string contentType, bool isHeadRequest, ILogger logger)
-        {
-            if (string.IsNullOrEmpty(contentType))
-            {
-                throw new ArgumentNullException("contentType");
-            }
-
-            RangeHeader = rangeHeader;
-            SourceStream = source;
-            IsHeadRequest = isHeadRequest;
-            this._logger = logger;
-
-            ContentType = contentType;
-            Headers["Content-Type"] = contentType;
-            Headers["Accept-Ranges"] = "bytes";
-            StatusCode = HttpStatusCode.PartialContent;
-
-            Cookies = new List<Cookie>();
-            SetRangeValues();
-        }
-
-        /// <summary>
-        /// Sets the range values.
-        /// </summary>
-        private void SetRangeValues()
-        {
-            var requestedRange = RequestedRanges[0];
-
-            TotalContentLength = SourceStream.Length;
-
-            // If the requested range is "0-", we can optimize by just doing a stream copy
-            if (!requestedRange.Value.HasValue)
-            {
-                RangeEnd = TotalContentLength - 1;
-            }
-            else
-            {
-                RangeEnd = requestedRange.Value.Value;
-            }
-
-            RangeStart = requestedRange.Key;
-            RangeLength = 1 + RangeEnd - RangeStart;
-
-            // Content-Length is the length of what we're serving, not the original content
-            Headers["Content-Length"] = RangeLength.ToString(UsCulture);
-            Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", RangeStart, RangeEnd, TotalContentLength);
-
-            if (RangeStart > 0)
-            {
-                SourceStream.Position = RangeStart;
-            }
-        }
-
-        /// <summary>
-        /// The _requested ranges
-        /// </summary>
-        private List<KeyValuePair<long, long?>> _requestedRanges;
-        /// <summary>
-        /// Gets the requested ranges.
-        /// </summary>
-        /// <value>The requested ranges.</value>
-        protected List<KeyValuePair<long, long?>> RequestedRanges
-        {
-            get
-            {
-                if (_requestedRanges == null)
-                {
-                    _requestedRanges = new List<KeyValuePair<long, long?>>();
-
-                    // Example: bytes=0-,32-63
-                    var ranges = RangeHeader.Split('=')[1].Split(',');
-
-                    foreach (var range in ranges)
-                    {
-                        var vals = range.Split('-');
-
-                        long start = 0;
-                        long? end = null;
-
-                        if (!string.IsNullOrEmpty(vals[0]))
-                        {
-                            start = long.Parse(vals[0], UsCulture);
-                        }
-                        if (!string.IsNullOrEmpty(vals[1]))
-                        {
-                            end = long.Parse(vals[1], UsCulture);
-                        }
-
-                        _requestedRanges.Add(new KeyValuePair<long, long?>(start, end));
-                    }
-                }
-
-                return _requestedRanges;
-            }
-        }
-
-        public async Task WriteToAsync(Stream responseStream, CancellationToken cancellationToken)
-        {
-            try
-            {
-                // Headers only
-                if (IsHeadRequest)
-                {
-                    return;
-                }
-
-                using (var source = SourceStream)
-                {
-                    // If the requested range is "0-", we can optimize by just doing a stream copy
-                    if (RangeEnd >= TotalContentLength - 1)
-                    {
-                        await source.CopyToAsync(responseStream, BufferSize).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        await CopyToInternalAsync(source, responseStream, RangeLength).ConfigureAwait(false);
-                    }
-                }
-            }
-            finally
-            {
-                if (OnComplete != null)
-                {
-                    OnComplete();
-                }
-            }
-        }
-
-        private async Task CopyToInternalAsync(Stream source, Stream destination, long copyLength)
-        {
-            var array = new byte[BufferSize];
-            int count;
-            while ((count = await source.ReadAsync(array, 0, array.Length).ConfigureAwait(false)) != 0)
-            {
-                var bytesToCopy = Math.Min(count, copyLength);
-
-                await destination.WriteAsync(array, 0, Convert.ToInt32(bytesToCopy)).ConfigureAwait(false);
-
-                copyLength -= bytesToCopy;
-
-                if (copyLength <= 0)
-                {
-                    break;
-                }
-            }
-        }
-
-        public string ContentType { get; set; }
-
-        public IRequest RequestContext { get; set; }
-
-        public object Response { get; set; }
-
-        public IContentTypeWriter ResponseFilter { get; set; }
-
-        public int Status { get; set; }
-
-        public HttpStatusCode StatusCode
-        {
-            get { return (HttpStatusCode)Status; }
-            set { Status = (int)value; }
-        }
-
-        public string StatusDescription { get; set; }
-
-        public int PaddingLength { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Server.Implementations/HttpServer/ResponseFilter.cs b/MediaBrowser.Server.Implementations/HttpServer/ResponseFilter.cs
deleted file mode 100644
index 6247e4c17..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/ResponseFilter.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Server.Implementations.HttpServer.SocketSharp;
-using System;
-using System.Globalization;
-using System.Net;
-using System.Text;
-using MediaBrowser.Model.Services;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    public class ResponseFilter
-    {
-        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
-        private readonly ILogger _logger;
-
-        public ResponseFilter(ILogger logger)
-        {
-            _logger = logger;
-        }
-
-        /// <summary>
-        /// Filters the response.
-        /// </summary>
-        /// <param name="req">The req.</param>
-        /// <param name="res">The res.</param>
-        /// <param name="dto">The dto.</param>
-        public void FilterResponse(IRequest req, IResponse res, object dto)
-        {
-            // Try to prevent compatibility view
-            res.AddHeader("X-UA-Compatible", "IE=Edge");
-
-            var exception = dto as Exception;
-
-            if (exception != null)
-            {
-                _logger.ErrorException("Error processing request for {0}", exception, req.RawUrl);
-
-                if (!string.IsNullOrEmpty(exception.Message))
-                {
-                    var error = exception.Message.Replace(Environment.NewLine, " ");
-                    error = RemoveControlCharacters(error);
-
-                    res.AddHeader("X-Application-Error-Code", error);
-                }
-            }
-
-            var vary = "Accept-Encoding";
-
-            var hasHeaders = dto as IHasHeaders;
-            var sharpResponse = res as WebSocketSharpResponse;
-
-            if (hasHeaders != null)
-            {
-                if (!hasHeaders.Headers.ContainsKey("Server"))
-                {
-                    hasHeaders.Headers["Server"] = "Mono-HTTPAPI/1.1, UPnP/1.0 DLNADOC/1.50";
-                    //hasHeaders.Headers["Server"] = "Mono-HTTPAPI/1.1";
-                }
-
-                // Content length has to be explicitly set on on HttpListenerResponse or it won't be happy
-                string contentLength;
-
-                if (hasHeaders.Headers.TryGetValue("Content-Length", out contentLength) && !string.IsNullOrEmpty(contentLength))
-                {
-                    var length = long.Parse(contentLength, UsCulture);
-
-                    if (length > 0)
-                    {
-                        res.SetContentLength(length);
-                        
-                        var listenerResponse = res.OriginalResponse as HttpListenerResponse;
-
-                        if (listenerResponse != null)
-                        {
-                            // Disable chunked encoding. Technically this is only needed when using Content-Range, but
-                            // anytime we know the content length there's no need for it
-                            listenerResponse.SendChunked = false;
-                            return;
-                        }
-
-                        if (sharpResponse != null)
-                        {
-                            sharpResponse.SendChunked = false;
-                        }
-                    }
-                }
-
-                string hasHeadersVary;
-                if (hasHeaders.Headers.TryGetValue("Vary", out hasHeadersVary))
-                {
-                    vary = hasHeadersVary;
-                }
-
-                hasHeaders.Headers["Vary"] = vary;
-            }
-
-            //res.KeepAlive = false;
-
-            // Per Google PageSpeed
-            // This instructs the proxies to cache two versions of the resource: one compressed, and one uncompressed. 
-            // The correct version of the resource is delivered based on the client request header. 
-            // This is a good choice for applications that are singly homed and depend on public proxies for user locality.                        
-            res.AddHeader("Vary", vary);
-        }
-
-        /// <summary>
-        /// Removes the control characters.
-        /// </summary>
-        /// <param name="inString">The in string.</param>
-        /// <returns>System.String.</returns>
-        public static string RemoveControlCharacters(string inString)
-        {
-            if (inString == null) return null;
-
-            var newString = new StringBuilder();
-
-            foreach (var ch in inString)
-            {
-                if (!char.IsControl(ch))
-                {
-                    newString.Append(ch);
-                }
-            }
-            return newString.ToString();
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/ServerFactory.cs b/MediaBrowser.Server.Implementations/HttpServer/ServerFactory.cs
index 4dff2d5a3..5da515900 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/ServerFactory.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/ServerFactory.cs
@@ -2,9 +2,11 @@
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Cryptography;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Logging;
-using ServiceStack.Logging;
+using MediaBrowser.Model.Net;
+using MediaBrowser.Model.Text;
 
 namespace MediaBrowser.Server.Implementations.HttpServer
 {
@@ -21,13 +23,14 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             ILogManager logManager,
             IServerConfigurationManager config, 
             INetworkManager networkmanager,
-            IMemoryStreamProvider streamProvider,
+            IMemoryStreamFactory streamProvider,
             string serverName, 
-            string defaultRedirectpath)
+            string defaultRedirectpath,
+            ITextEncoding textEncoding,
+            ISocketFactory socketFactory,
+            ICryptoProvider cryptoProvider)
         {
-            LogManager.LogFactory = new ServerLogFactory(logManager);
-
-            return new HttpListenerHost(applicationHost, logManager, config, serverName, defaultRedirectpath, networkmanager, streamProvider);
+            return new HttpListenerHost(applicationHost, logManager, config, serverName, defaultRedirectpath, networkmanager, streamProvider, textEncoding, socketFactory, cryptoProvider);
         }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/ServerLogFactory.cs b/MediaBrowser.Server.Implementations/HttpServer/ServerLogFactory.cs
deleted file mode 100644
index 40af3f3b0..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/ServerLogFactory.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using MediaBrowser.Model.Logging;
-using ServiceStack.Logging;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    /// <summary>
-    /// Class ServerLogFactory
-    /// </summary>
-    public class ServerLogFactory : ILogFactory
-    {
-        /// <summary>
-        /// The _log manager
-        /// </summary>
-        private readonly ILogManager _logManager;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ServerLogFactory"/> class.
-        /// </summary>
-        /// <param name="logManager">The log manager.</param>
-        public ServerLogFactory(ILogManager logManager)
-        {
-            _logManager = logManager;
-        }
-
-        /// <summary>
-        /// Gets the logger.
-        /// </summary>
-        /// <param name="typeName">Name of the type.</param>
-        /// <returns>ILog.</returns>
-        public ILog GetLogger(string typeName)
-        {
-            return new ServerLogger(_logManager.GetLogger(typeName));
-        }
-
-        /// <summary>
-        /// Gets the logger.
-        /// </summary>
-        /// <param name="type">The type.</param>
-        /// <returns>ILog.</returns>
-        public ILog GetLogger(Type type)
-        {
-            return GetLogger(type.Name);
-        }
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Server.Implementations/HttpServer/ServerLogger.cs b/MediaBrowser.Server.Implementations/HttpServer/ServerLogger.cs
deleted file mode 100644
index bf7924784..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/ServerLogger.cs
+++ /dev/null
@@ -1,194 +0,0 @@
-using MediaBrowser.Model.Logging;
-using ServiceStack.Logging;
-using System;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    /// <summary>
-    /// Class ServerLogger
-    /// </summary>
-    public class ServerLogger : ILog
-    {
-        /// <summary>
-        /// The _logger
-        /// </summary>
-        private readonly ILogger _logger;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ServerLogger"/> class.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        public ServerLogger(ILogger logger)
-        {
-            _logger = logger;
-        }
-
-        /// <summary>
-        /// Logs a Debug message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        /// <param name="exception">The exception.</param>
-        public void Debug(object message, Exception exception)
-        {
-            _logger.ErrorException(GetMesssage(message), exception);
-        }
-
-        /// <summary>
-        /// Logs a Debug message.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public void Debug(object message)
-        {
-            // Way too verbose. Can always make this configurable if needed again.
-            //_logger.Debug(GetMesssage(message));
-        }
-
-        /// <summary>
-        /// Logs a Debug format message.
-        /// </summary>
-        /// <param name="format">The format.</param>
-        /// <param name="args">The args.</param>
-        public void DebugFormat(string format, params object[] args)
-        {
-            // Way too verbose. Can always make this configurable if needed again.
-            //_logger.Debug(format, args);
-        }
-
-        /// <summary>
-        /// Logs a Error message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        /// <param name="exception">The exception.</param>
-        public void Error(object message, Exception exception)
-        {
-            _logger.ErrorException(GetMesssage(message), exception);
-        }
-
-        /// <summary>
-        /// Logs a Error message.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public void Error(object message)
-        {
-            _logger.Error(GetMesssage(message));
-        }
-
-        /// <summary>
-        /// Logs a Error format message.
-        /// </summary>
-        /// <param name="format">The format.</param>
-        /// <param name="args">The args.</param>
-        public void ErrorFormat(string format, params object[] args)
-        {
-            _logger.Error(format, args);
-        }
-
-        /// <summary>
-        /// Logs a Fatal message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        /// <param name="exception">The exception.</param>
-        public void Fatal(object message, Exception exception)
-        {
-            _logger.FatalException(GetMesssage(message), exception);
-        }
-
-        /// <summary>
-        /// Logs a Fatal message.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public void Fatal(object message)
-        {
-            _logger.Fatal(GetMesssage(message));
-        }
-
-        /// <summary>
-        /// Logs a Error format message.
-        /// </summary>
-        /// <param name="format">The format.</param>
-        /// <param name="args">The args.</param>
-        public void FatalFormat(string format, params object[] args)
-        {
-            _logger.Fatal(format, args);
-        }
-
-        /// <summary>
-        /// Logs an Info message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        /// <param name="exception">The exception.</param>
-        public void Info(object message, Exception exception)
-        {
-            _logger.ErrorException(GetMesssage(message), exception);
-        }
-
-        /// <summary>
-        /// Logs an Info message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public void Info(object message)
-        {
-            _logger.Info(GetMesssage(message));
-        }
-
-        /// <summary>
-        /// Logs an Info format message.
-        /// </summary>
-        /// <param name="format">The format.</param>
-        /// <param name="args">The args.</param>
-        public void InfoFormat(string format, params object[] args)
-        {
-            _logger.Info(format, args);
-        }
-
-        /// <summary>
-        /// Gets or sets a value indicating whether this instance is debug enabled.
-        /// </summary>
-        /// <value><c>true</c> if this instance is debug enabled; otherwise, <c>false</c>.</value>
-        public bool IsDebugEnabled
-        {
-            get { return true; }
-        }
-
-        /// <summary>
-        /// Logs a Warning message and exception.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        /// <param name="exception">The exception.</param>
-        public void Warn(object message, Exception exception)
-        {
-            _logger.ErrorException(GetMesssage(message), exception);
-        }
-
-        /// <summary>
-        /// Logs a Warning message.
-        /// </summary>
-        /// <param name="message">The message.</param>
-        public void Warn(object message)
-        {
-            // Hide StringMapTypeDeserializer messages
-            // _logger.Warn(GetMesssage(message));
-        }
-
-        /// <summary>
-        /// Logs a Warning format message.
-        /// </summary>
-        /// <param name="format">The format.</param>
-        /// <param name="args">The args.</param>
-        public void WarnFormat(string format, params object[] args)
-        {
-            // Hide StringMapTypeDeserializer messages
-            // _logger.Warn(format, args);
-        }
-
-        /// <summary>
-        /// Gets the messsage.
-        /// </summary>
-        /// <param name="o">The o.</param>
-        /// <returns>System.String.</returns>
-        private string GetMesssage(object o)
-        {
-            return o == null ? string.Empty : o.ToString();
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/Extensions.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
deleted file mode 100644
index 154313fb9..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/Extensions.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using MediaBrowser.Model.Logging;
-using SocketHttpListener.Net;
-using System;
-
-namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
-{
-    public static class Extensions
-    {
-        public static string GetOperationName(this HttpListenerRequest request)
-        {
-            return request.Url.Segments[request.Url.Segments.Length - 1];
-        }
-
-        public static void CloseOutputStream(this HttpListenerResponse response, ILogger logger)
-        {
-            try
-            {
-                response.OutputStream.Flush();
-                response.OutputStream.Close();
-                response.Close();
-            }
-            catch (Exception ex)
-            {
-                logger.ErrorException("Error in HttpListenerResponseWrapper: " + ex.Message, ex);
-            }
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/RequestMono.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/RequestMono.cs
index 13ae48cff..543eb4afe 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/RequestMono.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/RequestMono.cs
@@ -2,11 +2,10 @@
 using System.Collections.Specialized;
 using System.Globalization;
 using System.IO;
+using System.Net;
 using System.Text;
 using System.Threading.Tasks;
-using System.Web;
 using MediaBrowser.Model.Services;
-using ServiceStack;
 
 namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
 {
@@ -128,7 +127,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return string.IsNullOrEmpty(request.Headers[HttpHeaders.Accept]) ? null : request.Headers[HttpHeaders.Accept];
+                return string.IsNullOrEmpty(request.Headers["Accept"]) ? null : request.Headers["Accept"];
             }
         }
 
@@ -136,7 +135,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return string.IsNullOrEmpty(request.Headers[HttpHeaders.Authorization]) ? null : request.Headers[HttpHeaders.Authorization];
+                return string.IsNullOrEmpty(request.Headers["Authorization"]) ? null : request.Headers["Authorization"];
             }
         }
 
@@ -152,7 +151,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             string msg = String.Format("A potentially dangerous Request.{0} value was " +
                             "detected from the client ({1}={2}).", name, key, v);
 
-            throw new HttpRequestValidationException(msg);
+            throw new Exception(msg);
         }
 
         static void ValidateNameValueCollection(string name, QueryParamCollection coll)
@@ -278,9 +277,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
 
         void AddRawKeyValue(StringBuilder key, StringBuilder value)
         {
-            string decodedKey = HttpUtility.UrlDecode(key.ToString(), ContentEncoding);
+            string decodedKey = WebUtility.UrlDecode(key.ToString());
             form.Add(decodedKey,
-                  HttpUtility.UrlDecode(value.ToString(), ContentEncoding));
+                  WebUtility.UrlDecode(value.ToString()));
 
             key.Length = 0;
             value.Length = 0;
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
deleted file mode 100644
index d363c4de6..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/SharpWebSocket.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-using MediaBrowser.Common.Events;
-using MediaBrowser.Controller.Net;
-using MediaBrowser.Model.Logging;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using WebSocketState = MediaBrowser.Model.Net.WebSocketState;
-
-namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
-{
-    public class SharpWebSocket : IWebSocket
-    {
-        /// <summary>
-        /// The logger
-        /// </summary>
-        private readonly ILogger _logger;
-
-        public event EventHandler<EventArgs> Closed;
-
-        /// <summary>
-        /// Gets or sets the web socket.
-        /// </summary>
-        /// <value>The web socket.</value>
-        private SocketHttpListener.WebSocket WebSocket { get; set; }
-
-        private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="NativeWebSocket" /> class.
-        /// </summary>
-        /// <param name="socket">The socket.</param>
-        /// <param name="logger">The logger.</param>
-        /// <exception cref="System.ArgumentNullException">socket</exception>
-        public SharpWebSocket(SocketHttpListener.WebSocket socket, ILogger logger)
-        {
-            if (socket == null)
-            {
-                throw new ArgumentNullException("socket");
-            }
-
-            if (logger == null)
-            {
-                throw new ArgumentNullException("logger");
-            }
-
-            _logger = logger;
-            WebSocket = socket;
-
-            socket.OnMessage += socket_OnMessage;
-            socket.OnClose += socket_OnClose;
-            socket.OnError += socket_OnError;
-
-            WebSocket.ConnectAsServer();
-        }
-
-        void socket_OnError(object sender, SocketHttpListener.ErrorEventArgs e)
-        {
-            _logger.Error("Error in SharpWebSocket: {0}", e.Message ?? string.Empty);
-            //EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger);
-        }
-
-        void socket_OnClose(object sender, SocketHttpListener.CloseEventArgs e)
-        {
-            EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger);
-        }
-
-        void socket_OnMessage(object sender, SocketHttpListener.MessageEventArgs e)
-        {
-            //if (!string.IsNullOrWhiteSpace(e.Data))
-            //{
-            //    if (OnReceive != null)
-            //    {
-            //        OnReceive(e.Data);
-            //    }
-            //    return;
-            //}
-            if (OnReceiveBytes != null)
-            {
-                OnReceiveBytes(e.RawData);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the state.
-        /// </summary>
-        /// <value>The state.</value>
-        public WebSocketState State
-        {
-            get
-            {
-                WebSocketState commonState;
-
-                if (!Enum.TryParse(WebSocket.ReadyState.ToString(), true, out commonState))
-                {
-                    _logger.Warn("Unrecognized WebSocketState: {0}", WebSocket.ReadyState.ToString());
-                }
-
-                return commonState;
-            }
-        }
-
-        /// <summary>
-        /// Sends the async.
-        /// </summary>
-        /// <param name="bytes">The bytes.</param>
-        /// <param name="endOfMessage">if set to <c>true</c> [end of message].</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task.</returns>
-        public Task SendAsync(byte[] bytes, bool endOfMessage, CancellationToken cancellationToken)
-        {
-            var completionSource = new TaskCompletionSource<bool>();
-
-            WebSocket.SendAsync(bytes, res => completionSource.TrySetResult(true));
-
-            return completionSource.Task;
-        }
-
-        /// <summary>
-        /// Sends the asynchronous.
-        /// </summary>
-        /// <param name="text">The text.</param>
-        /// <param name="endOfMessage">if set to <c>true</c> [end of message].</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task.</returns>
-        public Task SendAsync(string text, bool endOfMessage, CancellationToken cancellationToken)
-        {
-            var completionSource = new TaskCompletionSource<bool>();
-
-            WebSocket.SendAsync(text, res => completionSource.TrySetResult(true));
-
-            return completionSource.Task;
-        }
-
-        /// <summary>
-        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool dispose)
-        {
-            if (dispose)
-            {
-                WebSocket.OnMessage -= socket_OnMessage;
-                WebSocket.OnClose -= socket_OnClose;
-                WebSocket.OnError -= socket_OnError;
-
-                _cancellationTokenSource.Cancel();
-
-                WebSocket.Close();
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the receive action.
-        /// </summary>
-        /// <value>The receive action.</value>
-        public Action<byte[]> OnReceiveBytes { get; set; }
-
-        /// <summary>
-        /// Gets or sets the on receive.
-        /// </summary>
-        /// <value>The on receive.</value>
-        public Action<string> OnReceive { get; set; }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
deleted file mode 100644
index 56f8ab429..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpListener.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-using System.Collections.Specialized;
-using MediaBrowser.Controller.Net;
-using MediaBrowser.Model.Logging;
-using SocketHttpListener.Net;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Emby.Server.Implementations.HttpServer;
-using Emby.Server.Implementations.Logging;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Services;
-using ServiceStack;
-
-namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
-{
-    public class WebSocketSharpListener : IHttpListener
-    {
-        private HttpListener _listener;
-
-        private readonly ILogger _logger;
-        private readonly string _certificatePath;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
-
-        public WebSocketSharpListener(ILogger logger, string certificatePath, IMemoryStreamProvider memoryStreamProvider)
-        {
-            _logger = logger;
-            _certificatePath = certificatePath;
-            _memoryStreamProvider = memoryStreamProvider;
-        }
-
-        public Action<Exception, IRequest> ErrorHandler { get; set; }
-
-        public Func<IHttpRequest, Uri, Task> RequestHandler { get; set; }
-
-        public Action<WebSocketConnectingEventArgs> WebSocketConnecting { get; set; }
-
-        public Action<WebSocketConnectEventArgs> WebSocketConnected { get; set; }
-
-        public void Start(IEnumerable<string> urlPrefixes)
-        {
-            if (_listener == null)
-                _listener = new HttpListener(new PatternsLogger(_logger), _certificatePath);
-
-            foreach (var prefix in urlPrefixes)
-            {
-                _logger.Info("Adding HttpListener prefix " + prefix);
-                _listener.Prefixes.Add(prefix);
-            }
-
-            _listener.OnContext = ProcessContext;
-
-            _listener.Start();
-        }
-
-        private void ProcessContext(HttpListenerContext context)
-        {
-            Task.Factory.StartNew(() => InitTask(context));
-        }
-
-        private void InitTask(HttpListenerContext context)
-        {
-            try
-            {
-                var task = this.ProcessRequestAsync(context);
-                task.ContinueWith(x => HandleError(x.Exception, context), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
-
-                //if (task.Status == TaskStatus.Created)
-                //{
-                //    task.RunSynchronously();
-                //}
-            }
-            catch (Exception ex)
-            {
-                HandleError(ex, context);
-            }
-        }
-
-        private Task ProcessRequestAsync(HttpListenerContext context)
-        {
-            var request = context.Request;
-
-            if (request.IsWebSocketRequest)
-            {
-                LoggerUtils.LogRequest(_logger, request);
-
-                ProcessWebSocketRequest(context);
-                return Task.FromResult(true);
-            }
-
-            if (string.IsNullOrEmpty(context.Request.RawUrl))
-                return ((object)null).AsTaskResult();
-
-            var httpReq = GetRequest(context);
-
-            return RequestHandler(httpReq, request.Url);
-        }
-
-        private void ProcessWebSocketRequest(HttpListenerContext ctx)
-        {
-            try
-            {
-                var endpoint = ctx.Request.RemoteEndPoint.ToString();
-                var url = ctx.Request.RawUrl;
-                var queryString = ctx.Request.QueryString ?? new NameValueCollection();
-
-                var queryParamCollection = new QueryParamCollection();
-
-                foreach (var key in queryString.AllKeys)
-                {
-                    queryParamCollection[key] = queryString[key];
-                }
-
-                var connectingArgs = new WebSocketConnectingEventArgs
-                {
-                    Url = url,
-                    QueryString = queryParamCollection,
-                    Endpoint = endpoint
-                };
-
-                if (WebSocketConnecting != null)
-                {
-                    WebSocketConnecting(connectingArgs);
-                }
-
-                if (connectingArgs.AllowConnection)
-                {
-                    _logger.Debug("Web socket connection allowed");
-
-                    var webSocketContext = ctx.AcceptWebSocket(null);
-
-                    if (WebSocketConnected != null)
-                    {
-                        WebSocketConnected(new WebSocketConnectEventArgs
-                        {
-                            Url = url,
-                            QueryString = queryParamCollection,
-                            WebSocket = new SharpWebSocket(webSocketContext.WebSocket, _logger),
-                            Endpoint = endpoint
-                        });
-                    }
-                }
-                else
-                {
-                    _logger.Warn("Web socket connection not allowed");
-                    ctx.Response.StatusCode = 401;
-                    ctx.Response.Close();
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.ErrorException("AcceptWebSocketAsync error", ex);
-                ctx.Response.StatusCode = 500;
-                ctx.Response.Close();
-            }
-        }
-
-        private IHttpRequest GetRequest(HttpListenerContext httpContext)
-        {
-            var operationName = httpContext.Request.GetOperationName();
-
-            var req = new WebSocketSharpRequest(httpContext, operationName, RequestAttributes.None, _logger, _memoryStreamProvider);
-
-            return req;
-        }
-
-        private void HandleError(Exception ex, HttpListenerContext context)
-        {
-            var httpReq = GetRequest(context);
-
-            if (ErrorHandler != null)
-            {
-                ErrorHandler(ex, httpReq);
-            }
-        }
-
-        public void Stop()
-        {
-            if (_listener != null)
-            {
-                foreach (var prefix in _listener.Prefixes.ToList())
-                {
-                    _listener.Prefixes.Remove(prefix);
-                }
-
-                _listener.Close();
-            }
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        private bool _disposed;
-        private readonly object _disposeLock = new object();
-        protected virtual void Dispose(bool disposing)
-        {
-            if (_disposed) return;
-
-            lock (_disposeLock)
-            {
-                if (_disposed) return;
-
-                if (disposing)
-                {
-                    Stop();
-                }
-
-                //release unmanaged resources here...
-                _disposed = true;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
index 72047609d..6f44fcce7 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
@@ -1,17 +1,14 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.IO;
 using System.Text;
 using Emby.Server.Implementations.HttpServer.SocketSharp;
 using Funq;
-using MediaBrowser.Common.IO;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Services;
 using ServiceStack;
 using ServiceStack.Host;
-using ServiceStack.Web;
 using SocketHttpListener.Net;
 using IHttpFile = MediaBrowser.Model.Services.IHttpFile;
 using IHttpRequest = MediaBrowser.Model.Services.IHttpRequest;
@@ -25,9 +22,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         public Container Container { get; set; }
         private readonly HttpListenerRequest request;
         private readonly IHttpResponse response;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public WebSocketSharpRequest(HttpListenerContext httpContext, string operationName, RequestAttributes requestAttributes, ILogger logger, IMemoryStreamProvider memoryStreamProvider)
+        public WebSocketSharpRequest(HttpListenerContext httpContext, string operationName, ILogger logger, IMemoryStreamFactory memoryStreamProvider)
         {
             this.OperationName = operationName;
             _memoryStreamProvider = memoryStreamProvider;
@@ -55,36 +52,10 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             get { return response; }
         }
 
-        public T TryResolve<T>()
-        {
-            if (typeof(T) == typeof(IHttpRequest))
-                throw new Exception("You don't need to use IHttpRequest.TryResolve<IHttpRequest> to resolve itself");
-
-            if (typeof(T) == typeof(IHttpResponse))
-                throw new Exception("Resolve IHttpResponse with 'Response' property instead of IHttpRequest.TryResolve<IHttpResponse>");
-
-            return Container == null
-                ? HostContext.TryResolve<T>()
-                : Container.TryResolve<T>();
-        }
-
         public string OperationName { get; set; }
 
         public object Dto { get; set; }
 
-        public string GetRawBody()
-        {
-            if (bufferedStream != null)
-            {
-                return bufferedStream.ToArray().FromUtf8Bytes();
-            }
-
-            using (var reader = new StreamReader(InputStream))
-            {
-                return reader.ReadToEnd();
-            }
-        }
-
         public string RawUrl
         {
             get { return request.RawUrl; }
@@ -104,7 +75,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return String.IsNullOrEmpty(request.Headers[HttpHeaders.XForwardedFor]) ? null : request.Headers[HttpHeaders.XForwardedFor];
+                return String.IsNullOrEmpty(request.Headers["X-Forwarded-For"]) ? null : request.Headers["X-Forwarded-For"];
             }
         }
 
@@ -112,7 +83,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return string.IsNullOrEmpty(request.Headers[HttpHeaders.XForwardedPort]) ? (int?)null : int.Parse(request.Headers[HttpHeaders.XForwardedPort]);
+                return string.IsNullOrEmpty(request.Headers["X-Forwarded-Port"]) ? (int?)null : int.Parse(request.Headers["X-Forwarded-Port"]);
             }
         }
 
@@ -120,7 +91,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return string.IsNullOrEmpty(request.Headers[HttpHeaders.XForwardedProtocol]) ? null : request.Headers[HttpHeaders.XForwardedProtocol];
+                return string.IsNullOrEmpty(request.Headers["X-Forwarded-Proto"]) ? null : request.Headers["X-Forwarded-Proto"];
             }
         }
 
@@ -128,7 +99,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
         {
             get
             {
-                return String.IsNullOrEmpty(request.Headers[HttpHeaders.XRealIp]) ? null : request.Headers[HttpHeaders.XRealIp];
+                return String.IsNullOrEmpty(request.Headers["X-Real-IP"]) ? null : request.Headers["X-Real-IP"];
             }
         }
 
@@ -140,7 +111,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
                 return remoteIp ??
                     (remoteIp = (CheckBadChars(XForwardedFor)) ??
                                 (NormalizeIp(CheckBadChars(XRealIp)) ??
-                                (request.RemoteEndPoint != null ? NormalizeIp(request.RemoteEndPoint.Address.ToString()) : null)));
+                                (request.RemoteEndPoint != null ? NormalizeIp(request.RemoteEndPoint.IpAddress.ToString()) : null)));
             }
         }
 
@@ -280,7 +251,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
                 defaultContentType = HostContext.Config.DefaultContentType;
             }
 
-            var customContentTypes = HostContext.ContentTypes.ContentTypeFormats.Values;
+            var customContentTypes = ContentTypes.Instance.ContentTypeFormats.Values;
             var preferredContentTypes = new string[] {};
 
             var acceptsAnything = false;
@@ -328,11 +299,6 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
                 }
             }
 
-            if (httpReq.ContentType.MatchesContentType(MimeTypes.Soap12))
-            {
-                return MimeTypes.Soap12;
-            }
-
             if (acceptContentTypes == null && httpReq.ContentType == MimeTypes.Soap11)
             {
                 return MimeTypes.Soap11;
@@ -344,10 +310,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
 
         private static string GetQueryStringContentType(IRequest httpReq)
         {
-            var callback = httpReq.QueryString[Keywords.Callback];
-            if (!string.IsNullOrEmpty(callback)) return MimeTypes.Json;
-
-            var format = httpReq.QueryString[Keywords.Format];
+            var format = httpReq.QueryString["format"];
             if (format == null)
             {
                 const int formatMaxLength = 4;
@@ -359,12 +322,11 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             }
 
             format = format.LeftPart('.').ToLower();
-            if (format.Contains("json")) return MimeTypes.Json;
+            if (format.Contains("json")) return "application/json";
             if (format.Contains("xml")) return MimeTypes.Xml;
-            if (format.Contains("jsv")) return MimeTypes.Jsv;
 
             string contentType;
-            HostContext.ContentTypes.ContentTypeFormats.TryGetValue(format, out contentType);
+            ContentTypes.Instance.ContentTypeFormats.TryGetValue(format, out contentType);
 
             return contentType;
         }
@@ -474,10 +436,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             get { return request.UserAgent; }
         }
 
-        private QueryParamCollection headers;
         public QueryParamCollection Headers
         {
-            get { return headers ?? (headers = ToQueryParams(request.Headers)); }
+            get { return request.Headers; }
         }
 
         private QueryParamCollection queryString;
@@ -492,18 +453,6 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             get { return formData ?? (formData = this.Form); }
         }
 
-        private QueryParamCollection ToQueryParams(NameValueCollection collection)
-        {
-            var result = new QueryParamCollection();
-
-            foreach (var key in collection.AllKeys)
-            {
-                result[key] = collection[key];
-            }
-
-            return result;
-        }
-
         public bool IsLocal
         {
             get { return request.IsLocal; }
@@ -563,21 +512,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             }
         }
 
-        public bool UseBufferedStream
-        {
-            get { return bufferedStream != null; }
-            set
-            {
-                bufferedStream = value
-                    ? bufferedStream ?? _memoryStreamProvider.CreateNew(request.InputStream.ReadFully())
-                    : null;
-            }
-        }
-
-        private MemoryStream bufferedStream;
         public Stream InputStream
         {
-            get { return bufferedStream ?? request.InputStream; }
+            get { return request.InputStream; }
         }
 
         public long ContentLength
@@ -613,7 +550,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             }
         }
 
-        static Stream GetSubStream(Stream stream, IMemoryStreamProvider streamProvider)
+        static Stream GetSubStream(Stream stream, IMemoryStreamFactory streamProvider)
         {
             if (stream is MemoryStream)
             {
@@ -654,4 +591,13 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             return pathInfo;
         }
     }
+
+    public class HttpFile : IHttpFile
+    {
+        public string Name { get; set; }
+        public string FileName { get; set; }
+        public long ContentLength { get; set; }
+        public string ContentType { get; set; }
+        public Stream InputStream { get; set; }
+    }
 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs
deleted file mode 100644
index 3aae6c9ca..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpResponse.cs
+++ /dev/null
@@ -1,152 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Net;
-using MediaBrowser.Model.Logging;
-using ServiceStack;
-using ServiceStack.Host;
-using HttpListenerResponse = SocketHttpListener.Net.HttpListenerResponse;
-using IHttpResponse = MediaBrowser.Model.Services.IHttpResponse;
-using IRequest = MediaBrowser.Model.Services.IRequest;
-
-namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
-{
-    public class WebSocketSharpResponse : IHttpResponse
-    {
-        private readonly ILogger _logger;
-        private readonly HttpListenerResponse _response;
-
-        public WebSocketSharpResponse(ILogger logger, HttpListenerResponse response, IRequest request)
-        {
-            _logger = logger;
-            this._response = response;
-            Items = new Dictionary<string, object>();
-            Request = request;
-        }
-
-        public IRequest Request { get; private set; }
-        public bool UseBufferedStream { get; set; }
-        public Dictionary<string, object> Items { get; private set; }
-        public object OriginalResponse
-        {
-            get { return _response; }
-        }
-
-        public int StatusCode
-        {
-            get { return this._response.StatusCode; }
-            set { this._response.StatusCode = value; }
-        }
-
-        public string StatusDescription
-        {
-            get { return this._response.StatusDescription; }
-            set { this._response.StatusDescription = value; }
-        }
-
-        public string ContentType
-        {
-            get { return _response.ContentType; }
-            set { _response.ContentType = value; }
-        }
-
-        //public ICookies Cookies { get; set; }
-
-        public void AddHeader(string name, string value)
-        {
-            if (string.Equals(name, "Content-Type", StringComparison.OrdinalIgnoreCase))
-            {
-                ContentType = value;
-                return;
-            }
-
-            _response.AddHeader(name, value);
-        }
-
-        public string GetHeader(string name)
-        {
-            return _response.Headers[name];
-        }
-
-        public void Redirect(string url)
-        {
-            _response.Redirect(url);
-        }
-
-        public Stream OutputStream
-        {
-            get { return _response.OutputStream; }
-        }
-
-        public object Dto { get; set; }
-
-        public void Write(string text)
-        {
-            var bOutput = System.Text.Encoding.UTF8.GetBytes(text);
-            _response.ContentLength64 = bOutput.Length;
-
-            var outputStream = _response.OutputStream;
-            outputStream.Write(bOutput, 0, bOutput.Length);
-            Close();
-        }
-
-        public void Close()
-        {
-            if (!this.IsClosed)
-            {
-                this.IsClosed = true;
-
-                try
-                {
-                    this._response.CloseOutputStream(_logger);
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error closing HttpListener output stream", ex);
-                }
-            }
-        }
-
-        public void End()
-        {
-            Close();
-        }
-
-        public void Flush()
-        {
-            _response.OutputStream.Flush();
-        }
-
-        public bool IsClosed
-        {
-            get;
-            private set;
-        }
-
-        public void SetContentLength(long contentLength)
-        {
-            //you can happily set the Content-Length header in Asp.Net
-            //but HttpListener will complain if you do - you have to set ContentLength64 on the response.
-            //workaround: HttpListener throws "The parameter is incorrect" exceptions when we try to set the Content-Length header
-            _response.ContentLength64 = contentLength;
-        }
-
-        public void SetCookie(Cookie cookie)
-        {
-            var cookieStr = cookie.AsHeaderValue();
-            _response.Headers.Add(HttpHeaders.SetCookie, cookieStr);
-        }
-
-        public bool SendChunked
-        {
-            get { return _response.SendChunked; }
-            set { _response.SendChunked = value; }
-        }
-
-        public bool KeepAlive { get; set; }
-
-        public void ClearCookies()
-        {
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/IO/MemoryStreamProvider.cs b/MediaBrowser.Server.Implementations/IO/MemoryStreamProvider.cs
index 0a0a04d5d..cb62ffa98 100644
--- a/MediaBrowser.Server.Implementations/IO/MemoryStreamProvider.cs
+++ b/MediaBrowser.Server.Implementations/IO/MemoryStreamProvider.cs
@@ -4,7 +4,7 @@ using Microsoft.IO;
 
 namespace MediaBrowser.Server.Implementations.IO
 {
-    public class RecyclableMemoryStreamProvider : IMemoryStreamProvider
+    public class RecyclableMemoryStreamProvider : IMemoryStreamFactory
     {
         readonly RecyclableMemoryStreamManager _manager = new RecyclableMemoryStreamManager();
 
@@ -22,9 +22,15 @@ namespace MediaBrowser.Server.Implementations.IO
         {
             return _manager.GetStream("RecyclableMemoryStream", buffer, 0, buffer.Length);
         }
+
+        public bool TryGetBuffer(MemoryStream stream, out byte[] buffer)
+        {
+            buffer = stream.GetBuffer();
+            return true;
+        }
     }
 
-    public class MemoryStreamProvider : IMemoryStreamProvider
+    public class MemoryStreamProvider : IMemoryStreamFactory
     {
         public MemoryStream CreateNew()
         {
@@ -40,5 +46,11 @@ namespace MediaBrowser.Server.Implementations.IO
         {
             return new MemoryStream(buffer);
         }
+
+        public bool TryGetBuffer(MemoryStream stream, out byte[] buffer)
+        {
+            buffer = stream.GetBuffer();
+            return true;
+        }
     }
 }
diff --git a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
index 42e2e0d7b..4096d71dc 100644
--- a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
+++ b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
@@ -69,16 +69,12 @@
       <HintPath>..\packages\Patterns.Logging.1.0.0.6\lib\portable-net45+win8\Patterns.Logging.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="ServiceStack.Api.Swagger">
-      <HintPath>..\ThirdParty\ServiceStack\ServiceStack.Api.Swagger.dll</HintPath>
-    </Reference>
     <Reference Include="SharpCompress, Version=0.10.3.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\ThirdParty\SharpCompress\SharpCompress.dll</HintPath>
     </Reference>
-    <Reference Include="SocketHttpListener, Version=1.0.6154.22657, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\SocketHttpListener.1.0.0.44\lib\net45\SocketHttpListener.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="SocketHttpListener.Portable">
+      <HintPath>..\ThirdParty\emby\SocketHttpListener.Portable.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -88,7 +84,6 @@
     <Reference Include="System.Net" />
     <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Security" />
-    <Reference Include="System.Web" />
     <Reference Include="System.Xml" />
     <Reference Include="ServiceStack">
       <HintPath>..\ThirdParty\ServiceStack\ServiceStack.dll</HintPath>
@@ -119,18 +114,9 @@
     <Compile Include="HttpServer\ContainerAdapter.cs" />
     <Compile Include="HttpServer\HttpListenerHost.cs" />
     <Compile Include="HttpServer\HttpResultFactory.cs" />
-    <Compile Include="HttpServer\LoggerUtils.cs" />
-    <Compile Include="HttpServer\RangeRequestWriter.cs" />
-    <Compile Include="HttpServer\ResponseFilter.cs" />
     <Compile Include="HttpServer\ServerFactory.cs" />
-    <Compile Include="HttpServer\ServerLogFactory.cs" />
-    <Compile Include="HttpServer\ServerLogger.cs" />
-    <Compile Include="HttpServer\SocketSharp\SharpWebSocket.cs" />
-    <Compile Include="HttpServer\SocketSharp\Extensions.cs" />
     <Compile Include="HttpServer\SocketSharp\RequestMono.cs" />
-    <Compile Include="HttpServer\SocketSharp\WebSocketSharpListener.cs" />
     <Compile Include="HttpServer\SocketSharp\WebSocketSharpRequest.cs" />
-    <Compile Include="HttpServer\SocketSharp\WebSocketSharpResponse.cs" />
     <Compile Include="IO\LibraryMonitor.cs" />
     <Compile Include="IO\MemoryStreamProvider.cs" />
     <Compile Include="LiveTv\TunerHosts\SatIp\ChannelScan.cs" />
diff --git a/MediaBrowser.Server.Implementations/Persistence/DataExtensions.cs b/MediaBrowser.Server.Implementations/Persistence/DataExtensions.cs
index 86ecbd24d..179101ca2 100644
--- a/MediaBrowser.Server.Implementations/Persistence/DataExtensions.cs
+++ b/MediaBrowser.Server.Implementations/Persistence/DataExtensions.cs
@@ -55,7 +55,7 @@ namespace MediaBrowser.Server.Implementations.Persistence
         /// </summary>
         /// <returns>Stream.</returns>
         /// <exception cref="System.ArgumentNullException">reader</exception>
-        public static Stream GetMemoryStream(this IDataReader reader, int ordinal, IMemoryStreamProvider streamProvider)
+        public static Stream GetMemoryStream(this IDataReader reader, int ordinal, IMemoryStreamFactory streamProvider)
         {
             if (reader == null)
             {
@@ -134,7 +134,7 @@ namespace MediaBrowser.Server.Implementations.Persistence
         /// </summary>
         /// <returns>System.Byte[][].</returns>
         /// <exception cref="System.ArgumentNullException">obj</exception>
-        public static byte[] SerializeToBytes(this IJsonSerializer json, object obj, IMemoryStreamProvider streamProvider)
+        public static byte[] SerializeToBytes(this IJsonSerializer json, object obj, IMemoryStreamFactory streamProvider)
         {
             if (obj == null)
             {
diff --git a/MediaBrowser.Server.Implementations/Persistence/SqliteDisplayPreferencesRepository.cs b/MediaBrowser.Server.Implementations/Persistence/SqliteDisplayPreferencesRepository.cs
index 3d20cad36..c97ba8792 100644
--- a/MediaBrowser.Server.Implementations/Persistence/SqliteDisplayPreferencesRepository.cs
+++ b/MediaBrowser.Server.Implementations/Persistence/SqliteDisplayPreferencesRepository.cs
@@ -20,9 +20,9 @@ namespace MediaBrowser.Server.Implementations.Persistence
     /// </summary>
     public class SqliteDisplayPreferencesRepository : BaseSqliteRepository, IDisplayPreferencesRepository
     {
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public SqliteDisplayPreferencesRepository(ILogManager logManager, IJsonSerializer jsonSerializer, IApplicationPaths appPaths, IDbConnector dbConnector, IMemoryStreamProvider memoryStreamProvider)
+        public SqliteDisplayPreferencesRepository(ILogManager logManager, IJsonSerializer jsonSerializer, IApplicationPaths appPaths, IDbConnector dbConnector, IMemoryStreamFactory memoryStreamProvider)
             : base(logManager, dbConnector)
         {
             _jsonSerializer = jsonSerializer;
diff --git a/MediaBrowser.Server.Implementations/Persistence/SqliteItemRepository.cs b/MediaBrowser.Server.Implementations/Persistence/SqliteItemRepository.cs
index 5fcd38f87..3577d1883 100644
--- a/MediaBrowser.Server.Implementations/Persistence/SqliteItemRepository.cs
+++ b/MediaBrowser.Server.Implementations/Persistence/SqliteItemRepository.cs
@@ -99,12 +99,12 @@ namespace MediaBrowser.Server.Implementations.Persistence
         private IDbCommand _updateInheritedTagsCommand;
 
         public const int LatestSchemaVersion = 109;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SqliteItemRepository"/> class.
         /// </summary>
-        public SqliteItemRepository(IServerConfigurationManager config, IJsonSerializer jsonSerializer, ILogManager logManager, IDbConnector connector, IMemoryStreamProvider memoryStreamProvider)
+        public SqliteItemRepository(IServerConfigurationManager config, IJsonSerializer jsonSerializer, ILogManager logManager, IDbConnector connector, IMemoryStreamFactory memoryStreamProvider)
             : base(logManager, connector)
         {
             if (config == null)
diff --git a/MediaBrowser.Server.Implementations/Persistence/SqliteUserRepository.cs b/MediaBrowser.Server.Implementations/Persistence/SqliteUserRepository.cs
index c3cf4acc4..0c1367e0a 100644
--- a/MediaBrowser.Server.Implementations/Persistence/SqliteUserRepository.cs
+++ b/MediaBrowser.Server.Implementations/Persistence/SqliteUserRepository.cs
@@ -20,9 +20,9 @@ namespace MediaBrowser.Server.Implementations.Persistence
     public class SqliteUserRepository : BaseSqliteRepository, IUserRepository
     {
         private readonly IJsonSerializer _jsonSerializer;
-        private readonly IMemoryStreamProvider _memoryStreamProvider;
+        private readonly IMemoryStreamFactory _memoryStreamProvider;
 
-        public SqliteUserRepository(ILogManager logManager, IServerApplicationPaths appPaths, IJsonSerializer jsonSerializer, IDbConnector dbConnector, IMemoryStreamProvider memoryStreamProvider) : base(logManager, dbConnector)
+        public SqliteUserRepository(ILogManager logManager, IServerApplicationPaths appPaths, IJsonSerializer jsonSerializer, IDbConnector dbConnector, IMemoryStreamFactory memoryStreamProvider) : base(logManager, dbConnector)
         {
             _jsonSerializer = jsonSerializer;
             _memoryStreamProvider = memoryStreamProvider;
diff --git a/MediaBrowser.Server.Implementations/packages.config b/MediaBrowser.Server.Implementations/packages.config
index 909246f68..84a5d5a1d 100644
--- a/MediaBrowser.Server.Implementations/packages.config
+++ b/MediaBrowser.Server.Implementations/packages.config
@@ -5,6 +5,5 @@
   <package id="MediaBrowser.Naming" version="1.0.0.59" targetFramework="net46" />
   <package id="Microsoft.IO.RecyclableMemoryStream" version="1.1.0.0" targetFramework="net46" />
   <package id="Patterns.Logging" version="1.0.0.6" targetFramework="net46" />
-  <package id="SocketHttpListener" version="1.0.0.44" targetFramework="net46" />
   <package id="UniversalDetector" version="1.0.1" targetFramework="net46" />
 </packages>
\ No newline at end of file
diff --git a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
index fd84940dd..c0f184bef 100644
--- a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
+++ b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
@@ -126,7 +126,7 @@ using MediaBrowser.Model.Reflection;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.Services;
 using MediaBrowser.Model.Social;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 using MediaBrowser.Model.Xml;
 using MediaBrowser.Server.Implementations.Archiving;
 using MediaBrowser.Server.Implementations.Serialization;
@@ -252,6 +252,8 @@ namespace MediaBrowser.Server.Startup.Common
         /// <value>The zip client.</value>
         protected IZipClient ZipClient { get; private set; }
 
+        protected IAuthService AuthService { get; private set; }
+
         private readonly StartupOptions _startupOptions;
         private readonly string _releaseAssetFilename;
 
@@ -410,7 +412,7 @@ namespace MediaBrowser.Server.Startup.Common
             LogManager.RemoveConsoleOutput();
         }
 
-        protected override IMemoryStreamProvider CreateMemoryStreamProvider()
+        protected override IMemoryStreamFactory CreateMemoryStreamProvider()
         {
             if (Environment.OSVersion.Platform == PlatformID.Win32NT)
             {
@@ -555,7 +557,7 @@ namespace MediaBrowser.Server.Startup.Common
             StringExtensions.LocalizationManager = LocalizationManager;
             RegisterSingleInstance(LocalizationManager);
 
-            IEncoding textEncoding = new TextEncoding(FileSystemManager);
+            ITextEncoding textEncoding = new TextEncoding(FileSystemManager);
             RegisterSingleInstance(textEncoding);
             Utilities.EncodingHelper = textEncoding;
             RegisterSingleInstance<IBlurayExaminer>(() => new BdInfoExaminer(FileSystemManager, textEncoding));
@@ -601,7 +603,7 @@ namespace MediaBrowser.Server.Startup.Common
 
             RegisterSingleInstance<ISearchEngine>(() => new SearchEngine(LogManager, LibraryManager, UserManager));
 
-            HttpServer = ServerFactory.CreateServer(this, LogManager, ServerConfigurationManager, NetworkManager, MemoryStreamProvider, "Emby", "web/index.html");
+            HttpServer = ServerFactory.CreateServer(this, LogManager, ServerConfigurationManager, NetworkManager, MemoryStreamProvider, "Emby", "web/index.html", textEncoding, SocketFactory, CryptographyProvider);
             HttpServer.GlobalResponse = LocalizationManager.GetLocalizedString("StartupEmbyServerIsLoading");
             RegisterSingleInstance(HttpServer, false);
             progress.Report(10);
@@ -702,7 +704,9 @@ namespace MediaBrowser.Server.Startup.Common
             var authContext = new AuthorizationContext(AuthenticationRepository, ConnectManager);
             RegisterSingleInstance<IAuthorizationContext>(authContext);
             RegisterSingleInstance<ISessionContext>(new SessionContext(UserManager, authContext, SessionManager));
-            RegisterSingleInstance<IAuthService>(new AuthService(UserManager, authContext, ServerConfigurationManager, ConnectManager, SessionManager, DeviceManager));
+
+            AuthService = new AuthService(UserManager, authContext, ServerConfigurationManager, ConnectManager, SessionManager, DeviceManager);
+            RegisterSingleInstance<IAuthService>(AuthService);
 
             SubtitleEncoder = new SubtitleEncoder(LibraryManager, LogManager.GetLogger("SubtitleEncoder"), ApplicationPaths, FileSystemManager, MediaEncoder, JsonSerializer, HttpClient, MediaSourceManager, MemoryStreamProvider, ProcessFactory, textEncoding);
             RegisterSingleInstance(SubtitleEncoder);
@@ -900,6 +904,7 @@ namespace MediaBrowser.Server.Startup.Common
             BaseStreamingService.AppHost = this;
             BaseStreamingService.HttpClient = HttpClient;
             Utilities.CryptographyProvider = CryptographyProvider;
+            AuthenticatedAttribute.AuthService = AuthService;
         }
 
         /// <summary>
@@ -1291,7 +1296,7 @@ namespace MediaBrowser.Server.Startup.Common
             try
             {
                 // Return the first matched address, if found, or the first known local address
-                var address = (await GetLocalIpAddressesInternal().ConfigureAwait(false)).FirstOrDefault(i => !IPAddress.IsLoopback(i));
+                var address = (await GetLocalIpAddresses().ConfigureAwait(false)).FirstOrDefault(i => !i.Equals(IpAddressInfo.Loopback) && !i.Equals(IpAddressInfo.IPv6Loopback));
 
                 if (address != null)
                 {
@@ -1308,19 +1313,14 @@ namespace MediaBrowser.Server.Startup.Common
             return null;
         }
 
-        public string GetLocalApiUrl(IPAddress ipAddress)
-        {
-            return GetLocalApiUrl(ipAddress.ToString(), ipAddress.AddressFamily == AddressFamily.InterNetworkV6);
-        }
-
-        public string GetLocalApiUrl(string ipAddress, bool isIpv6)
+        public string GetLocalApiUrl(IpAddressInfo ipAddress)
         {
-            if (isIpv6)
+            if (ipAddress.AddressFamily == IpAddressFamily.InterNetworkV6)
             {
-                return GetLocalApiUrl("[" + ipAddress + "]");
+                return GetLocalApiUrl("[" + ipAddress.Address + "]");
             }
 
-            return GetLocalApiUrl(ipAddress);
+            return GetLocalApiUrl(ipAddress.Address);
         }
 
         public string GetLocalApiUrl(string host)
@@ -1332,23 +1332,8 @@ namespace MediaBrowser.Server.Startup.Common
 
         public async Task<List<IpAddressInfo>> GetLocalIpAddresses()
         {
-            var list = await GetLocalIpAddressesInternal().ConfigureAwait(false);
-
-            return list.Select(i => new IpAddressInfo
-            {
-                Address = i.ToString(),
-                IsIpv6 = i.AddressFamily == AddressFamily.InterNetworkV6
-
-            }).ToList();
-        }
-
-        private async Task<List<IPAddress>> GetLocalIpAddressesInternal()
-        {
-            // Need to do this until Common will compile with this method
-            var nativeNetworkManager = (BaseNetworkManager)NetworkManager;
-
-            var addresses = nativeNetworkManager.GetLocalIpAddresses().ToList();
-            var list = new List<IPAddress>();
+            var addresses = NetworkManager.GetLocalIpAddresses().ToList();
+            var list = new List<IpAddressInfo>();
 
             foreach (var address in addresses)
             {
@@ -1364,9 +1349,10 @@ namespace MediaBrowser.Server.Startup.Common
 
         private readonly ConcurrentDictionary<string, bool> _validAddressResults = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
         private DateTime _lastAddressCacheClear;
-        private async Task<bool> IsIpAddressValidAsync(IPAddress address)
+        private async Task<bool> IsIpAddressValidAsync(IpAddressInfo address)
         {
-            if (IPAddress.IsLoopback(address))
+            if (address.Equals(IpAddressInfo.Loopback) ||
+                address.Equals(IpAddressInfo.IPv6Loopback))
             {
                 return true;
             }
diff --git a/Nuget/MediaBrowser.Common.nuspec b/Nuget/MediaBrowser.Common.nuspec
index e813c0a0a..7b949fcb1 100644
--- a/Nuget/MediaBrowser.Common.nuspec
+++ b/Nuget/MediaBrowser.Common.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
     <metadata>
         <id>MediaBrowser.Common</id>
-        <version>3.0.684</version>
+        <version>3.0.688</version>
         <title>Emby.Common</title>
         <authors>Emby Team</authors>
         <owners>ebr,Luke,scottisafool</owners>
diff --git a/Nuget/MediaBrowser.Server.Core.nuspec b/Nuget/MediaBrowser.Server.Core.nuspec
index 9b0c10cbb..96986de9b 100644
--- a/Nuget/MediaBrowser.Server.Core.nuspec
+++ b/Nuget/MediaBrowser.Server.Core.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>MediaBrowser.Server.Core</id>
-        <version>3.0.684</version>
+        <version>3.0.688</version>
         <title>Emby.Server.Core</title>
         <authors>Emby Team</authors>
         <owners>ebr,Luke,scottisafool</owners>
@@ -12,7 +12,7 @@
         <description>Contains core components required to build plugins for Emby Server.</description>
         <copyright>Copyright © Emby 2013</copyright>
         <dependencies>
-            <dependency id="MediaBrowser.Common" version="3.0.684" />
+            <dependency id="MediaBrowser.Common" version="3.0.688" />
         </dependencies>
     </metadata>
     <files>
diff --git a/OpenSubtitlesHandler/Utilities.cs b/OpenSubtitlesHandler/Utilities.cs
index b2ad2d0f1..3fe606c78 100644
--- a/OpenSubtitlesHandler/Utilities.cs
+++ b/OpenSubtitlesHandler/Utilities.cs
@@ -24,7 +24,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Common.Net;
 using MediaBrowser.Model.Cryptography;
-using MediaBrowser.Model.TextEncoding;
+using MediaBrowser.Model.Text;
 
 namespace OpenSubtitlesHandler
 {
@@ -33,9 +33,9 @@ namespace OpenSubtitlesHandler
     /// </summary>
     public sealed class Utilities
     {
-        public static ICryptographyProvider CryptographyProvider { get; set; }
+        public static ICryptoProvider CryptographyProvider { get; set; }
         public static IHttpClient HttpClient { get; set; }
-        public static IEncoding EncodingHelper { get; set; }
+        public static ITextEncoding EncodingHelper { get; set; }
 
         private const string XML_RPC_SERVER = "https://api.opensubtitles.org/xml-rpc";
 
@@ -124,13 +124,13 @@ namespace OpenSubtitlesHandler
                     data.Add((byte)r);
                 }
                 var bytes = data.ToArray();
-                return EncodingHelper.GetASCIIString(bytes, 0, bytes.Length);
+                return EncodingHelper.GetASCIIEncoding().GetString(bytes, 0, bytes.Length);
             }
         }
 
         public static byte[] GetASCIIBytes(string text)
         {
-            return EncodingHelper.GetASCIIBytes(text);
+            return EncodingHelper.GetASCIIEncoding().GetBytes(text);
         }
 
         /// <summary>
-- 
cgit v1.2.3


From 8c8f2aaba5e4bf573efe2730b5450a8c07abe1b3 Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Sun, 4 Dec 2016 16:55:02 -0500
Subject: first pass at binding to multiple network addresses

---
 MediaBrowser.Common/Net/INetworkManager.cs    |   2 +-
 MediaBrowser.Model/Net/ISocketFactory.cs      |   2 +-
 MediaBrowser.Model/Net/IUdpSocket.cs          |  16 +--
 MediaBrowser.Model/Net/SocketReceiveResult.cs |   3 +-
 RSSDP/ISsdpCommunicationsServer.cs            |   3 +-
 RSSDP/RSSDP.csproj                            |   5 +-
 RSSDP/ReadOnlyEnumerable.cs                   |  46 -------
 RSSDP/RequestReceivedEventArgs.cs             |   9 +-
 RSSDP/SsdpCommunicationsServer.cs             | 175 ++++++++++++++++++++------
 RSSDP/SsdpDevice.cs                           |   2 +-
 RSSDP/SsdpDevicePublisherBase.cs              |  31 ++---
 11 files changed, 177 insertions(+), 117 deletions(-)
 delete mode 100644 RSSDP/ReadOnlyEnumerable.cs

(limited to 'MediaBrowser.Model/Net/ISocketFactory.cs')

diff --git a/MediaBrowser.Common/Net/INetworkManager.cs b/MediaBrowser.Common/Net/INetworkManager.cs
index 5ac701f82..3bc22c07f 100644
--- a/MediaBrowser.Common/Net/INetworkManager.cs
+++ b/MediaBrowser.Common/Net/INetworkManager.cs
@@ -47,7 +47,7 @@ namespace MediaBrowser.Common.Net
         /// <returns><c>true</c> if [is in local network] [the specified endpoint]; otherwise, <c>false</c>.</returns>
         bool IsInLocalNetwork(string endpoint);
 
-        IEnumerable<IpAddressInfo> GetLocalIpAddresses();
+        List<IpAddressInfo> GetLocalIpAddresses();
 
         IpAddressInfo ParseIpAddress(string ipAddress);
 
diff --git a/MediaBrowser.Model/Net/ISocketFactory.cs b/MediaBrowser.Model/Net/ISocketFactory.cs
index 599292ddf..ac406e7f1 100644
--- a/MediaBrowser.Model/Net/ISocketFactory.cs
+++ b/MediaBrowser.Model/Net/ISocketFactory.cs
@@ -17,7 +17,7 @@ namespace MediaBrowser.Model.Net
         /// <summary>
         /// Createa a new unicast socket using the specified local port number.
         /// </summary>
-        IUdpSocket CreateSsdpUdpSocket(int localPort);
+        IUdpSocket CreateSsdpUdpSocket(IpAddressInfo localIp, int localPort);
 
         /// <summary>
         /// Createa a new multicast socket using the specified multicast IP address, multicast time to live and local port.
diff --git a/MediaBrowser.Model/Net/IUdpSocket.cs b/MediaBrowser.Model/Net/IUdpSocket.cs
index ef090e010..c70510726 100644
--- a/MediaBrowser.Model/Net/IUdpSocket.cs
+++ b/MediaBrowser.Model/Net/IUdpSocket.cs
@@ -10,16 +10,18 @@ namespace MediaBrowser.Model.Net
     /// Provides a common interface across platforms for UDP sockets used by this SSDP implementation.
     /// </summary>
     public interface IUdpSocket : IDisposable
-	{
-		/// <summary>
-		/// Waits for and returns the next UDP message sent to this socket (uni or multicast).
-		/// </summary>
-		/// <returns></returns>
-		Task<SocketReceiveResult> ReceiveAsync();
+    {
+        IpAddressInfo LocalIPAddress { get; }
+
+        /// <summary>
+        /// Waits for and returns the next UDP message sent to this socket (uni or multicast).
+        /// </summary>
+        /// <returns></returns>
+        Task<SocketReceiveResult> ReceiveAsync();
 
         /// <summary>
         /// Sends a UDP message to a particular end point (uni or multicast).
         /// </summary>
         Task SendAsync(byte[] buffer, int bytes, IpEndPointInfo endPoint);
-	}
+    }
 }
\ No newline at end of file
diff --git a/MediaBrowser.Model/Net/SocketReceiveResult.cs b/MediaBrowser.Model/Net/SocketReceiveResult.cs
index 0a2d04ad3..483e2297b 100644
--- a/MediaBrowser.Model/Net/SocketReceiveResult.cs
+++ b/MediaBrowser.Model/Net/SocketReceiveResult.cs
@@ -20,5 +20,6 @@ namespace MediaBrowser.Model.Net
         /// The <see cref="IpEndPointInfo"/> the data was received from.
         /// </summary>
         public IpEndPointInfo RemoteEndPoint { get; set; }
-	}
+        public IpAddressInfo LocalIPAddress { get; set; }
+    }
 }
diff --git a/RSSDP/ISsdpCommunicationsServer.cs b/RSSDP/ISsdpCommunicationsServer.cs
index 462f33fe6..eea5e0ed6 100644
--- a/RSSDP/ISsdpCommunicationsServer.cs
+++ b/RSSDP/ISsdpCommunicationsServer.cs
@@ -46,7 +46,8 @@ namespace Rssdp.Infrastructure
         /// </summary>
         /// <param name="messageData">A byte array containing the data to send.</param>
         /// <param name="destination">A <see cref="IpEndPointInfo"/> representing the destination address for the data. Can be either a multicast or unicast destination.</param>
-        Task SendMessage(byte[] messageData, IpEndPointInfo destination);
+        /// <param name="fromLocalIpAddress">A <see cref="IpEndPointInfo"/> The local ip address to send from, or .Any if sending from all available</param>
+        Task SendMessage(byte[] messageData, IpEndPointInfo destination, IpAddressInfo fromLocalIpAddress);
 
         /// <summary>
         /// Sends a message to the SSDP multicast address and port.
diff --git a/RSSDP/RSSDP.csproj b/RSSDP/RSSDP.csproj
index d60f6ea44..ef1f32207 100644
--- a/RSSDP/RSSDP.csproj
+++ b/RSSDP/RSSDP.csproj
@@ -50,7 +50,6 @@
     <Compile Include="ISsdpDevicePublisher.cs" />
     <Compile Include="IUPnPDeviceValidator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ReadOnlyEnumerable.cs" />
     <Compile Include="RequestReceivedEventArgs.cs" />
     <Compile Include="ResponseReceivedEventArgs.cs" />
     <Compile Include="SsdpCommunicationsServer.cs" />
@@ -70,6 +69,10 @@
     <Compile Include="UPnP10DeviceValidator.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\MediaBrowser.Common\MediaBrowser.Common.csproj">
+      <Project>{9142eefa-7570-41e1-bfcc-468bb571af2f}</Project>
+      <Name>MediaBrowser.Common</Name>
+    </ProjectReference>
     <ProjectReference Include="..\MediaBrowser.Model\MediaBrowser.Model.csproj">
       <Project>{7eeeb4bb-f3e8-48fc-b4c5-70f0fff8329b}</Project>
       <Name>MediaBrowser.Model</Name>
diff --git a/RSSDP/ReadOnlyEnumerable.cs b/RSSDP/ReadOnlyEnumerable.cs
deleted file mode 100644
index 1a69f8837..000000000
--- a/RSSDP/ReadOnlyEnumerable.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Rssdp
-{
-	internal sealed class ReadOnlyEnumerable<T> : System.Collections.Generic.IEnumerable<T>
-	{
-
-		#region Fields
-
-		private IEnumerable<T> _Items;
-
-		#endregion
-
-		#region Constructors
-
-		public ReadOnlyEnumerable(IEnumerable<T> items)
-		{
-			if (items == null) throw new ArgumentNullException("items");
-
-			_Items = items;
-		}
-
-		#endregion
-
-		#region IEnumerable<T> Members
-
-		public IEnumerator<T> GetEnumerator()
-		{
-			return _Items.GetEnumerator();
-		}
-
-		#endregion
-
-		#region IEnumerable Members
-
-		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-		{
-			return _Items.GetEnumerator();
-		}
-
-		#endregion
-	}
-}
diff --git a/RSSDP/RequestReceivedEventArgs.cs b/RSSDP/RequestReceivedEventArgs.cs
index fb4fac871..03c059634 100644
--- a/RSSDP/RequestReceivedEventArgs.cs
+++ b/RSSDP/RequestReceivedEventArgs.cs
@@ -22,17 +22,18 @@ namespace Rssdp.Infrastructure
 
 		#endregion
 
-		#region Constructors
+	    public IpAddressInfo LocalIpAddress { get; private set; }
+
+	    #region Constructors
 
 		/// <summary>
 		/// Full constructor.
 		/// </summary>
-		/// <param name="message">The <see cref="HttpRequestMessage"/> that was received.</param>
-		/// <param name="receivedFrom">A <see cref="UdpEndPoint"/> representing the sender's address (sometimes used for replies).</param>
-		public RequestReceivedEventArgs(HttpRequestMessage message, IpEndPointInfo receivedFrom)
+		public RequestReceivedEventArgs(HttpRequestMessage message, IpEndPointInfo receivedFrom, IpAddressInfo localIpAddress)
 		{
 			_Message = message;
 			_ReceivedFrom = receivedFrom;
+		    LocalIpAddress = localIpAddress;
 		}
 
 		#endregion
diff --git a/RSSDP/SsdpCommunicationsServer.cs b/RSSDP/SsdpCommunicationsServer.cs
index 4de47f3d3..5d8ca15bb 100644
--- a/RSSDP/SsdpCommunicationsServer.cs
+++ b/RSSDP/SsdpCommunicationsServer.cs
@@ -5,6 +5,8 @@ using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Net;
 
 namespace Rssdp.Infrastructure
@@ -38,12 +40,13 @@ namespace Rssdp.Infrastructure
         private IUdpSocket _BroadcastListenSocket;
 
         private object _SendSocketSynchroniser = new object();
-        private IUdpSocket _SendSocket;
+        private List<IUdpSocket> _sendSockets;
 
         private HttpRequestParser _RequestParser;
         private HttpResponseParser _ResponseParser;
-
+        private readonly ILogger _logger;
         private ISocketFactory _SocketFactory;
+        private readonly INetworkManager _networkManager;
 
         private int _LocalPort;
         private int _MulticastTtl;
@@ -71,22 +74,18 @@ namespace Rssdp.Infrastructure
         /// <summary>
         /// Minimum constructor.
         /// </summary>
-        /// <param name="socketFactory">An implementation of the <see cref="ISocketFactory"/> interface that can be used to make new unicast and multicast sockets. Cannot be null.</param>
         /// <exception cref="System.ArgumentNullException">The <paramref name="socketFactory"/> argument is null.</exception>
-        public SsdpCommunicationsServer(ISocketFactory socketFactory)
-            : this(socketFactory, 0, SsdpConstants.SsdpDefaultMulticastTimeToLive)
+        public SsdpCommunicationsServer(ISocketFactory socketFactory, INetworkManager networkManager, ILogger logger)
+            : this(socketFactory, 0, SsdpConstants.SsdpDefaultMulticastTimeToLive, networkManager, logger)
         {
         }
 
         /// <summary>
         /// Full constructor.
         /// </summary>
-        /// <param name="socketFactory">An implementation of the <see cref="ISocketFactory"/> interface that can be used to make new unicast and multicast sockets. Cannot be null.</param>
-        /// <param name="localPort">The specific local port to use for all sockets created by this instance. Specify zero to indicate the system should choose a free port itself.</param>
-        /// <param name="multicastTimeToLive">The multicast time to live value for multicast sockets. Technically this is a number of router hops, not a 'Time'. Must be greater than zero.</param>
         /// <exception cref="System.ArgumentNullException">The <paramref name="socketFactory"/> argument is null.</exception>
         /// <exception cref="System.ArgumentOutOfRangeException">The <paramref name="multicastTimeToLive"/> argument is less than or equal to zero.</exception>
-        public SsdpCommunicationsServer(ISocketFactory socketFactory, int localPort, int multicastTimeToLive)
+        public SsdpCommunicationsServer(ISocketFactory socketFactory, int localPort, int multicastTimeToLive, INetworkManager networkManager, ILogger logger)
         {
             if (socketFactory == null) throw new ArgumentNullException("socketFactory");
             if (multicastTimeToLive <= 0) throw new ArgumentOutOfRangeException("multicastTimeToLive", "multicastTimeToLive must be greater than zero.");
@@ -101,6 +100,8 @@ namespace Rssdp.Infrastructure
             _ResponseParser = new HttpResponseParser();
 
             _MulticastTtl = multicastTimeToLive;
+            _networkManager = networkManager;
+            _logger = logger;
         }
 
         #endregion
@@ -148,25 +149,72 @@ namespace Rssdp.Infrastructure
         /// </summary>
         /// <param name="messageData">A byte array containing the data to send.</param>
         /// <param name="destination">A <see cref="IpEndPointInfo"/> representing the destination address for the data. Can be either a multicast or unicast destination.</param>
+        /// <param name="fromLocalIpAddress">A <see cref="IpEndPointInfo"/> The local ip address to send from, or .Any if sending from all available</param>
         /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="messageData"/> argument is null.</exception>
         /// <exception cref="System.ObjectDisposedException">Thrown if the <see cref="DisposableManagedObjectBase.IsDisposed"/> property is true (because <seealso cref="DisposableManagedObjectBase.Dispose()" /> has been called previously).</exception>
-        public async Task SendMessage(byte[] messageData, IpEndPointInfo destination)
+        public async Task SendMessage(byte[] messageData, IpEndPointInfo destination, IpAddressInfo fromLocalIpAddress)
         {
             if (messageData == null) throw new ArgumentNullException("messageData");
 
             ThrowIfDisposed();
 
-            EnsureSendSocketCreated();
+            var sockets = GetSendSockets(fromLocalIpAddress, destination);
+
+            if (sockets.Count == 0)
+            {
+                return;
+            }
 
             // SSDP spec recommends sending messages multiple times (not more than 3) to account for possible packet loss over UDP.
             for (var i = 0; i < SsdpConstants.UdpResendCount; i++)
             {
-                await SendMessageIfSocketNotDisposed(messageData, destination).ConfigureAwait(false);
+                var tasks = sockets.Select(s => SendFromSocket(s, messageData, destination)).ToArray();
+                await Task.WhenAll(tasks).ConfigureAwait(false);
 
                 await Task.Delay(100).ConfigureAwait(false);
             }
         }
 
+        private async Task SendFromSocket(IUdpSocket socket, byte[] messageData, IpEndPointInfo destination)
+        {
+            try
+            {
+                await socket.SendAsync(messageData, messageData.Length, destination).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error sending socket message from {0} to {1}", ex, socket.LocalIPAddress.ToString(), destination.ToString());
+            }
+        }
+
+        private List<IUdpSocket> GetSendSockets(IpAddressInfo fromLocalIpAddress, IpEndPointInfo destination)
+        {
+            EnsureSendSocketCreated();
+
+            lock (_SendSocketSynchroniser)
+            {
+                var sockets = _sendSockets.Where(i => i.LocalIPAddress.AddressFamily == fromLocalIpAddress.AddressFamily);
+
+                // Send from the Any socket and the socket with the matching address
+                if (fromLocalIpAddress.AddressFamily == IpAddressFamily.InterNetwork)
+                {
+                    sockets = sockets.Where(i => i.LocalIPAddress.Equals(IpAddressInfo.Any) || fromLocalIpAddress.Equals(i.LocalIPAddress));
+                }
+                else if (fromLocalIpAddress.AddressFamily == IpAddressFamily.InterNetworkV6)
+                {
+                    sockets = sockets.Where(i => i.LocalIPAddress.Equals(IpAddressInfo.IPv6Any) || fromLocalIpAddress.Equals(i.LocalIPAddress));
+                }
+
+                // If sending to the loopback address, filter the socket list as well
+                if (destination.IpAddress.Equals(IpAddressInfo.Loopback))
+                {
+                    sockets = sockets.Where(i => i.LocalIPAddress.Equals(IpAddressInfo.Any) || i.LocalIPAddress.Equals(IpAddressInfo.Loopback));
+                }
+
+                return sockets.ToList();
+            }
+        }
+
         /// <summary>
         /// Sends a message to the SSDP multicast address and port.
         /// </summary>
@@ -185,7 +233,10 @@ namespace Rssdp.Infrastructure
             {
                 await SendMessageIfSocketNotDisposed(messageData, new IpEndPointInfo
                 {
-                    IpAddress = new IpAddressInfo { Address = SsdpConstants.MulticastLocalAdminAddress },
+                    IpAddress = new IpAddressInfo
+                    {
+                        Address = SsdpConstants.MulticastLocalAdminAddress
+                    },
                     Port = SsdpConstants.MulticastPort
 
                 }).ConfigureAwait(false);
@@ -204,10 +255,16 @@ namespace Rssdp.Infrastructure
 
             lock (_SendSocketSynchroniser)
             {
-                var socket = _SendSocket;
-                _SendSocket = null;
-                if (socket != null)
-                    socket.Dispose();
+                if (_sendSockets != null)
+                {
+                    var sockets = _sendSockets.ToList();
+                    _sendSockets = null;
+
+                    foreach (var socket in sockets)
+                    {
+                        socket.Dispose();
+                    }
+                }
             }
         }
 
@@ -247,8 +304,16 @@ namespace Rssdp.Infrastructure
 
                 lock (_SendSocketSynchroniser)
                 {
-                    if (_SendSocket != null)
-                        _SendSocket.Dispose();
+                    if (_sendSockets != null)
+                    {
+                        var sockets = _sendSockets.ToList();
+                        _sendSockets = null;
+
+                        foreach (var socket in sockets)
+                        {
+                            socket.Dispose();
+                        }
+                    }
                 }
             }
         }
@@ -257,16 +322,20 @@ namespace Rssdp.Infrastructure
 
         #region Private Methods
 
-        private Task SendMessageIfSocketNotDisposed(byte[] messageData, IpEndPointInfo destination)
+        private async Task SendMessageIfSocketNotDisposed(byte[] messageData, IpEndPointInfo destination)
         {
-            var socket = _SendSocket;
-            if (socket != null)
+            var sockets = _sendSockets;
+            if (sockets != null)
             {
-                return _SendSocket.SendAsync(messageData, messageData.Length, destination);
+                sockets = sockets.ToList();
+
+                foreach (var socket in sockets)
+                {
+                    await socket.SendAsync(messageData, messageData.Length, destination).ConfigureAwait(false);
+                }
             }
 
             ThrowIfDisposed();
-            return Task.FromResult(true);
         }
 
         private IUdpSocket ListenForBroadcastsAsync()
@@ -278,13 +347,30 @@ namespace Rssdp.Infrastructure
             return socket;
         }
 
-        private IUdpSocket CreateSocketAndListenForResponsesAsync()
+        private List<IUdpSocket> CreateSocketAndListenForResponsesAsync()
         {
-            _SendSocket = _SocketFactory.CreateSsdpUdpSocket(_LocalPort);
+            var sockets = new List<IUdpSocket>();
 
-            ListenToSocket(_SendSocket);
+            sockets.Add(_SocketFactory.CreateSsdpUdpSocket(IpAddressInfo.Any, _LocalPort));
 
-            return _SendSocket;
+            foreach (var address in _networkManager.GetLocalIpAddresses().ToList())
+            {
+                try
+                {
+                    sockets.Add(_SocketFactory.CreateSsdpUdpSocket(address, _LocalPort));
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error in CreateSsdpUdpSocket. IPAddress: {0}", ex, address);
+                }
+            }
+
+            foreach (var socket in sockets)
+            {
+                ListenToSocket(socket);
+            }
+
+            return sockets;
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "t", Justification = "Capturing task to local variable removes compiler warning, task is not otherwise required.")]
@@ -305,7 +391,7 @@ namespace Rssdp.Infrastructure
                             // Strange cannot convert compiler error here if I don't explicitly
                             // assign or cast to Action first. Assignment is easier to read,
                             // so went with that.
-                            ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(result.Buffer, 0, result.ReceivedBytes), result.RemoteEndPoint);
+                            ProcessMessage(System.Text.UTF8Encoding.UTF8.GetString(result.Buffer, 0, result.ReceivedBytes), result.RemoteEndPoint, result.LocalIPAddress);
                         }
                     }
                     catch (ObjectDisposedException)
@@ -322,19 +408,19 @@ namespace Rssdp.Infrastructure
 
         private void EnsureSendSocketCreated()
         {
-            if (_SendSocket == null)
+            if (_sendSockets == null)
             {
                 lock (_SendSocketSynchroniser)
                 {
-                    if (_SendSocket == null)
+                    if (_sendSockets == null)
                     {
-                        _SendSocket = CreateSocketAndListenForResponsesAsync();
+                        _sendSockets = CreateSocketAndListenForResponsesAsync();
                     }
                 }
             }
         }
 
-        private void ProcessMessage(string data, IpEndPointInfo endPoint)
+        private void ProcessMessage(string data, IpEndPointInfo endPoint, IpAddressInfo receivedOnLocalIpAddress)
         {
             //Responses start with the HTTP version, prefixed with HTTP/ while
             //requests start with a method which can vary and might be one we haven't 
@@ -347,7 +433,10 @@ namespace Rssdp.Infrastructure
                 {
                     responseMessage = _ResponseParser.Parse(data);
                 }
-                catch (ArgumentException) { } // Ignore invalid packets.
+                catch (ArgumentException ex)
+                {
+                    // Ignore invalid packets.
+                }
 
                 if (responseMessage != null)
                     OnResponseReceived(responseMessage, endPoint);
@@ -359,23 +448,31 @@ namespace Rssdp.Infrastructure
                 {
                     requestMessage = _RequestParser.Parse(data);
                 }
-                catch (ArgumentException) { } // Ignore invalid packets.
+                catch (ArgumentException ex)
+                {
+                    // Ignore invalid packets.
+                }
 
                 if (requestMessage != null)
-                    OnRequestReceived(requestMessage, endPoint);
+                {
+                    OnRequestReceived(requestMessage, endPoint, receivedOnLocalIpAddress);
+                }
             }
         }
 
-        private void OnRequestReceived(HttpRequestMessage data, IpEndPointInfo endPoint)
+        private void OnRequestReceived(HttpRequestMessage data, IpEndPointInfo remoteEndPoint, IpAddressInfo receivedOnLocalIpAddress)
         {
             //SSDP specification says only * is currently used but other uri's might
             //be implemented in the future and should be ignored unless understood.
             //Section 4.2 - http://tools.ietf.org/html/draft-cai-ssdp-v1-03#page-11
-            if (data.RequestUri.ToString() != "*") return;
+            if (data.RequestUri.ToString() != "*")
+            {
+                return;
+            }
 
             var handlers = this.RequestReceived;
             if (handlers != null)
-                handlers(this, new RequestReceivedEventArgs(data, endPoint));
+                handlers(this, new RequestReceivedEventArgs(data, remoteEndPoint, receivedOnLocalIpAddress));
         }
 
         private void OnResponseReceived(HttpResponseMessage data, IpEndPointInfo endPoint)
diff --git a/RSSDP/SsdpDevice.cs b/RSSDP/SsdpDevice.cs
index 8a4992239..a595742d0 100644
--- a/RSSDP/SsdpDevice.cs
+++ b/RSSDP/SsdpDevice.cs
@@ -64,7 +64,7 @@ namespace Rssdp
 
             this.Icons = new List<SsdpDeviceIcon>();
             _Devices = new List<SsdpDevice>();
-            this.Devices = new ReadOnlyEnumerable<SsdpDevice>(_Devices);
+            this.Devices = new ReadOnlyCollection<SsdpDevice>(_Devices);
             _CustomResponseHeaders = new CustomHttpHeadersCollection();
             _CustomProperties = new SsdpDevicePropertiesCollection();
         }
diff --git a/RSSDP/SsdpDevicePublisherBase.cs b/RSSDP/SsdpDevicePublisherBase.cs
index 7737733f7..ee3335957 100644
--- a/RSSDP/SsdpDevicePublisherBase.cs
+++ b/RSSDP/SsdpDevicePublisherBase.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.Http;
 using System.Text;
@@ -25,7 +26,7 @@ namespace Rssdp.Infrastructure
         private bool _SupportPnpRootDevice;
 
         private IList<SsdpRootDevice> _Devices;
-        private ReadOnlyEnumerable<SsdpRootDevice> _ReadOnlyDevices;
+        private IReadOnlyList<SsdpRootDevice> _ReadOnlyDevices;
 
         private ITimer _RebroadcastAliveNotificationsTimer;
         private ITimerFactory _timerFactory;
@@ -62,7 +63,7 @@ namespace Rssdp.Infrastructure
             _SupportPnpRootDevice = true;
             _timerFactory = timerFactory;
             _Devices = new List<SsdpRootDevice>();
-            _ReadOnlyDevices = new ReadOnlyEnumerable<SsdpRootDevice>(_Devices);
+            _ReadOnlyDevices = new ReadOnlyCollection<SsdpRootDevice>(_Devices);
             _RecentSearchRequests = new Dictionary<string, SearchRequest>(StringComparer.OrdinalIgnoreCase);
             _Random = new Random();
             _DeviceValidator = new Upnp10DeviceValidator(); //Should probably inject this later, but for now we only support 1.0.
@@ -236,17 +237,17 @@ namespace Rssdp.Infrastructure
 
         #region Search Related Methods
 
-        private void ProcessSearchRequest(string mx, string searchTarget, IpEndPointInfo endPoint)
+        private void ProcessSearchRequest(string mx, string searchTarget, IpEndPointInfo remoteEndPoint, IpAddressInfo receivedOnlocalIpAddress)
         {
             if (String.IsNullOrEmpty(searchTarget))
             {
-                WriteTrace(String.Format("Invalid search request received From {0}, Target is null/empty.", endPoint.ToString()));
+                WriteTrace(String.Format("Invalid search request received From {0}, Target is null/empty.", remoteEndPoint.ToString()));
                 return;
             }
 
-            WriteTrace(String.Format("Search Request Received From {0}, Target = {1}", endPoint.ToString(), searchTarget));
+            WriteTrace(String.Format("Search Request Received From {0}, Target = {1}", remoteEndPoint.ToString(), searchTarget));
 
-            if (IsDuplicateSearchRequest(searchTarget, endPoint))
+            if (IsDuplicateSearchRequest(searchTarget, remoteEndPoint))
             {
                 WriteTrace("Search Request is Duplicate, ignoring.");
                 return;
@@ -294,7 +295,7 @@ namespace Rssdp.Infrastructure
 
                     foreach (var device in deviceList)
                     {
-                        SendDeviceSearchResponses(device, endPoint);
+                        SendDeviceSearchResponses(device, remoteEndPoint, receivedOnlocalIpAddress);
                     }
                 }
                 else
@@ -307,19 +308,19 @@ namespace Rssdp.Infrastructure
             return _Devices.Union(_Devices.SelectManyRecursive<SsdpDevice>((d) => d.Devices));
         }
 
-        private void SendDeviceSearchResponses(SsdpDevice device, IpEndPointInfo endPoint)
+        private void SendDeviceSearchResponses(SsdpDevice device, IpEndPointInfo endPoint, IpAddressInfo receivedOnlocalIpAddress)
         {
             bool isRootDevice = (device as SsdpRootDevice) != null;
             if (isRootDevice)
             {
-                SendSearchResponse(SsdpConstants.UpnpDeviceTypeRootDevice, device, GetUsn(device.Udn, SsdpConstants.UpnpDeviceTypeRootDevice), endPoint);
+                SendSearchResponse(SsdpConstants.UpnpDeviceTypeRootDevice, device, GetUsn(device.Udn, SsdpConstants.UpnpDeviceTypeRootDevice), endPoint, receivedOnlocalIpAddress);
                 if (this.SupportPnpRootDevice)
-                    SendSearchResponse(SsdpConstants.PnpDeviceTypeRootDevice, device, GetUsn(device.Udn, SsdpConstants.PnpDeviceTypeRootDevice), endPoint);
+                    SendSearchResponse(SsdpConstants.PnpDeviceTypeRootDevice, device, GetUsn(device.Udn, SsdpConstants.PnpDeviceTypeRootDevice), endPoint, receivedOnlocalIpAddress);
             }
 
-            SendSearchResponse(device.Udn, device, device.Udn, endPoint);
+            SendSearchResponse(device.Udn, device, device.Udn, endPoint, receivedOnlocalIpAddress);
 
-            SendSearchResponse(device.FullDeviceType, device, GetUsn(device.Udn, device.FullDeviceType), endPoint);
+            SendSearchResponse(device.FullDeviceType, device, GetUsn(device.Udn, device.FullDeviceType), endPoint, receivedOnlocalIpAddress);
         }
 
         private static string GetUsn(string udn, string fullDeviceType)
@@ -327,7 +328,7 @@ namespace Rssdp.Infrastructure
             return String.Format("{0}::{1}", udn, fullDeviceType);
         }
 
-        private async void SendSearchResponse(string searchTarget, SsdpDevice device, string uniqueServiceName, IpEndPointInfo endPoint)
+        private async void SendSearchResponse(string searchTarget, SsdpDevice device, string uniqueServiceName, IpEndPointInfo endPoint, IpAddressInfo receivedOnlocalIpAddress)
         {
             var rootDevice = device.ToRootDevice();
 
@@ -349,7 +350,7 @@ namespace Rssdp.Infrastructure
 
             try
             {
-                await _CommsServer.SendMessage(System.Text.Encoding.UTF8.GetBytes(message), endPoint).ConfigureAwait(false);
+                await _CommsServer.SendMessage(System.Text.Encoding.UTF8.GetBytes(message), endPoint, receivedOnlocalIpAddress).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
@@ -674,7 +675,7 @@ namespace Rssdp.Infrastructure
                 //else if (!e.Message.Headers.Contains("MAN"))
                 //	WriteTrace("Ignoring search request - missing MAN header.");
                 //else
-                ProcessSearchRequest(GetFirstHeaderValue(e.Message.Headers, "MX"), GetFirstHeaderValue(e.Message.Headers, "ST"), e.ReceivedFrom);
+                ProcessSearchRequest(GetFirstHeaderValue(e.Message.Headers, "MX"), GetFirstHeaderValue(e.Message.Headers, "ST"), e.ReceivedFrom, e.LocalIpAddress);
             }
         }
 
-- 
cgit v1.2.3