Rename additional values in NetworkConfiguration and add migration for all changed values

Emby.Server.Implementations/ApplicationHost.cs

@@ -475,8 +475,8 @@ namespace Emby.Server.Implementations
             }
 
             var networkConfiguration = ConfigurationManager.GetNetworkConfiguration();
-            HttpPort = networkConfiguration.HttpServerPortNumber;
-            HttpsPort = networkConfiguration.HttpsPortNumber;
+            HttpPort = networkConfiguration.ServerPortNumberHttp;
+            HttpsPort = networkConfiguration.ServerPortNumberHttps;
 
             // Safeguard against invalid configuration
             if (HttpPort == HttpsPort)
@@ -785,8 +785,8 @@ namespace Emby.Server.Implementations
             if (HttpPort != 0 && HttpsPort != 0)
             {
                 // Need to restart if ports have changed
-                if (networkConfiguration.HttpServerPortNumber != HttpPort
-                    || networkConfiguration.HttpsPortNumber != HttpsPort)
+                if (networkConfiguration.ServerPortNumberHttp != HttpPort
+                    || networkConfiguration.ServerPortNumberHttps != HttpsPort)
                 {
                     if (ConfigurationManager.Configuration.IsPortAuthorized)
                     {

Emby.Server.Implementations/EntryPoints/ExternalPortForwarding.cs

@@ -57,8 +57,8 @@ namespace Emby.Server.Implementations.EntryPoints
 
             return new StringBuilder(32)
                 .Append(config.EnableUPnP).Append(Separator)
-                .Append(config.PublicPort).Append(Separator)
-                .Append(config.PublicHttpsPort).Append(Separator)
+                .Append(config.PublicPortHttp).Append(Separator)
+                .Append(config.PublicPortHttps).Append(Separator)
                 .Append(_appHost.HttpPort).Append(Separator)
                 .Append(_appHost.HttpsPort).Append(Separator)
                 .Append(_appHost.ListenWithHttps).Append(Separator)
@@ -146,11 +146,11 @@ namespace Emby.Server.Implementations.EntryPoints
         private IEnumerable<Task> CreatePortMaps(INatDevice device)
         {
             var config = _config.GetNetworkConfiguration();
-            yield return CreatePortMap(device, _appHost.HttpPort, config.PublicPort);
+            yield return CreatePortMap(device, _appHost.HttpPort, config.PublicPortHttp);
 
             if (_appHost.ListenWithHttps)
             {
-                yield return CreatePortMap(device, _appHost.HttpsPort, config.PublicHttpsPort);
+                yield return CreatePortMap(device, _appHost.HttpsPort, config.PublicPortHttps);
             }
         }
 

Jellyfin.Networking/Configuration/NetworkConfiguration.cs

@@ -10,12 +10,12 @@ namespace Jellyfin.Networking.Configuration
     public class NetworkConfiguration
     {
         /// <summary>
-        /// The default value for <see cref="HttpServerPortNumber"/>.
+        /// The default value for <see cref="ServerPortNumberHttp"/>.
         /// </summary>
         public const int DefaultHttpPort = 8096;
 
         /// <summary>
-        /// The default value for <see cref="PublicHttpsPort"/> and <see cref="HttpsPortNumber"/>.
+        /// The default value for <see cref="PublicPortHttps"/> and <see cref="ServerPortNumberHttps"/>.
         /// </summary>
         public const int DefaultHttpsPort = 8920;
 
@@ -79,28 +79,28 @@ namespace Jellyfin.Networking.Configuration
         public string CertificatePassword { get; set; } = string.Empty;
 
         /// <summary>
-        /// Gets or sets the HTTPS server port number.
+        /// Gets or sets the HTTP server port number.
         /// </summary>
-        /// <value>The HTTPS server port number.</value>
-        public int HttpsPortNumber { get; set; } = DefaultHttpsPort;
+        /// <value>The HTTP server port number.</value>
+        public int ServerPortNumberHttp { get; set; } = DefaultHttpPort;
 
         /// <summary>
-        /// Gets or sets the public HTTPS port.
+        /// Gets or sets the HTTPS server port number.
         /// </summary>
-        /// <value>The public HTTPS port.</value>
-        public int PublicHttpsPort { get; set; } = DefaultHttpsPort;
+        /// <value>The HTTPS server port number.</value>
+        public int ServerPortNumberHttps { get; set; } = DefaultHttpsPort;
 
         /// <summary>
-        /// Gets or sets the HTTP server port number.
+        /// Gets or sets the public mapped port.
         /// </summary>
-        /// <value>The HTTP server port number.</value>
-        public int HttpServerPortNumber { get; set; } = DefaultHttpPort;
+        /// <value>The public mapped port.</value>
+        public int PublicPortHttp { get; set; } = DefaultHttpPort;
 
         /// <summary>
-        /// Gets or sets the public mapped port.
+        /// Gets or sets the public HTTPS port.
         /// </summary>
-        /// <value>The public mapped port.</value>
-        public int PublicPort { get; set; } = DefaultHttpPort;
+        /// <value>The public HTTPS port.</value>
+        public int PublicPortHttps { get; set; } = DefaultHttpsPort;
 
         /// <summary>
         /// Gets or sets a value indicating whether Autodiscovery is enabled.
@@ -113,17 +113,17 @@ namespace Jellyfin.Networking.Configuration
         public bool EnableUPnP { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether IPv6 is enabled or not.
+        /// Gets or sets a value indicating whether IPv6 is enabled.
         /// </summary>
         public bool EnableIPv4 { get; set; } = true;
 
         /// <summary>
-        /// Gets or sets a value indicating whether IPv6 is enabled or not.
+        /// Gets or sets a value indicating whether IPv6 is enabled.
         /// </summary>
         public bool EnableIPv6 { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether access outside of the LAN is permitted.
+        /// Gets or sets a value indicating whether access from outside of the LAN is permitted.
         /// </summary>
         public bool EnableRemoteAccess { get; set; } = true;
 
@@ -138,12 +138,12 @@ namespace Jellyfin.Networking.Configuration
         public string[] LocalNetworkAddresses { get; set; } = Array.Empty<string>();
 
         /// <summary>
-        /// Gets or sets the known proxies. If the proxy is a network, it's added to the KnownNetworks.
+        /// Gets or sets the known proxies.
         /// </summary>
         public string[] KnownProxies { get; set; } = Array.Empty<string>();
 
         /// <summary>
-        /// Gets or sets a value indicating whether address names that match <see cref="VirtualInterfaceNames"/> should be Ignore for the purposes of binding.
+        /// Gets or sets a value indicating whether address names that match <see cref="VirtualInterfaceNames"/> should be ignored for the purposes of binding.
         /// </summary>
         public bool IgnoreVirtualInterfaces { get; set; } = true;
 

Jellyfin.Server/Migrations/MigrationRunner.cs

@@ -22,7 +22,8 @@ namespace Jellyfin.Server.Migrations
         private static readonly Type[] _preStartupMigrationTypes =
         {
             typeof(PreStartupRoutines.CreateNetworkConfiguration),
-            typeof(PreStartupRoutines.MigrateMusicBrainzTimeout)
+            typeof(PreStartupRoutines.MigrateMusicBrainzTimeout),
+            typeof(PreStartupRoutines.MigrateNetworkConfiguration)
         };
 
         /// <summary>

Jellyfin.Server/Migrations/PreStartupRoutines/MigrateNetworkConfiguration.cs

@@ -0,0 +1,195 @@
+using System;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+using Emby.Server.Implementations;
+using Jellyfin.Networking.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Server.Migrations.PreStartupRoutines;
+
+/// <inheritdoc />
+public class MigrateNetworkConfiguration : IMigrationRoutine
+{
+    private readonly ServerApplicationPaths _applicationPaths;
+    private readonly ILogger<MigrateNetworkConfiguration> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MigrateNetworkConfiguration"/> class.
+    /// </summary>
+    /// <param name="applicationPaths">An instance of <see cref="ServerApplicationPaths"/>.</param>
+    /// <param name="loggerFactory">An instance of the <see cref="ILoggerFactory"/> interface.</param>
+    public MigrateNetworkConfiguration(ServerApplicationPaths applicationPaths, ILoggerFactory loggerFactory)
+    {
+        _applicationPaths = applicationPaths;
+        _logger = loggerFactory.CreateLogger<MigrateNetworkConfiguration>();
+    }
+
+    /// <inheritdoc />
+    public Guid Id => Guid.Parse("4FB5C950-1991-11EE-9B4B-0800200C9A66");
+
+    /// <inheritdoc />
+    public string Name => nameof(MigrateNetworkConfiguration);
+
+    /// <inheritdoc />
+    public bool PerformOnNewInstall => false;
+
+    /// <inheritdoc />
+    public void Perform()
+    {
+        string path = Path.Combine(_applicationPaths.ConfigurationDirectoryPath, "network.xml");
+        var oldNetworkConfigSerializer = new XmlSerializer(typeof(OldNetworkConfiguration), new XmlRootAttribute("NetworkConfiguration"));
+        using var xmlReader = XmlReader.Create(path);
+        var oldNetworkConfiguration = (OldNetworkConfiguration?)oldNetworkConfigSerializer.Deserialize(xmlReader);
+
+        if (oldNetworkConfiguration is not null)
+        {
+            // Migrate network config values to new config schema
+            var networkConfiguration = new NetworkConfiguration();
+            networkConfiguration.AutoDiscovery = oldNetworkConfiguration.AutoDiscovery;
+            networkConfiguration.BaseUrl = oldNetworkConfiguration.BaseUrl;
+            networkConfiguration.CertificatePassword = oldNetworkConfiguration.CertificatePassword;
+            networkConfiguration.CertificatePath = oldNetworkConfiguration.CertificatePath;
+            networkConfiguration.EnableHttps = oldNetworkConfiguration.EnableHttps;
+            networkConfiguration.EnableIPv4 = oldNetworkConfiguration.EnableIPV4;
+            networkConfiguration.EnableIPv6 = oldNetworkConfiguration.EnableIPV6;
+            networkConfiguration.EnablePublishedServerUriByRequest = oldNetworkConfiguration.EnablePublishedServerUriByRequest;
+            networkConfiguration.EnableRemoteAccess = oldNetworkConfiguration.EnableRemoteAccess;
+            networkConfiguration.EnableUPnP = oldNetworkConfiguration.EnableUPnP;
+            networkConfiguration.IgnoreVirtualInterfaces = oldNetworkConfiguration.IgnoreVirtualInterfaces;
+            networkConfiguration.IsRemoteIPFilterBlacklist = oldNetworkConfiguration.IsRemoteIPFilterBlacklist;
+            networkConfiguration.KnownProxies = oldNetworkConfiguration.KnownProxies;
+            networkConfiguration.LocalNetworkAddresses = oldNetworkConfiguration.LocalNetworkAddresses;
+            networkConfiguration.LocalNetworkSubnets = oldNetworkConfiguration.LocalNetworkSubnets;
+            networkConfiguration.PublicPortHttp = oldNetworkConfiguration.PublicPort;
+            networkConfiguration.PublicPortHttps = oldNetworkConfiguration.PublicHttpsPort;
+            networkConfiguration.PublishedServerUriBySubnet = oldNetworkConfiguration.PublishedServerUriBySubnet;
+            networkConfiguration.RemoteIPFilter = oldNetworkConfiguration.RemoteIPFilter;
+            networkConfiguration.RequireHttps = oldNetworkConfiguration.RequireHttps;
+            networkConfiguration.ServerPortNumberHttp = oldNetworkConfiguration.HttpServerPortNumber;
+            networkConfiguration.ServerPortNumberHttps = oldNetworkConfiguration.HttpsPortNumber;
+
+            // Migrate old virtual interface name schema
+            var oldVirtualInterfaceNames = oldNetworkConfiguration.VirtualInterfaceNames;
+            if (oldVirtualInterfaceNames.Equals("vEthernet*", StringComparison.OrdinalIgnoreCase))
+            {
+                networkConfiguration.VirtualInterfaceNames = new string[] { "veth" };
+            }
+            else
+            {
+                networkConfiguration.VirtualInterfaceNames = oldVirtualInterfaceNames.Replace("*", string.Empty, StringComparison.OrdinalIgnoreCase).Split(',');
+            }
+
+            var networkConfigSerializer = new XmlSerializer(typeof(NetworkConfiguration));
+            var xmlWriterSettings = new XmlWriterSettings { Indent = true };
+            using var xmlWriter = XmlWriter.Create(path, xmlWriterSettings);
+            networkConfigSerializer.Serialize(xmlWriter, networkConfiguration);
+        }
+    }
+
+#pragma warning disable
+    public sealed class OldNetworkConfiguration
+    {
+        public const int DefaultHttpPort = 8096;
+
+        public const int DefaultHttpsPort = 8920;
+
+        private string _baseUrl = string.Empty;
+
+        public bool RequireHttps { get; set; }
+
+        public string CertificatePath { get; set; } = string.Empty;
+
+        public string CertificatePassword { get; set; } = string.Empty;
+
+        public string BaseUrl
+        {
+            get => _baseUrl;
+            set
+            {
+                // Normalize the start of the string
+                if (string.IsNullOrWhiteSpace(value))
+                {
+                    // If baseUrl is empty, set an empty prefix string
+                    _baseUrl = string.Empty;
+                    return;
+                }
+
+                if (value[0] != '/')
+                {
+                    // If baseUrl was not configured with a leading slash, append one for consistency
+                    value = "/" + value;
+                }
+
+                // Normalize the end of the string
+                if (value[^1] == '/')
+                {
+                    // If baseUrl was configured with a trailing slash, remove it for consistency
+                    value = value.Remove(value.Length - 1);
+                }
+
+                _baseUrl = value;
+            }
+        }
+
+        public int PublicHttpsPort { get; set; } = DefaultHttpsPort;
+
+        public int HttpServerPortNumber { get; set; } = DefaultHttpPort;
+
+        public int HttpsPortNumber { get; set; } = DefaultHttpsPort;
+
+        public bool EnableHttps { get; set; }
+
+        public int PublicPort { get; set; } = DefaultHttpPort;
+
+        public bool UPnPCreateHttpPortMap { get; set; }
+
+        public string UDPPortRange { get; set; } = string.Empty;
+
+        public bool EnableIPV6 { get; set; }
+
+        public bool EnableIPV4 { get; set; } = true;
+
+        public bool EnableSSDPTracing { get; set; }
+
+        public string SSDPTracingFilter { get; set; } = string.Empty;
+
+        public int UDPSendCount { get; set; } = 2;
+
+        public int UDPSendDelay { get; set; } = 100;
+
+        public bool IgnoreVirtualInterfaces { get; set; } = true;
+
+        public string VirtualInterfaceNames { get; set; } = "vEthernet*";
+
+        public int GatewayMonitorPeriod { get; set; } = 60;
+
+        public bool EnableMultiSocketBinding { get; } = true;
+
+        public bool TrustAllIP6Interfaces { get; set; }
+
+        public string HDHomerunPortRange { get; set; } = string.Empty;
+
+        public string[] PublishedServerUriBySubnet { get; set; } = Array.Empty<string>();
+
+        public bool AutoDiscoveryTracing { get; set; }
+
+        public bool AutoDiscovery { get; set; } = true;
+
+        public string[] RemoteIPFilter { get; set; } = Array.Empty<string>();
+
+        public bool IsRemoteIPFilterBlacklist { get; set; }
+
+        public bool EnableUPnP { get; set; }
+
+        public bool EnableRemoteAccess { get; set; } = true;
+
+        public string[] LocalNetworkSubnets { get; set; } = Array.Empty<string>();
+
+        public string[] LocalNetworkAddresses { get; set; } = Array.Empty<string>();
+        public string[] KnownProxies { get; set; } = Array.Empty<string>();
+
+        public bool EnablePublishedServerUriByRequest { get; set; } = false;
+    }
+#pragma warning restore
+}