Wrap application in baseurl

Jellyfin.Server/Middleware/BaseUrlRedirectionMiddleware.cs

@@ -44,11 +44,7 @@ namespace Jellyfin.Server.Middleware
             var localPath = httpContext.Request.Path.ToString();
             var baseUrlPrefix = serverConfigurationManager.Configuration.BaseUrl;
 
-            if (string.Equals(localPath, baseUrlPrefix + "/", StringComparison.OrdinalIgnoreCase)
+            if (!localPath.StartsWith(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 an URL at {LocalPath}", localPath);

Jellyfin.Server/Startup.cs

@@ -88,71 +88,78 @@ namespace Jellyfin.Server
         /// </summary>
         /// <param name="app">The application builder.</param>
         /// <param name="env">The webhost environment.</param>
-        /// <param name="serverApplicationHost">The server application host.</param>
         /// <param name="appConfig">The application config.</param>
         public void Configure(
             IApplicationBuilder app,
             IWebHostEnvironment env,
-            IServerApplicationHost serverApplicationHost,
             IConfiguration appConfig)
+        {
+            // Only add base url redirection if a base url is set.
+            if (!string.IsNullOrEmpty(_serverConfigurationManager.Configuration.BaseUrl))
+            {
+                app.UseBaseUrlRedirection();
+            }
+
+            // Wrap rest of configuration so everything only listens on BaseUrl.
+            app.Map(_serverConfigurationManager.Configuration.BaseUrl, mainApp =>
             {
                 if (env.IsDevelopment())
                 {
-                app.UseDeveloperExceptionPage();
+                    mainApp.UseDeveloperExceptionPage();
                 }
 
-            app.UseMiddleware<ExceptionMiddleware>();
+                mainApp.UseMiddleware<ExceptionMiddleware>();
 
-            app.UseMiddleware<ResponseTimeMiddleware>();
+                mainApp.UseMiddleware<ResponseTimeMiddleware>();
 
-            app.UseWebSockets();
+                mainApp.UseWebSockets();
 
-            app.UseResponseCompression();
+                mainApp.UseResponseCompression();
 
-            app.UseCors(ServerCorsPolicy.DefaultPolicyName);
+                mainApp.UseCors(ServerCorsPolicy.DefaultPolicyName);
 
                 if (_serverConfigurationManager.Configuration.RequireHttps
                     && _serverApplicationHost.ListenWithHttps)
                 {
-                app.UseHttpsRedirection();
+                    mainApp.UseHttpsRedirection();
                 }
 
-            app.UseStaticFiles();
+                mainApp.UsePathBase(_serverConfigurationManager.Configuration.BaseUrl);
-            app.UsePathBase(_serverConfigurationManager.Configuration.BaseUrl);
+                mainApp.UseStaticFiles();
                 if (appConfig.HostWebClient())
                 {
-                app.UseStaticFiles(new StaticFileOptions
+                    mainApp.UseStaticFiles(new StaticFileOptions
                     {
                         FileProvider = new PhysicalFileProvider(_serverConfigurationManager.ApplicationPaths.WebPath),
                         RequestPath = "/web"
                     });
                 }
 
-            app.UseAuthentication();
+                mainApp.UseAuthentication();
-            app.UseJellyfinApiSwagger(_serverConfigurationManager);
+                mainApp.UseJellyfinApiSwagger(_serverConfigurationManager);
-            app.UseRouting();
+                mainApp.UseRouting();
-            app.UseAuthorization();
+                mainApp.UseAuthorization();
                 if (_serverConfigurationManager.Configuration.EnableMetrics)
                 {
                     // Must be registered after any middleware that could change HTTP response codes or the data will be bad
-                app.UseHttpMetrics();
+                    mainApp.UseHttpMetrics();
                 }
 
-            app.UseLanFiltering();
+                mainApp.UseLanFiltering();
-            app.UseIpBasedAccessValidation();
+                mainApp.UseIpBasedAccessValidation();
-            app.UseBaseUrlRedirection();
+                mainApp.UseWebSocketHandler();
-            app.UseWebSocketHandler();
+                mainApp.UseServerStartupMessage();
-            app.UseServerStartupMessage();
 
-            app.UseEndpoints(endpoints =>
+                mainApp.UseEndpoints(endpoints =>
                 {
                     endpoints.MapControllers();
                     if (_serverConfigurationManager.Configuration.EnableMetrics)
                     {
-                    endpoints.MapMetrics(_serverConfigurationManager.Configuration.BaseUrl.TrimStart('/') + "/metrics");
+                        endpoints.MapMetrics("/metrics");
                     }
 
-                endpoints.MapHealthChecks(_serverConfigurationManager.Configuration.BaseUrl.TrimStart('/') + "/health");
+                    endpoints.MapHealthChecks("/health");
+                });
             });
 
             // Add type descriptor for legacy datetime parsing.