jellyfin-server/MediaBrowser.Server.Implementations/EntryPoints/ExternalPortForwarding.cs

255 lines
8.5 KiB
C#
Raw Normal View History

2015-04-19 15:54:20 +00:00
using MediaBrowser.Controller;
2014-02-26 04:38:21 +00:00
using MediaBrowser.Controller.Configuration;
2015-04-29 18:48:34 +00:00
using MediaBrowser.Controller.Dlna;
2014-02-26 04:38:21 +00:00
using MediaBrowser.Controller.Plugins;
using MediaBrowser.Model.Logging;
using Mono.Nat;
using System;
2014-08-21 15:55:35 +00:00
using System.Collections.Generic;
2015-01-19 04:29:57 +00:00
using System.Globalization;
2014-02-26 04:38:21 +00:00
using System.IO;
2015-04-29 18:48:34 +00:00
using System.Net;
2014-02-26 04:38:21 +00:00
using System.Text;
2014-08-21 15:55:35 +00:00
using System.Threading;
2014-02-26 04:38:21 +00:00
namespace MediaBrowser.Server.Implementations.EntryPoints
{
public class ExternalPortForwarding : IServerEntryPoint
{
private readonly IServerApplicationHost _appHost;
private readonly ILogger _logger;
private readonly IServerConfigurationManager _config;
2015-04-29 18:48:34 +00:00
private readonly ISsdpHandler _ssdp;
2014-02-26 04:38:21 +00:00
2014-08-21 15:55:35 +00:00
private Timer _timer;
2015-01-19 04:29:57 +00:00
private bool _isStarted;
2014-08-21 15:55:35 +00:00
2015-04-29 18:48:34 +00:00
public ExternalPortForwarding(ILogManager logmanager, IServerApplicationHost appHost, IServerConfigurationManager config, ISsdpHandler ssdp)
2014-02-26 04:38:21 +00:00
{
2014-05-02 02:54:33 +00:00
_logger = logmanager.GetLogger("PortMapper");
2014-02-26 04:38:21 +00:00
_appHost = appHost;
_config = config;
2015-04-29 18:48:34 +00:00
_ssdp = ssdp;
2015-01-19 04:29:57 +00:00
}
2014-02-26 04:38:21 +00:00
2015-01-19 04:29:57 +00:00
private string _lastConfigIdentifier;
private string GetConfigIdentifier()
{
var values = new List<string>();
var config = _config.Configuration;
values.Add(config.EnableUPnP.ToString());
values.Add(config.PublicPort.ToString(CultureInfo.InvariantCulture));
values.Add(_appHost.HttpPort.ToString(CultureInfo.InvariantCulture));
values.Add(_appHost.HttpsPort.ToString(CultureInfo.InvariantCulture));
values.Add(config.EnableHttps.ToString());
values.Add(_appHost.EnableHttps.ToString());
return string.Join("|", values.ToArray());
2014-02-26 04:38:21 +00:00
}
void _config_ConfigurationUpdated(object sender, EventArgs e)
{
2015-01-19 04:29:57 +00:00
_config.ConfigurationUpdated -= _config_ConfigurationUpdated;
2015-04-13 16:21:10 +00:00
2015-01-19 04:29:57 +00:00
if (!string.Equals(_lastConfigIdentifier, GetConfigIdentifier(), StringComparison.OrdinalIgnoreCase))
2014-02-26 04:38:21 +00:00
{
2015-01-19 04:29:57 +00:00
if (_isStarted)
{
DisposeNat();
}
Run();
2014-02-26 04:38:21 +00:00
}
}
public void Run()
{
2014-03-01 22:34:27 +00:00
//NatUtility.Logger = new LogWriter(_logger);
2014-08-21 15:55:35 +00:00
2015-01-19 04:29:57 +00:00
if (_config.Configuration.EnableUPnP)
{
Start();
}
_config.ConfigurationUpdated -= _config_ConfigurationUpdated;
_config.ConfigurationUpdated += _config_ConfigurationUpdated;
2014-02-26 04:38:21 +00:00
}
2015-01-19 04:29:57 +00:00
private void Start()
2014-02-26 04:38:21 +00:00
{
2015-01-19 04:29:57 +00:00
_logger.Debug("Starting NAT discovery");
2015-04-29 18:48:34 +00:00
NatUtility.EnabledProtocols = new List<NatProtocol>
{
NatProtocol.Pmp
};
2015-01-19 04:29:57 +00:00
NatUtility.DeviceFound += NatUtility_DeviceFound;
2014-08-21 15:55:35 +00:00
2015-01-19 04:29:57 +00:00
// Mono.Nat does never rise this event. The event is there however it is useless.
// You could remove it with no risk.
NatUtility.DeviceLost += NatUtility_DeviceLost;
2014-08-21 15:55:35 +00:00
2015-01-19 04:29:57 +00:00
// it is hard to say what one should do when an unhandled exception is raised
// because there isn't anything one can do about it. Probably save a log or ignored it.
NatUtility.UnhandledException += NatUtility_UnhandledException;
NatUtility.StartDiscovery();
2014-02-26 04:38:21 +00:00
_timer = new Timer(s => _createdRules = new List<string>(), null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
2014-08-21 15:55:35 +00:00
2015-04-29 18:48:34 +00:00
_ssdp.MessageReceived += _ssdp_MessageReceived;
2015-01-19 04:29:57 +00:00
_lastConfigIdentifier = GetConfigIdentifier();
_isStarted = true;
2014-02-26 04:38:21 +00:00
}
2015-04-29 18:48:34 +00:00
void _ssdp_MessageReceived(object sender, SsdpMessageEventArgs e)
{
var endpoint = e.EndPoint as IPEndPoint;
if (endpoint != null && e.LocalIp != null)
{
NatUtility.Handle(e.LocalIp, e.Message, endpoint, NatProtocol.Upnp);
}
}
2014-02-26 04:38:21 +00:00
void NatUtility_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
var ex = e.ExceptionObject as Exception;
if (ex == null)
{
//_logger.Error("Unidentified error reported by Mono.Nat");
}
else
{
// Seeing some blank exceptions coming through here
2015-04-26 03:25:07 +00:00
//_logger.ErrorException("Error reported by Mono.Nat: ", ex);
}
2014-02-26 04:38:21 +00:00
}
void NatUtility_DeviceFound(object sender, DeviceEventArgs e)
{
try
{
var device = e.Device;
_logger.Debug("NAT device found: {0}", device.LocalAddress.ToString());
CreateRules(device);
}
2015-04-13 16:21:10 +00:00
catch (Exception ex)
2014-02-26 04:38:21 +00:00
{
// I think it could be a good idea to log the exception because
// you are using permanent portmapping here (never expire) and that means that next time
// CreatePortMap is invoked it can fails with a 718-ConflictInMappingEntry or not. That depends
// on the router's upnp implementation (specs says it should fail however some routers don't do it)
// It also can fail with others like 727-ExternalPortOnlySupportsWildcard, 728-NoPortMapsAvailable
// and those errors (upnp errors) could be useful for diagnosting.
2014-08-21 15:55:35 +00:00
2015-04-13 16:21:10 +00:00
_logger.ErrorException("Error creating port forwarding rules", ex);
2014-02-26 04:38:21 +00:00
}
}
2014-08-21 15:55:35 +00:00
private List<string> _createdRules = new List<string>();
2014-02-26 04:38:21 +00:00
private void CreateRules(INatDevice device)
{
2014-08-21 15:55:35 +00:00
// On some systems the device discovered event seems to fire repeatedly
// This check will help ensure we're not trying to port map the same device over and over
var address = device.LocalAddress.ToString();
if (!_createdRules.Contains(address))
{
_createdRules.Add(address);
2015-04-19 15:54:20 +00:00
CreatePortMap(device, _appHost.HttpPort, _config.Configuration.PublicPort);
CreatePortMap(device, _appHost.HttpsPort, _config.Configuration.PublicHttpsPort);
2014-08-21 15:55:35 +00:00
}
2014-02-26 04:38:21 +00:00
}
2015-04-19 15:54:20 +00:00
private void CreatePortMap(INatDevice device, int privatePort, int publicPort)
2014-02-26 04:38:21 +00:00
{
2015-04-19 15:54:20 +00:00
_logger.Debug("Creating port map on port {0}", privatePort);
device.CreatePortMap(new Mapping(Protocol.Tcp, privatePort, publicPort)
2014-02-26 04:38:21 +00:00
{
2015-04-19 15:54:20 +00:00
Description = _appHost.Name
});
2014-02-26 04:38:21 +00:00
}
// As I said before, this method will be never invoked. You can remove it.
void NatUtility_DeviceLost(object sender, DeviceEventArgs e)
{
var device = e.Device;
_logger.Debug("NAT device lost: {0}", device.LocalAddress.ToString());
}
2014-02-26 04:38:21 +00:00
public void Dispose()
{
DisposeNat();
}
private void DisposeNat()
{
_logger.Debug("Stopping NAT discovery");
2014-08-21 15:55:35 +00:00
if (_timer != null)
{
_timer.Dispose();
_timer = null;
}
2015-04-29 18:48:34 +00:00
_ssdp.MessageReceived -= _ssdp_MessageReceived;
2014-02-26 04:38:21 +00:00
try
{
// This is not a significant improvement
NatUtility.StopDiscovery();
2014-02-26 04:38:21 +00:00
NatUtility.DeviceFound -= NatUtility_DeviceFound;
NatUtility.DeviceLost -= NatUtility_DeviceLost;
2014-02-26 04:38:21 +00:00
NatUtility.UnhandledException -= NatUtility_UnhandledException;
}
// Statements in try-block will no fail because StopDiscovery is a one-line
// method that was no chances to fail.
// public static void StopDiscovery ()
2014-08-21 15:55:35 +00:00
// {
// searching.Reset();
2014-08-21 15:55:35 +00:00
// }
// IMO you could remove the catch-block
2014-02-26 04:38:21 +00:00
catch (Exception ex)
{
_logger.ErrorException("Error stopping NAT Discovery", ex);
}
finally
{
_isStarted = false;
}
}
private class LogWriter : TextWriter
{
private readonly ILogger _logger;
public LogWriter(ILogger logger)
{
_logger = logger;
}
public override Encoding Encoding
{
get { return Encoding.UTF8; }
}
public override void WriteLine(string format, params object[] arg)
{
_logger.Debug(format, arg);
}
public override void WriteLine(string value)
{
_logger.Debug(value);
}
}
}
}