ExternalPortForwarding.cs 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230
  1. #pragma warning disable CS1591
  2. #pragma warning disable SA1600
  3. using System;
  4. using System.Collections.Generic;
  5. using System.Net;
  6. using System.Text;
  7. using System.Threading;
  8. using System.Threading.Tasks;
  9. using MediaBrowser.Controller;
  10. using MediaBrowser.Controller.Configuration;
  11. using MediaBrowser.Controller.Plugins;
  12. using MediaBrowser.Model.Dlna;
  13. using MediaBrowser.Model.Events;
  14. using Microsoft.Extensions.Logging;
  15. using Mono.Nat;
  16. namespace Emby.Server.Implementations.EntryPoints
  17. {
  18. /// <summary>
  19. /// Server entrypoint handling external port forwarding.
  20. /// </summary>
  21. public class ExternalPortForwarding : IServerEntryPoint
  22. {
  23. private readonly IServerApplicationHost _appHost;
  24. private readonly ILogger _logger;
  25. private readonly IServerConfigurationManager _config;
  26. private readonly IDeviceDiscovery _deviceDiscovery;
  27. private readonly object _createdRulesLock = new object();
  28. private List<IPEndPoint> _createdRules = new List<IPEndPoint>();
  29. private Timer _timer;
  30. private string _lastConfigIdentifier;
  31. private bool _disposed = false;
  32. /// <summary>
  33. /// Initializes a new instance of the <see cref="ExternalPortForwarding"/> class.
  34. /// </summary>
  35. /// <param name="logger">The logger.</param>
  36. /// <param name="appHost">The application host.</param>
  37. /// <param name="config">The configuration manager.</param>
  38. /// <param name="deviceDiscovery">The device discovery.</param>
  39. public ExternalPortForwarding(
  40. ILogger<ExternalPortForwarding> logger,
  41. IServerApplicationHost appHost,
  42. IServerConfigurationManager config,
  43. IDeviceDiscovery deviceDiscovery)
  44. {
  45. _logger = logger;
  46. _appHost = appHost;
  47. _config = config;
  48. _deviceDiscovery = deviceDiscovery;
  49. }
  50. private string GetConfigIdentifier()
  51. {
  52. const char Separator = '|';
  53. var config = _config.Configuration;
  54. return new StringBuilder(32)
  55. .Append(config.EnableUPnP).Append(Separator)
  56. .Append(config.PublicPort).Append(Separator)
  57. .Append(_appHost.HttpPort).Append(Separator)
  58. .Append(_appHost.HttpsPort).Append(Separator)
  59. .Append(_appHost.EnableHttps).Append(Separator)
  60. .Append(config.EnableRemoteAccess).Append(Separator)
  61. .ToString();
  62. }
  63. private void OnConfigurationUpdated(object sender, EventArgs e)
  64. {
  65. if (!string.Equals(_lastConfigIdentifier, GetConfigIdentifier(), StringComparison.OrdinalIgnoreCase))
  66. {
  67. Stop();
  68. Start();
  69. }
  70. }
  71. /// <inheritdoc />
  72. public Task RunAsync()
  73. {
  74. Start();
  75. _config.ConfigurationUpdated += OnConfigurationUpdated;
  76. return Task.CompletedTask;
  77. }
  78. private void Start()
  79. {
  80. if (!_config.Configuration.EnableUPnP || !_config.Configuration.EnableRemoteAccess)
  81. {
  82. return;
  83. }
  84. _logger.LogDebug("Starting NAT discovery");
  85. NatUtility.DeviceFound += OnNatUtilityDeviceFound;
  86. NatUtility.StartDiscovery();
  87. _timer = new Timer(ClearCreatedRules, null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
  88. _deviceDiscovery.DeviceDiscovered += OnDeviceDiscoveryDeviceDiscovered;
  89. _lastConfigIdentifier = GetConfigIdentifier();
  90. }
  91. private void Stop()
  92. {
  93. _logger.LogDebug("Stopping NAT discovery");
  94. NatUtility.StopDiscovery();
  95. NatUtility.DeviceFound -= OnNatUtilityDeviceFound;
  96. _timer?.Dispose();
  97. _deviceDiscovery.DeviceDiscovered -= OnDeviceDiscoveryDeviceDiscovered;
  98. }
  99. private void ClearCreatedRules(object state)
  100. {
  101. lock (_createdRulesLock)
  102. {
  103. _createdRules.Clear();
  104. }
  105. }
  106. private void OnDeviceDiscoveryDeviceDiscovered(object sender, GenericEventArgs<UpnpDeviceInfo> e)
  107. {
  108. NatUtility.Search(e.Argument.LocalIpAddress, NatProtocol.Upnp);
  109. }
  110. private void OnNatUtilityDeviceFound(object sender, DeviceEventArgs e)
  111. {
  112. try
  113. {
  114. var device = e.Device;
  115. CreateRules(device);
  116. }
  117. catch (Exception ex)
  118. {
  119. _logger.LogError(ex, "Error creating port forwarding rules");
  120. }
  121. }
  122. private async void CreateRules(INatDevice device)
  123. {
  124. if (_disposed)
  125. {
  126. throw new ObjectDisposedException(GetType().Name);
  127. }
  128. // On some systems the device discovered event seems to fire repeatedly
  129. // This check will help ensure we're not trying to port map the same device over and over
  130. var address = device.DeviceEndpoint;
  131. lock (_createdRulesLock)
  132. {
  133. if (!_createdRules.Contains(address))
  134. {
  135. _createdRules.Add(address);
  136. }
  137. else
  138. {
  139. return;
  140. }
  141. }
  142. try
  143. {
  144. await CreatePortMap(device, _appHost.HttpPort, _config.Configuration.PublicPort).ConfigureAwait(false);
  145. }
  146. catch (Exception ex)
  147. {
  148. _logger.LogError(ex, "Error creating http port map");
  149. return;
  150. }
  151. try
  152. {
  153. await CreatePortMap(device, _appHost.HttpsPort, _config.Configuration.PublicHttpsPort).ConfigureAwait(false);
  154. }
  155. catch (Exception ex)
  156. {
  157. _logger.LogError(ex, "Error creating https port map");
  158. }
  159. }
  160. private Task<Mapping> CreatePortMap(INatDevice device, int privatePort, int publicPort)
  161. {
  162. _logger.LogDebug(
  163. "Creating port map on local port {0} to public port {1} with device {2}",
  164. privatePort,
  165. publicPort,
  166. device.DeviceEndpoint);
  167. return device.CreatePortMapAsync(
  168. new Mapping(Protocol.Tcp, privatePort, publicPort, 0, _appHost.Name));
  169. }
  170. /// <inheritdoc />
  171. public void Dispose()
  172. {
  173. Dispose(true);
  174. GC.SuppressFinalize(this);
  175. }
  176. /// <summary>
  177. /// Releases unmanaged and - optionally - managed resources.
  178. /// </summary>
  179. /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
  180. protected virtual void Dispose(bool dispose)
  181. {
  182. if (_disposed)
  183. {
  184. return;
  185. }
  186. _config.ConfigurationUpdated -= OnConfigurationUpdated;
  187. Stop();
  188. _timer = null;
  189. _disposed = true;
  190. }
  191. }
  192. }