jellyfin/Emby.Server.Implementations/HttpServer/HttpListenerHost.cs

805 lines
27 KiB
C#
Raw Normal View History

2016-11-10 14:41:24 +00:00
using MediaBrowser.Common.Extensions;
2015-06-13 04:14:48 +00:00
using MediaBrowser.Controller.Configuration;
2013-12-07 15:52:38 +00:00
using MediaBrowser.Controller.Net;
using MediaBrowser.Model.Logging;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
2016-11-12 07:14:04 +00:00
using System.Text;
2013-12-07 15:52:38 +00:00
using System.Threading.Tasks;
2016-11-04 01:18:51 +00:00
using Emby.Server.Implementations.HttpServer;
2016-11-05 02:17:18 +00:00
using Emby.Server.Implementations.HttpServer.SocketSharp;
2017-02-13 01:07:48 +00:00
using Emby.Server.Implementations.Services;
2015-12-14 14:45:42 +00:00
using MediaBrowser.Common.Net;
2015-10-30 17:00:33 +00:00
using MediaBrowser.Common.Security;
2016-10-26 06:01:42 +00:00
using MediaBrowser.Controller;
2016-11-08 18:44:23 +00:00
using MediaBrowser.Model.Cryptography;
2016-03-18 03:40:15 +00:00
using MediaBrowser.Model.Extensions;
using MediaBrowser.Model.IO;
2016-11-08 18:44:23 +00:00
using MediaBrowser.Model.Net;
2016-11-10 14:41:24 +00:00
using MediaBrowser.Model.Serialization;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Model.Services;
2016-11-11 03:29:51 +00:00
using MediaBrowser.Model.System;
2016-11-08 18:44:23 +00:00
using MediaBrowser.Model.Text;
using SocketHttpListener.Net;
using SocketHttpListener.Primitives;
2013-12-07 15:52:38 +00:00
2016-11-11 03:29:51 +00:00
namespace Emby.Server.Implementations.HttpServer
2013-12-07 15:52:38 +00:00
{
2017-02-13 02:06:54 +00:00
public class HttpListenerHost : IHttpServer, IDisposable
2013-12-07 15:52:38 +00:00
{
private string DefaultRedirectPath { get; set; }
private readonly ILogger _logger;
2014-01-09 04:44:51 +00:00
public IEnumerable<string> UrlPrefixes { get; private set; }
2013-12-07 15:52:38 +00:00
2016-10-26 06:01:42 +00:00
private readonly List<IService> _restServices = new List<IService>();
2013-12-07 15:52:38 +00:00
2014-07-18 22:14:59 +00:00
private IHttpListener _listener;
2013-12-07 15:52:38 +00:00
public event EventHandler<WebSocketConnectEventArgs> WebSocketConnected;
2015-03-08 19:48:30 +00:00
public event EventHandler<WebSocketConnectingEventArgs> WebSocketConnecting;
2013-12-07 15:52:38 +00:00
2015-06-13 04:14:48 +00:00
private readonly IServerConfigurationManager _config;
2015-12-14 14:45:42 +00:00
private readonly INetworkManager _networkManager;
2016-11-08 18:44:23 +00:00
private readonly IMemoryStreamFactory _memoryStreamProvider;
2015-06-13 04:14:48 +00:00
2016-10-26 06:01:42 +00:00
private readonly IServerApplicationHost _appHost;
2016-11-08 18:44:23 +00:00
private readonly ITextEncoding _textEncoding;
private readonly ISocketFactory _socketFactory;
private readonly ICryptoProvider _cryptoProvider;
2017-03-12 19:27:26 +00:00
private readonly IFileSystem _fileSystem;
2016-11-10 14:41:24 +00:00
private readonly IJsonSerializer _jsonSerializer;
private readonly IXmlSerializer _xmlSerializer;
2016-11-11 03:29:51 +00:00
private readonly ICertificate _certificate;
private readonly IEnvironmentInfo _environment;
private readonly IStreamFactory _streamFactory;
private readonly Func<Type, Func<string, object>> _funcParseFn;
private readonly bool _enableDualModeSockets;
2016-11-10 14:41:24 +00:00
2017-02-13 01:07:48 +00:00
public List<Action<IRequest, IResponse, object>> RequestFilters { get; set; }
2017-02-13 02:06:54 +00:00
public List<Action<IRequest, IResponse, object>> ResponseFilters { get; set; }
private readonly Dictionary<Type, Type> ServiceOperationsMap = new Dictionary<Type, Type>();
public static HttpListenerHost Instance { get; protected set; }
2017-02-13 01:07:48 +00:00
2016-10-26 06:01:42 +00:00
public HttpListenerHost(IServerApplicationHost applicationHost,
2016-11-11 03:29:51 +00:00
ILogger logger,
2015-06-13 04:14:48 +00:00
IServerConfigurationManager config,
2015-01-17 19:30:23 +00:00
string serviceName,
2017-03-12 19:27:26 +00:00
string defaultRedirectPath, INetworkManager networkManager, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding, ISocketFactory socketFactory, ICryptoProvider cryptoProvider, IJsonSerializer jsonSerializer, IXmlSerializer xmlSerializer, IEnvironmentInfo environment, ICertificate certificate, IStreamFactory streamFactory, Func<Type, Func<string, object>> funcParseFn, bool enableDualModeSockets, IFileSystem fileSystem)
2013-12-07 15:52:38 +00:00
{
2017-02-13 02:06:54 +00:00
Instance = this;
2016-10-26 06:01:42 +00:00
_appHost = applicationHost;
2013-12-07 15:52:38 +00:00
DefaultRedirectPath = defaultRedirectPath;
2015-12-14 14:45:42 +00:00
_networkManager = networkManager;
2016-10-06 18:55:01 +00:00
_memoryStreamProvider = memoryStreamProvider;
2016-11-08 18:44:23 +00:00
_textEncoding = textEncoding;
_socketFactory = socketFactory;
_cryptoProvider = cryptoProvider;
2016-11-10 14:41:24 +00:00
_jsonSerializer = jsonSerializer;
_xmlSerializer = xmlSerializer;
2016-11-11 03:29:51 +00:00
_environment = environment;
_certificate = certificate;
_streamFactory = streamFactory;
_funcParseFn = funcParseFn;
_enableDualModeSockets = enableDualModeSockets;
2017-03-12 19:27:26 +00:00
_fileSystem = fileSystem;
2015-06-13 04:14:48 +00:00
_config = config;
2013-12-07 15:52:38 +00:00
2016-11-11 03:29:51 +00:00
_logger = logger;
2017-02-13 01:07:48 +00:00
RequestFilters = new List<Action<IRequest, IResponse, object>>();
2017-02-13 02:06:54 +00:00
ResponseFilters = new List<Action<IRequest, IResponse, object>>();
2013-12-07 15:52:38 +00:00
}
2015-09-13 23:07:54 +00:00
public string GlobalResponse { get; set; }
2015-10-30 17:00:33 +00:00
2016-11-12 06:58:50 +00:00
readonly Dictionary<Type, int> _mapExceptionToStatusCode = new Dictionary<Type, int>
2013-12-07 15:52:38 +00:00
{
{typeof (ResourceNotFoundException), 404},
{typeof (FileNotFoundException), 404},
2016-11-11 03:29:51 +00:00
//{typeof (DirectoryNotFoundException), 404},
2014-11-15 02:31:03 +00:00
{typeof (SecurityException), 401},
2015-10-30 17:00:33 +00:00
{typeof (PaymentRequiredException), 402},
2016-12-27 07:24:44 +00:00
{typeof (ArgumentException), 400}
2013-12-07 15:52:38 +00:00
};
2017-02-13 01:07:48 +00:00
protected ILogger Logger
2016-11-08 18:44:23 +00:00
{
get
{
return _logger;
}
}
2017-02-13 02:06:54 +00:00
public object CreateInstance(Type type)
2016-11-10 14:41:24 +00:00
{
2017-02-13 01:07:48 +00:00
return _appHost.CreateInstance(type);
2016-11-10 14:41:24 +00:00
}
2017-02-13 01:07:48 +00:00
private ServiceController CreateServiceController()
2013-12-07 15:52:38 +00:00
{
2017-02-13 01:07:48 +00:00
var types = _restServices.Select(r => r.GetType()).ToArray();
return new ServiceController(() => types);
2016-11-11 01:37:20 +00:00
}
2013-12-07 15:52:38 +00:00
2017-02-13 01:07:48 +00:00
/// <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, IResponse res, object requestDto)
2016-11-11 01:37:20 +00:00
{
2017-02-13 01:07:48 +00:00
//Exec all RequestFilter attributes with Priority < 0
var attributes = GetRequestFilterAttributes(requestDto.GetType());
var i = 0;
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
attribute.RequestFilter(req, res, requestDto);
}
//Exec global filters
foreach (var requestFilter in RequestFilters)
{
requestFilter(req, res, requestDto);
}
//Exec remaining RequestFilter attributes with Priority >= 0
for (; i < attributes.Length && attributes[i].Priority >= 0; i++)
{
var attribute = attributes[i];
attribute.RequestFilter(req, res, requestDto);
}
2013-12-07 15:52:38 +00:00
}
2017-02-13 01:07:48 +00:00
public Type GetServiceTypeByRequest(Type requestType)
2013-12-07 15:52:38 +00:00
{
2017-02-13 01:07:48 +00:00
Type serviceType;
ServiceOperationsMap.TryGetValue(requestType, out serviceType);
return serviceType;
}
2013-12-07 15:52:38 +00:00
2017-02-13 01:07:48 +00:00
public void AddServiceInfo(Type serviceType, Type requestType, Type responseType)
{
ServiceOperationsMap[requestType] = serviceType;
2013-12-07 15:52:38 +00:00
}
2017-02-13 01:07:48 +00:00
private IHasRequestFilter[] GetRequestFilterAttributes(Type requestDtoType)
2013-12-07 15:52:38 +00:00
{
2017-02-13 02:06:54 +00:00
var attributes = requestDtoType.GetTypeInfo().GetCustomAttributes(true).OfType<IHasRequestFilter>().ToList();
2017-02-13 01:07:48 +00:00
var serviceType = GetServiceTypeByRequest(requestDtoType);
if (serviceType != null)
{
2017-02-13 02:06:54 +00:00
attributes.AddRange(serviceType.GetTypeInfo().GetCustomAttributes(true).OfType<IHasRequestFilter>());
2017-02-13 01:07:48 +00:00
}
attributes.Sort((x, y) => x.Priority - y.Priority);
return attributes.ToArray();
2013-12-07 15:52:38 +00:00
}
/// <summary>
/// Starts the Web Service
/// </summary>
2014-07-18 22:14:59 +00:00
private void StartListener()
2013-12-07 15:52:38 +00:00
{
2016-11-11 01:58:20 +00:00
WebSocketSharpRequest.HandlerFactoryPath = GetHandlerPathIfAny(UrlPrefixes.First());
2014-07-09 00:46:11 +00:00
2014-12-27 22:52:41 +00:00
_listener = GetListener();
2014-07-19 01:28:40 +00:00
2015-03-08 19:48:30 +00:00
_listener.WebSocketConnected = OnWebSocketConnected;
_listener.WebSocketConnecting = OnWebSocketConnecting;
2014-07-19 01:28:40 +00:00
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
2013-12-07 15:52:38 +00:00
2014-07-18 22:14:59 +00:00
_listener.Start(UrlPrefixes);
2014-07-09 00:46:11 +00:00
}
2013-12-07 15:52:38 +00:00
2016-10-25 19:02:04 +00:00
public static string GetHandlerPathIfAny(string listenerUrl)
{
if (listenerUrl == null) return null;
var pos = listenerUrl.IndexOf("://", StringComparison.OrdinalIgnoreCase);
if (pos == -1) return null;
var startHostUrl = listenerUrl.Substring(pos + "://".Length);
var endPos = startHostUrl.IndexOf('/');
if (endPos == -1) return null;
var endHostUrl = startHostUrl.Substring(endPos + 1);
return string.IsNullOrEmpty(endHostUrl) ? null : endHostUrl.TrimEnd('/');
}
2014-12-27 22:52:41 +00:00
private IHttpListener GetListener()
{
2016-11-11 03:29:51 +00:00
return new WebSocketSharpListener(_logger,
_certificate,
_memoryStreamProvider,
_textEncoding,
_networkManager,
_socketFactory,
_cryptoProvider,
_streamFactory,
_enableDualModeSockets,
2017-03-12 19:27:26 +00:00
GetRequest,
_fileSystem);
2016-11-08 18:44:23 +00:00
}
private IHttpRequest GetRequest(HttpListenerContext httpContext)
{
var operationName = httpContext.Request.GetOperationName();
var req = new WebSocketSharpRequest(httpContext, operationName, _logger, _memoryStreamProvider);
return req;
2014-12-27 22:52:41 +00:00
}
2015-03-08 19:48:30 +00:00
private void OnWebSocketConnecting(WebSocketConnectingEventArgs args)
{
2016-04-22 16:12:20 +00:00
if (_disposed)
{
return;
}
2015-03-08 19:48:30 +00:00
if (WebSocketConnecting != null)
{
WebSocketConnecting(this, args);
}
}
private void OnWebSocketConnected(WebSocketConnectEventArgs args)
2014-07-09 00:46:11 +00:00
{
2016-04-22 16:12:20 +00:00
if (_disposed)
{
return;
}
2014-07-18 22:14:59 +00:00
if (WebSocketConnected != null)
2014-07-09 00:46:11 +00:00
{
2014-07-18 22:14:59 +00:00
WebSocketConnected(this, args);
2014-07-09 00:46:11 +00:00
}
2013-12-07 15:52:38 +00:00
}
2016-12-27 07:24:44 +00:00
private int GetStatusCode(Exception ex)
{
if (ex is ArgumentException)
{
return 400;
}
2017-04-02 04:08:07 +00:00
var exceptionType = ex.GetType();
2016-12-27 07:24:44 +00:00
int statusCode;
2017-04-02 04:08:07 +00:00
if (!_mapExceptionToStatusCode.TryGetValue(exceptionType, out statusCode))
2016-12-27 07:24:44 +00:00
{
2017-04-02 04:08:07 +00:00
if (string.Equals(exceptionType.Name, "DirectoryNotFoundException", StringComparison.OrdinalIgnoreCase))
{
statusCode = 404;
}
else
{
statusCode = 500;
}
2016-12-27 07:24:44 +00:00
}
return statusCode;
}
2016-12-26 17:38:12 +00:00
private void ErrorHandler(Exception ex, IRequest httpReq, bool logException = true)
2013-12-07 15:52:38 +00:00
{
try
{
2016-12-26 17:38:12 +00:00
if (logException)
{
_logger.ErrorException("Error processing request", ex);
}
2016-11-10 14:41:24 +00:00
2013-12-07 15:52:38 +00:00
var httpRes = httpReq.Response;
if (httpRes.IsClosed)
{
return;
}
2015-01-17 19:30:23 +00:00
2016-12-27 07:24:44 +00:00
var statusCode = GetStatusCode(ex);
2016-11-12 06:58:50 +00:00
httpRes.StatusCode = statusCode;
2013-12-07 15:52:38 +00:00
2016-11-10 14:41:24 +00:00
httpRes.ContentType = "text/html";
2016-11-12 07:14:04 +00:00
Write(httpRes, ex.Message);
2013-12-07 15:52:38 +00:00
}
catch
2013-12-07 15:52:38 +00:00
{
2016-02-04 18:04:04 +00:00
//_logger.ErrorException("Error this.ProcessRequest(context)(Exception while writing error to the response)", errorEx);
2013-12-07 15:52:38 +00:00
}
}
/// <summary>
/// Shut down the Web Service
/// </summary>
public void Stop()
{
2014-07-18 22:14:59 +00:00
if (_listener != null)
2013-12-07 15:52:38 +00:00
{
2016-12-28 06:08:18 +00:00
_logger.Info("Stopping HttpListener...");
2014-07-18 22:14:59 +00:00
_listener.Stop();
2016-12-28 06:08:18 +00:00
_logger.Info("HttpListener stopped");
2013-12-07 15:52:38 +00:00
}
}
2016-01-23 03:10:21 +00:00
private readonly Dictionary<string, int> _skipLogExtensions = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)
{
{".js", 0},
{".css", 0},
{".woff", 0},
{".woff2", 0},
{".ttf", 0},
{".html", 0}
};
2016-02-03 21:56:00 +00:00
private bool EnableLogging(string url, string localPath)
2016-01-23 03:10:21 +00:00
{
2016-02-01 19:54:49 +00:00
var extension = GetExtension(url);
2016-01-23 03:10:21 +00:00
2016-02-03 21:56:00 +00:00
if (string.IsNullOrWhiteSpace(extension) || !_skipLogExtensions.ContainsKey(extension))
{
if (string.IsNullOrWhiteSpace(localPath) || localPath.IndexOf("system/ping", StringComparison.OrdinalIgnoreCase) == -1)
{
return true;
}
}
return false;
2016-01-23 03:10:21 +00:00
}
2016-02-01 19:54:49 +00:00
private string GetExtension(string url)
{
var parts = url.Split(new[] { '?' }, 2);
return Path.GetExtension(parts[0]);
}
2016-03-15 19:11:53 +00:00
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 = MyHttpUtility.ParseQueryString(uri.Query);
2016-11-11 03:29:51 +00:00
var originalCount = newQueryString.Count;
if (originalCount == 0)
2016-03-15 19:11:53 +00:00
{
return url;
}
// this removes the key if exists
newQueryString.Remove(key);
2016-11-11 03:29:51 +00:00
if (originalCount == newQueryString.Count)
{
return url;
}
2016-03-15 19:11:53 +00:00
// this gets the page path from root without QueryString
2016-11-11 03:29:51 +00:00
string pagePathWithoutQueryString = url.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries)[0];
2016-03-15 19:11:53 +00:00
return newQueryString.Count > 0
? String.Format("{0}?{1}", pagePathWithoutQueryString, newQueryString)
: pagePathWithoutQueryString;
}
private string GetUrlToLog(string url)
{
url = RemoveQueryStringByKey(url, "api_key");
return url;
}
private string NormalizeConfiguredLocalAddress(string address)
{
var index = address.Trim('/').IndexOf('/');
if (index != -1)
{
address = address.Substring(index + 1);
}
return address.Trim('/');
}
private bool ValidateHost(Uri url)
{
var hosts = _config
.Configuration
.LocalNetworkAddresses
.Select(NormalizeConfiguredLocalAddress)
.ToList();
if (hosts.Count == 0)
{
return true;
}
var host = url.Host ?? string.Empty;
_logger.Debug("Validating host {0}", host);
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;
}
2013-12-07 15:52:38 +00:00
/// <summary>
/// Overridable method that can be used to implement a custom hnandler
/// </summary>
2014-07-18 22:14:59 +00:00
/// <param name="httpReq">The HTTP req.</param>
2014-07-19 01:28:40 +00:00
/// <param name="url">The URL.</param>
2014-07-18 22:14:59 +00:00
/// <returns>Task.</returns>
2016-07-14 19:13:52 +00:00
protected async Task RequestHandler(IHttpRequest httpReq, Uri url)
2013-12-07 15:52:38 +00:00
{
2014-07-18 22:14:59 +00:00
var date = DateTime.Now;
var httpRes = httpReq.Response;
2016-11-08 18:44:23 +00:00
bool enableLog = false;
string urlToLog = null;
string remoteIp = null;
2014-07-09 00:46:11 +00:00
2016-11-08 18:44:23 +00:00
try
2016-04-22 16:12:20 +00:00
{
2016-11-08 18:44:23 +00:00
if (_disposed)
{
httpRes.StatusCode = 503;
2016-11-13 21:04:21 +00:00
httpRes.ContentType = "text/plain";
Write(httpRes, "Server shutting down");
2016-11-08 18:44:23 +00:00
return;
}
2016-04-22 16:12:20 +00:00
2016-11-08 18:44:23 +00:00
if (!ValidateHost(url))
{
httpRes.StatusCode = 400;
httpRes.ContentType = "text/plain";
2016-11-12 07:14:04 +00:00
Write(httpRes, "Invalid host");
2016-11-08 18:44:23 +00:00
return;
}
2016-11-08 18:44:23 +00:00
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/plain";
Write(httpRes, string.Empty);
2016-11-08 18:44:23 +00:00
return;
}
2016-11-08 18:44:23 +00:00
var operationName = httpReq.OperationName;
var localPath = url.LocalPath;
2016-09-01 16:36:11 +00:00
2016-11-08 18:44:23 +00:00
var urlString = url.OriginalString;
enableLog = EnableLogging(urlString, localPath);
urlToLog = urlString;
2016-09-01 16:36:11 +00:00
2016-11-08 18:44:23 +00:00
if (enableLog)
{
urlToLog = GetUrlToLog(urlString);
remoteIp = httpReq.RemoteIp;
2014-07-09 00:46:11 +00:00
2016-11-08 18:44:23 +00:00
LoggerUtils.LogRequest(_logger, urlToLog, httpReq.HttpMethod, httpReq.UserAgent);
}
2016-01-23 03:10:21 +00:00
2016-11-08 18:44:23 +00:00
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;
}
2016-03-18 03:40:15 +00:00
2016-11-08 18:44:23 +00:00
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);
2016-04-06 02:18:56 +00:00
2016-11-08 18:44:23 +00:00
if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
{
2016-11-12 07:14:04 +00:00
Write(httpRes,
2016-11-08 18:44:23 +00:00
"<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" +
newUrl + "\">" + newUrl + "</a></body></html>");
return;
}
}
2016-08-22 18:28:24 +00:00
2016-11-08 18:44:23 +00:00
if (localPath.IndexOf("dashboard/", StringComparison.OrdinalIgnoreCase) != -1 &&
localPath.IndexOf("web/dashboard", StringComparison.OrdinalIgnoreCase) == -1)
2016-08-22 18:28:24 +00:00
{
2016-11-08 18:44:23 +00:00
httpRes.StatusCode = 200;
httpRes.ContentType = "text/html";
var newUrl = urlString.Replace("mediabrowser", "emby", StringComparison.OrdinalIgnoreCase)
.Replace("/dashboard/", "/web/", StringComparison.OrdinalIgnoreCase);
2016-08-22 18:28:24 +00:00
2016-11-08 18:44:23 +00:00
if (!string.Equals(newUrl, urlString, StringComparison.OrdinalIgnoreCase))
{
2016-11-12 07:14:04 +00:00
Write(httpRes,
2016-11-08 18:44:23 +00:00
"<!doctype html><html><head><title>Emby</title></head><body>Please update your Emby bookmark to <a href=\"" +
newUrl + "\">" + newUrl + "</a></body></html>");
return;
}
2016-08-22 18:28:24 +00:00
}
2016-11-08 18:44:23 +00:00
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;
}
2016-03-18 03:40:15 +00:00
2016-11-08 18:44:23 +00:00
if (string.Equals(localPath, "/emby/pin", StringComparison.OrdinalIgnoreCase))
2016-03-25 17:48:18 +00:00
{
2016-11-08 18:44:23 +00:00
RedirectToUrl(httpRes, "web/pin.html");
return;
}
2016-03-18 03:40:15 +00:00
2016-11-08 18:44:23 +00:00
if (!string.IsNullOrWhiteSpace(GlobalResponse))
{
httpRes.StatusCode = 503;
httpRes.ContentType = "text/html";
2016-11-12 07:14:04 +00:00
Write(httpRes, GlobalResponse);
2016-07-14 19:13:52 +00:00
return;
2016-03-25 17:48:18 +00:00
}
2016-03-18 06:36:58 +00:00
2017-02-13 01:07:48 +00:00
var handler = GetServiceHandler(httpReq);
2014-07-09 00:46:11 +00:00
2016-11-08 18:44:23 +00:00
if (handler != null)
{
2017-02-13 01:07:48 +00:00
await handler.ProcessRequestAsync(this, httpReq, httpRes, Logger, operationName).ConfigureAwait(false);
2016-11-08 18:44:23 +00:00
}
2016-11-12 06:58:50 +00:00
else
{
2017-03-06 02:32:56 +00:00
ErrorHandler(new FileNotFoundException(), httpReq, false);
2016-11-12 06:58:50 +00:00
}
2016-02-21 06:25:25 +00:00
}
2016-12-26 17:38:12 +00:00
catch (OperationCanceledException ex)
{
ErrorHandler(ex, httpReq, false);
}
2016-11-08 18:44:23 +00:00
catch (Exception ex)
2015-09-13 23:07:54 +00:00
{
2016-11-08 18:44:23 +00:00
ErrorHandler(ex, httpReq);
2015-09-13 23:07:54 +00:00
}
2016-11-08 18:44:23 +00:00
finally
2013-12-07 15:52:38 +00:00
{
2016-11-08 18:44:23 +00:00
httpRes.Close();
2013-12-07 15:52:38 +00:00
2016-11-08 18:44:23 +00:00
if (enableLog)
2014-07-09 00:46:11 +00:00
{
2014-07-19 01:28:40 +00:00
var statusCode = httpRes.StatusCode;
2014-07-09 00:46:11 +00:00
var duration = DateTime.Now - date;
2016-11-08 18:44:23 +00:00
LoggerUtils.LogResponse(_logger, statusCode, urlToLog, remoteIp, duration);
2016-07-14 19:13:52 +00:00
}
2013-12-07 15:52:38 +00:00
}
}
2017-02-13 01:07:48 +00:00
// Entry point for HttpListener
public ServiceHandler GetServiceHandler(IHttpRequest httpReq)
{
var pathInfo = httpReq.PathInfo;
var pathParts = pathInfo.TrimStart('/').Split('/');
if (pathParts.Length == 0)
{
_logger.Error("Path parts empty for PathInfo: {0}, Url: {1}", pathInfo, httpReq.RawUrl);
return null;
}
2017-02-13 02:06:54 +00:00
2017-02-13 01:07:48 +00:00
string contentType;
var restPath = ServiceHandler.FindMatchingRestPath(httpReq.HttpMethod, pathInfo, _logger, out contentType);
if (restPath != null)
{
return new ServiceHandler
{
RestPath = restPath,
ResponseContentType = contentType
};
}
_logger.Error("Could not find handler for {0}", pathInfo);
return null;
}
2016-11-12 07:14:04 +00:00
private void Write(IResponse response, string text)
{
var bOutput = Encoding.UTF8.GetBytes(text);
response.SetContentLength(bOutput.Length);
var outputStream = response.OutputStream;
outputStream.Write(bOutput, 0, bOutput.Length);
}
2016-11-08 18:44:23 +00:00
public static void RedirectToUrl(IResponse httpRes, string url)
{
httpRes.StatusCode = 302;
2016-11-10 14:41:24 +00:00
httpRes.AddHeader("Location", url);
2016-11-08 18:44:23 +00:00
}
2017-02-13 01:07:48 +00:00
public ServiceController ServiceController { get; private set; }
2016-11-08 18:44:23 +00:00
2013-12-07 15:52:38 +00:00
/// <summary>
/// Adds the rest handlers.
/// </summary>
/// <param name="services">The services.</param>
2016-10-26 06:01:42 +00:00
public void Init(IEnumerable<IService> services)
2013-12-07 15:52:38 +00:00
{
_restServices.AddRange(services);
ServiceController = CreateServiceController();
_logger.Info("Calling ServiceStack AppHost.Init");
2013-12-09 02:24:48 +00:00
2017-02-13 01:07:48 +00:00
ServiceController.Init(this);
var requestFilters = _appHost.GetExports<IRequestFilter>().ToList();
foreach (var filter in requestFilters)
{
RequestFilters.Add(filter.Filter);
}
2017-02-13 02:06:54 +00:00
ResponseFilters.Add(new ResponseFilter(_logger).FilterResponse);
2013-12-07 15:52:38 +00:00
}
2017-02-13 02:06:54 +00:00
public RouteAttribute[] GetRouteAttributes(Type requestType)
2015-01-17 19:30:23 +00:00
{
2017-02-13 02:06:54 +00:00
var routes = requestType.GetTypeInfo().GetCustomAttributes<RouteAttribute>(true).ToList();
2015-01-17 19:30:23 +00:00
var clone = routes.ToList();
foreach (var route in clone)
{
2016-11-11 03:29:51 +00:00
routes.Add(new RouteAttribute(NormalizeEmbyRoutePath(route.Path), route.Verbs)
2015-04-11 21:34:05 +00:00
{
Notes = route.Notes,
Priority = route.Priority,
Summary = route.Summary
});
2016-03-18 03:40:15 +00:00
2016-11-11 03:29:51 +00:00
routes.Add(new RouteAttribute(NormalizeRoutePath(route.Path), route.Verbs)
2015-01-17 19:30:23 +00:00
{
Notes = route.Notes,
Priority = route.Priority,
Summary = route.Summary
});
2015-02-19 04:37:44 +00:00
2016-11-11 03:29:51 +00:00
routes.Add(new RouteAttribute(DoubleNormalizeEmbyRoutePath(route.Path), route.Verbs)
2015-04-11 21:34:05 +00:00
{
Notes = route.Notes,
Priority = route.Priority,
Summary = route.Summary
});
2015-01-17 19:30:23 +00:00
}
return routes.ToArray();
}
2017-02-13 02:06:54 +00:00
public Func<string, object> GetParseFn(Type propertyType)
2016-11-11 01:37:20 +00:00
{
2016-11-11 03:29:51 +00:00
return _funcParseFn(propertyType);
2016-11-11 01:37:20 +00:00
}
2017-02-13 02:06:54 +00:00
public void SerializeToJson(object o, Stream stream)
2016-11-10 14:41:24 +00:00
{
_jsonSerializer.SerializeToStream(o, stream);
}
2017-02-13 02:06:54 +00:00
public void SerializeToXml(object o, Stream stream)
2016-11-10 14:41:24 +00:00
{
_xmlSerializer.SerializeToStream(o, stream);
}
2017-02-13 02:06:54 +00:00
public object DeserializeXml(Type type, Stream stream)
2016-11-10 14:41:24 +00:00
{
return _xmlSerializer.DeserializeFromStream(type, stream);
}
2017-02-13 02:06:54 +00:00
public object DeserializeJson(Type type, Stream stream)
2016-11-10 14:41:24 +00:00
{
return _jsonSerializer.DeserializeFromStream(stream, type);
}
2015-04-11 21:34:05 +00:00
private string NormalizeEmbyRoutePath(string path)
{
if (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
return "/emby" + path;
}
return "emby/" + path;
}
private string DoubleNormalizeEmbyRoutePath(string path)
{
if (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
return "/emby/emby" + path;
}
return "emby/emby/" + path;
}
2015-01-17 19:30:23 +00:00
private string NormalizeRoutePath(string path)
{
if (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
return "/mediabrowser" + path;
}
return "mediabrowser/" + path;
}
2014-07-09 00:46:11 +00:00
2013-12-07 15:52:38 +00:00
private bool _disposed;
private readonly object _disposeLock = new object();
protected virtual void Dispose(bool disposing)
{
if (_disposed) return;
2016-12-28 06:08:18 +00:00
2013-12-07 15:52:38 +00:00
lock (_disposeLock)
{
if (_disposed) return;
2016-12-28 06:08:18 +00:00
_disposed = true;
2013-12-07 15:52:38 +00:00
if (disposing)
{
Stop();
}
}
}
2017-02-13 02:06:54 +00:00
public void Dispose()
2013-12-07 15:52:38 +00:00
{
Dispose(true);
GC.SuppressFinalize(this);
}
2016-11-11 03:29:51 +00:00
public void StartServer(IEnumerable<string> urlPrefixes)
2013-12-07 15:52:38 +00:00
{
2014-01-09 04:44:51 +00:00
UrlPrefixes = urlPrefixes.ToList();
2017-02-13 01:07:48 +00:00
StartListener();
2013-12-07 15:52:38 +00:00
}
}
}