| 
					
				 | 
			
			
				@@ -1,766 +0,0 @@ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-#pragma warning disable CS1591 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Collections.Generic; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Diagnostics; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.IO; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Linq; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Net.Sockets; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Net.WebSockets; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Reflection; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Threading; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using System.Threading.Tasks; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Emby.Server.Implementations.Services; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Emby.Server.Implementations.SocketSharp; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Jellyfin.Data.Events; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Common.Extensions; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Common.Net; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Controller; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Controller.Authentication; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Controller.Configuration; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Controller.Net; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Model.Globalization; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Model.Serialization; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using MediaBrowser.Model.Services; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.AspNetCore.Http; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.AspNetCore.Http.Extensions; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.AspNetCore.WebUtilities; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.Extensions.Configuration; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.Extensions.Hosting; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.Extensions.Logging; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using Microsoft.Extensions.Primitives; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-using ServiceStack.Text.Jsv; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-namespace Emby.Server.Implementations.HttpServer 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-{ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-    public class HttpListenerHost : IHttpServer 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// The key for a setting that specifies the default redirect path 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// to use for requests where the URL base prefix is invalid or missing. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public const string DefaultRedirectKey = "HttpListenerHost:DefaultRedirectPath"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly ILogger<HttpListenerHost> _logger; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly ILoggerFactory _loggerFactory; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly IServerConfigurationManager _config; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly INetworkManager _networkManager; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly IServerApplicationHost _appHost; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly IJsonSerializer _jsonSerializer; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly IXmlSerializer _xmlSerializer; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly Func<Type, Func<string, object>> _funcParseFn; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly string _defaultRedirectPath; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly string _baseUrlPrefix; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly Dictionary<Type, Type> _serviceOperationsMap = new Dictionary<Type, Type>(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private readonly IHostEnvironment _hostEnvironment; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private IWebSocketListener[] _webSocketListeners = Array.Empty<IWebSocketListener>(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private bool _disposed = false; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public HttpListenerHost( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IServerApplicationHost applicationHost, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ILogger<HttpListenerHost> logger, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IServerConfigurationManager config, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IConfiguration configuration, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            INetworkManager networkManager, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IJsonSerializer jsonSerializer, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IXmlSerializer xmlSerializer, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ILocalizationManager localizationManager, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ServiceController serviceController, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IHostEnvironment hostEnvironment, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ILoggerFactory loggerFactory) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _appHost = applicationHost; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _logger = logger; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _config = config; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _defaultRedirectPath = configuration[DefaultRedirectKey]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _baseUrlPrefix = _config.Configuration.BaseUrl; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _networkManager = networkManager; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _jsonSerializer = jsonSerializer; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _xmlSerializer = xmlSerializer; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ServiceController = serviceController; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _hostEnvironment = hostEnvironment; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _loggerFactory = loggerFactory; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _funcParseFn = t => s => JsvReader.GetParseFn(t)(s); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            Instance = this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ResponseFilters = Array.Empty<Action<IRequest, HttpResponse, object>>(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            GlobalResponse = localizationManager.GetLocalizedString("StartupEmbyServerIsLoading"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public event EventHandler<GenericEventArgs<IWebSocketConnection>> WebSocketConnected; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Action<IRequest, HttpResponse, object>[] ResponseFilters { get; set; } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public static HttpListenerHost Instance { get; protected set; } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public string[] UrlPrefixes { get; private set; } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public string GlobalResponse { get; set; } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public ServiceController ServiceController { get; } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public object CreateInstance(Type type) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _appHost.CreateInstance(type); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private static string NormalizeUrlPath(string path) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (path.Length > 0 && path[0] == '/') 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                // If the path begins with a leading slash, just return it as-is 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return path; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                // If the path does not begin with a leading slash, append one for consistency 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return "/" + path; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Applies the request filters. Returns whether or not the request has been handled 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// and no more processing should be done. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <returns></returns> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public void ApplyRequestFilters(IRequest req, HttpResponse res, object requestDto) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // Exec all RequestFilter attributes with Priority < 0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var attributes = GetRequestFilterAttributes(requestDto.GetType()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            int count = attributes.Count; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            int i = 0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            for (; i < count && attributes[i].Priority < 0; i++) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var attribute = attributes[i]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                attribute.RequestFilter(req, res, requestDto); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // Exec remaining RequestFilter attributes with Priority >= 0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            for (; i < count && attributes[i].Priority >= 0; i++) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var attribute = attributes[i]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                attribute.RequestFilter(req, res, requestDto); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Type GetServiceTypeByRequest(Type requestType) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _serviceOperationsMap.TryGetValue(requestType, out var serviceType); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return serviceType; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public void AddServiceInfo(Type serviceType, Type requestType) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _serviceOperationsMap[requestType] = serviceType; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private List<IHasRequestFilter> GetRequestFilterAttributes(Type requestDtoType) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var attributes = requestDtoType.GetCustomAttributes(true).OfType<IHasRequestFilter>().ToList(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var serviceType = GetServiceTypeByRequest(requestDtoType); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (serviceType != null) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                attributes.AddRange(serviceType.GetCustomAttributes(true).OfType<IHasRequestFilter>()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            attributes.Sort((x, y) => x.Priority - y.Priority); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return attributes; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private static Exception GetActualException(Exception ex) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (ex is AggregateException agg) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var inner = agg.InnerException; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (inner != null) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return GetActualException(inner); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    var inners = agg.InnerExceptions; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    if (inners.Count > 0) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        return GetActualException(inners[0]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return ex; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private int GetStatusCode(Exception ex) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            switch (ex) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case ArgumentException _: return 400; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case AuthenticationException _: return 401; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case SecurityException _: return 403; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case DirectoryNotFoundException _: 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case FileNotFoundException _: 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case ResourceNotFoundException _: return 404; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                case MethodNotAllowedException _: return 405; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                default: return 500; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private async Task ErrorHandler(Exception ex, IRequest httpReq, int statusCode, string urlToLog, bool ignoreStackTrace) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (ignoreStackTrace) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                _logger.LogError("Error processing request: {Message}. URL: {Url}", ex.Message.TrimEnd('.'), urlToLog); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                _logger.LogError(ex, "Error processing request. URL: {Url}", urlToLog); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var httpRes = httpReq.Response; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (httpRes.HasStarted) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            httpRes.StatusCode = statusCode; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var errContent = _hostEnvironment.IsDevelopment() 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    ? (NormalizeExceptionMessage(ex) ?? string.Empty) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    : "Error processing request."; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            httpRes.ContentType = "text/plain"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            httpRes.ContentLength = errContent.Length; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            await httpRes.WriteAsync(errContent).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private string NormalizeExceptionMessage(Exception ex) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // Do not expose the exception message for AuthenticationException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (ex is AuthenticationException) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // Strip any information we don't want to reveal 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return ex.Message 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                ?.Replace(_config.ApplicationPaths.ProgramSystemPath, string.Empty, StringComparison.OrdinalIgnoreCase) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                .Replace(_config.ApplicationPaths.ProgramDataPath, string.Empty, StringComparison.OrdinalIgnoreCase); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public static string RemoveQueryStringByKey(string url, string key) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var uri = new Uri(url); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // this gets all the query string key value pairs as a collection 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var newQueryString = QueryHelpers.ParseQuery(uri.Query); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var originalCount = newQueryString.Count; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (originalCount == 0) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return url; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // this removes the key if exists 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            newQueryString.Remove(key); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (originalCount == newQueryString.Count) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return url; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            // this gets the page path from root without QueryString 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            string pagePathWithoutQueryString = url.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries)[0]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return newQueryString.Count > 0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                ? QueryHelpers.AddQueryString(pagePathWithoutQueryString, newQueryString.ToDictionary(kv => kv.Key, kv => kv.Value.ToString())) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                : pagePathWithoutQueryString; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private static string GetUrlToLog(string url) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            url = RemoveQueryStringByKey(url, "api_key"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return url; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private static string NormalizeConfiguredLocalAddress(string address) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var add = address.AsSpan().Trim('/'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            int index = add.IndexOf('/'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (index != -1) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                add = add.Slice(index + 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return add.TrimStart('/').ToString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private bool ValidateHost(string host) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var hosts = _config 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                .Configuration 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                .LocalNetworkAddresses 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                .Select(NormalizeConfiguredLocalAddress) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                .ToList(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (hosts.Count == 0) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            host ??= string.Empty; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (_networkManager.IsInPrivateAddressSpace(host)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                hosts.Add("localhost"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                hosts.Add("127.0.0.1"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return hosts.Any(i => host.IndexOf(i, StringComparison.OrdinalIgnoreCase) != -1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private bool ValidateRequest(string remoteIp, bool isLocal) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (isLocal) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (_config.Configuration.EnableRemoteAccess) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var addressFilter = _config.Configuration.RemoteIPFilter.Where(i => !string.IsNullOrWhiteSpace(i)).ToArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (addressFilter.Length > 0 && !_networkManager.IsInLocalNetwork(remoteIp)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    if (_config.Configuration.IsRemoteIPFilterBlacklist) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        return !_networkManager.IsAddressInSubnets(remoteIp, addressFilter); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        return _networkManager.IsAddressInSubnets(remoteIp, addressFilter); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!_networkManager.IsInLocalNetwork(remoteIp)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return false; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Validate a connection from a remote IP address to a URL to see if a redirection to HTTPS is required. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <returns>True if the request is valid, or false if the request is not valid and an HTTPS redirect is required.</returns> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private bool ValidateSsl(string remoteIp, string urlString) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (_config.Configuration.RequireHttps 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                && _appHost.ListenWithHttps 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                && !urlString.Contains("https://", StringComparison.OrdinalIgnoreCase)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                // These are hacks, but if these ever occur on ipv6 in the local network they could be incorrectly redirected 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (urlString.IndexOf("system/ping", StringComparison.OrdinalIgnoreCase) != -1 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    || urlString.IndexOf("dlna/", StringComparison.OrdinalIgnoreCase) != -1) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!_networkManager.IsInLocalNetwork(remoteIp)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return false; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return true; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <inheritdoc /> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Task RequestHandler(HttpContext context) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (context.WebSockets.IsWebSocketRequest) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return WebSocketRequestHandler(context); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var request = context.Request; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var response = context.Response; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var localPath = context.Request.Path.ToString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var req = new WebSocketSharpRequest(request, response, request.Path); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return RequestHandler(req, request.GetDisplayUrl(), request.Host.ToString(), localPath, context.RequestAborted); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Overridable method that can be used to implement a custom handler. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private async Task RequestHandler(IHttpRequest httpReq, string urlString, string host, string localPath, CancellationToken cancellationToken) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var stopWatch = new Stopwatch(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            stopWatch.Start(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var httpRes = httpReq.Response; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            string urlToLog = GetUrlToLog(urlString); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            string remoteIp = httpReq.RemoteIp; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            try 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (_disposed) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.StatusCode = 503; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.ContentType = "text/plain"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await httpRes.WriteAsync("Server shutting down", cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!ValidateHost(host)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.StatusCode = 400; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.ContentType = "text/plain"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await httpRes.WriteAsync("Invalid host", cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!ValidateRequest(remoteIp, httpReq.IsLocal)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.StatusCode = 403; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.ContentType = "text/plain"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await httpRes.WriteAsync("Forbidden", cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!ValidateSsl(httpReq.RemoteIp, urlString)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    RedirectToSecureUrl(httpReq, httpRes, urlString); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (string.Equals(httpReq.Verb, "OPTIONS", StringComparison.OrdinalIgnoreCase)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.StatusCode = 200; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    foreach (var (key, value) in GetDefaultCorsHeaders(httpReq)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        httpRes.Headers.Add(key, value); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.ContentType = "text/plain"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await httpRes.WriteAsync(string.Empty, cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (string.Equals(localPath, _baseUrlPrefix + "/", StringComparison.OrdinalIgnoreCase) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    || string.Equals(localPath, _baseUrlPrefix, StringComparison.OrdinalIgnoreCase) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    || string.Equals(localPath, "/", StringComparison.OrdinalIgnoreCase) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    || string.IsNullOrEmpty(localPath) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    || !localPath.StartsWith(_baseUrlPrefix, StringComparison.OrdinalIgnoreCase)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // Always redirect back to the default path if the base prefix is invalid or missing 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    _logger.LogDebug("Normalizing a URL at {0}", localPath); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    httpRes.Redirect(_baseUrlPrefix + "/" + _defaultRedirectPath); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!string.IsNullOrEmpty(GlobalResponse)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // We don't want the address pings in ApplicationHost to fail 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    if (localPath.IndexOf("system/ping", StringComparison.OrdinalIgnoreCase) == -1) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        httpRes.StatusCode = 503; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        httpRes.ContentType = "text/html"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        await httpRes.WriteAsync(GlobalResponse, cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var handler = GetServiceHandler(httpReq); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (handler != null) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await handler.ProcessRequestAsync(this, httpReq, httpRes, cancellationToken).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                else 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    throw new FileNotFoundException(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            catch (Exception requestEx) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                try 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    var requestInnerEx = GetActualException(requestEx); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    var statusCode = GetStatusCode(requestInnerEx); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    foreach (var (key, value) in GetDefaultCorsHeaders(httpReq)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        if (!httpRes.Headers.ContainsKey(key)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                            httpRes.Headers.Add(key, value); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    bool ignoreStackTrace = 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        requestInnerEx is SocketException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        || requestInnerEx is IOException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        || requestInnerEx is OperationCanceledException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        || requestInnerEx is SecurityException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        || requestInnerEx is AuthenticationException 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        || requestInnerEx is FileNotFoundException; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // Do not handle 500 server exceptions manually when in development mode. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // Instead, re-throw the exception so it can be handled by the DeveloperExceptionPageMiddleware. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // However, do not use the DeveloperExceptionPageMiddleware when the stack trace should be ignored, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    // because it will log the stack trace when it handles the exception. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    if (statusCode == 500 && !ignoreStackTrace && _hostEnvironment.IsDevelopment()) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        throw; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    await ErrorHandler(requestInnerEx, httpReq, statusCode, urlToLog, ignoreStackTrace).ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                catch (Exception handlerException) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    var aggregateEx = new AggregateException("Error while handling request exception", requestEx, handlerException); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    _logger.LogError(aggregateEx, "Error while handling exception in response to {Url}", urlToLog); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    if (_hostEnvironment.IsDevelopment()) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                        throw aggregateEx; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            finally 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (httpRes.StatusCode >= 500) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    _logger.LogDebug("Sending HTTP Response 500 in response to {Url}", urlToLog); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                stopWatch.Stop(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var elapsed = stopWatch.Elapsed; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (elapsed.TotalMilliseconds > 500) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    _logger.LogWarning("HTTP Response {StatusCode} to {RemoteIp}. Time (slow): {Elapsed:g}. {Url}", httpRes.StatusCode, remoteIp, elapsed, urlToLog); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private async Task WebSocketRequestHandler(HttpContext context) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (_disposed) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            try 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                _logger.LogInformation("WS {IP} request", context.Connection.RemoteIpAddress); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                using var connection = new WebSocketConnection( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    _loggerFactory.CreateLogger<WebSocketConnection>(), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    webSocket, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    context.Connection.RemoteIpAddress, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    context.Request.Query) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    OnReceive = ProcessWebSocketMessageReceived 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                WebSocketConnected?.Invoke(this, new GenericEventArgs<IWebSocketConnection>(connection)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                await connection.ProcessAsync().ConfigureAwait(false); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                _logger.LogInformation("WS {IP} closed", context.Connection.RemoteIpAddress); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            catch (Exception ex) // Otherwise ASP.Net will ignore the exception 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                _logger.LogError(ex, "WS {IP} WebSocketRequestHandler error", context.Connection.RemoteIpAddress); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (!context.Response.HasStarted) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    context.Response.StatusCode = 500; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Get the default CORS headers. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <param name="req"></param> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <returns></returns> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public IDictionary<string, string> GetDefaultCorsHeaders(IRequest req) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var origin = req.Headers["Origin"]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (origin == StringValues.Empty) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                origin = req.Headers["Host"]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                if (origin == StringValues.Empty) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    origin = "*"; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var headers = new Dictionary<string, string>(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            headers.Add("Access-Control-Allow-Origin", origin); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            headers.Add("Access-Control-Allow-Credentials", "true"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            headers.Add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            headers.Add("Access-Control-Allow-Headers", "Content-Type, Authorization, Range, X-MediaBrowser-Token, X-Emby-Authorization, Cookie"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return headers; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        // Entry point for HttpListener 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public ServiceHandler GetServiceHandler(IHttpRequest httpReq) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var pathInfo = httpReq.PathInfo; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            pathInfo = ServiceHandler.GetSanitizedPathInfo(pathInfo, out string contentType); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var restPath = ServiceController.GetRestPathForRequest(httpReq.HttpMethod, pathInfo); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (restPath != null) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return new ServiceHandler(restPath, contentType); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _logger.LogError("Could not find handler for {PathInfo}", pathInfo); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private void RedirectToSecureUrl(IHttpRequest httpReq, HttpResponse httpRes, string url) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (Uri.TryCreate(url, UriKind.Absolute, out Uri uri)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                var builder = new UriBuilder(uri) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Port = _config.Configuration.PublicHttpsPort, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Scheme = "https" 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                url = builder.Uri.ToString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            httpRes.Redirect(url); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Adds the rest handlers. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <param name="serviceTypes">The service types to register with the <see cref="ServiceController"/>.</param> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <param name="listeners">The web socket listeners.</param> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <param name="urlPrefixes">The URL prefixes. See <see cref="UrlPrefixes"/>.</param> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public void Init(IEnumerable<Type> serviceTypes, IEnumerable<IWebSocketListener> listeners, IEnumerable<string> urlPrefixes) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _webSocketListeners = listeners.ToArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            UrlPrefixes = urlPrefixes.ToArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ServiceController.Init(this, serviceTypes); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            ResponseFilters = new Action<IRequest, HttpResponse, object>[] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                new ResponseFilter(this, _logger).FilterResponse 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public RouteAttribute[] GetRouteAttributes(Type requestType) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var routes = requestType.GetTypeInfo().GetCustomAttributes<RouteAttribute>(true).ToList(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            var clone = routes.ToList(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            foreach (var route in clone) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                routes.Add(new RouteAttribute(NormalizeCustomRoutePath(route.Path), route.Verbs) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Notes = route.Notes, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Priority = route.Priority, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Summary = route.Summary 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                routes.Add(new RouteAttribute(NormalizeEmbyRoutePath(route.Path), route.Verbs) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Notes = route.Notes, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Priority = route.Priority, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Summary = route.Summary 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                routes.Add(new RouteAttribute(NormalizeMediaBrowserRoutePath(route.Path), route.Verbs) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Notes = route.Notes, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Priority = route.Priority, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    Summary = route.Summary 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return routes.ToArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Func<string, object> GetParseFn(Type propertyType) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _funcParseFn(propertyType); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public void SerializeToJson(object o, Stream stream) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _jsonSerializer.SerializeToStream(o, stream); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public void SerializeToXml(object o, Stream stream) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _xmlSerializer.SerializeToStream(o, stream); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Task<object> DeserializeXml(Type type, Stream stream) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return Task.FromResult(_xmlSerializer.DeserializeFromStream(type, stream)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        public Task<object> DeserializeJson(Type type, Stream stream) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _jsonSerializer.DeserializeFromStreamAsync(stream, type); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private string NormalizeEmbyRoutePath(string path) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _logger.LogDebug("Normalizing /emby route"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _baseUrlPrefix + "/emby" + NormalizeUrlPath(path); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private string NormalizeMediaBrowserRoutePath(string path) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _logger.LogDebug("Normalizing /mediabrowser route"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _baseUrlPrefix + "/mediabrowser" + NormalizeUrlPath(path); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private string NormalizeCustomRoutePath(string path) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            _logger.LogDebug("Normalizing custom route {0}", path); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return _baseUrlPrefix + NormalizeUrlPath(path); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// Processes the web socket message received. 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// </summary> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        /// <param name="result">The result.</param> 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        private Task ProcessWebSocketMessageReceived(WebSocketMessageInfo result) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (_disposed) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                return Task.CompletedTask; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            IEnumerable<Task> GetTasks() 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                foreach (var x in _webSocketListeners) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                    yield return x.ProcessMessageAsync(result); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            return Task.WhenAll(GetTasks()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-    } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-} 
			 |