< Summary - Jellyfin

Information
Class: Jellyfin.Server.Extensions.ApiServiceCollectionExtensions
Assembly: jellyfin
File(s): /srv/git/jellyfin/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
Line coverage
98%
Covered lines: 239
Uncovered lines: 3
Coverable lines: 242
Total lines: 390
Line coverage: 98.7%
Branch coverage
90%
Covered branches: 27
Total branches: 30
Branch coverage: 90%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
AddJellyfinApiAuthorization(...)100%11100%
AddCustomAuthentication(...)100%11100%
AddJellyfinApi(...)100%22100%
AddJellyfinApiSwagger(...)100%11100%
AddPolicy(...)100%11100%
AddProxyAddresses(...)87.5%181680%
AddIPAddress(...)91.66%121287.5%
AddSwaggerTypeMappings(...)100%11100%

File(s)

/srv/git/jellyfin/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.IO;
 4using System.Linq;
 5using System.Net;
 6using System.Net.Sockets;
 7using System.Reflection;
 8using System.Security.Claims;
 9using Emby.Server.Implementations;
 10using Jellyfin.Api.Auth;
 11using Jellyfin.Api.Auth.AnonymousLanAccessPolicy;
 12using Jellyfin.Api.Auth.DefaultAuthorizationPolicy;
 13using Jellyfin.Api.Auth.FirstTimeSetupPolicy;
 14using Jellyfin.Api.Auth.LocalAccessOrRequiresElevationPolicy;
 15using Jellyfin.Api.Auth.SyncPlayAccessPolicy;
 16using Jellyfin.Api.Auth.UserPermissionPolicy;
 17using Jellyfin.Api.Constants;
 18using Jellyfin.Api.Controllers;
 19using Jellyfin.Api.Formatters;
 20using Jellyfin.Api.ModelBinders;
 21using Jellyfin.Data.Enums;
 22using Jellyfin.Database.Implementations.Enums;
 23using Jellyfin.Extensions.Json;
 24using Jellyfin.Server.Configuration;
 25using Jellyfin.Server.Filters;
 26using MediaBrowser.Common.Api;
 27using MediaBrowser.Common.Net;
 28using MediaBrowser.Model.Entities;
 29using MediaBrowser.Model.Session;
 30using Microsoft.AspNetCore.Authentication;
 31using Microsoft.AspNetCore.Authorization;
 32using Microsoft.AspNetCore.Builder;
 33using Microsoft.AspNetCore.Cors.Infrastructure;
 34using Microsoft.AspNetCore.HttpOverrides;
 35using Microsoft.Extensions.DependencyInjection;
 36using Microsoft.OpenApi.Any;
 37using Microsoft.OpenApi.Interfaces;
 38using Microsoft.OpenApi.Models;
 39using Swashbuckle.AspNetCore.SwaggerGen;
 40using AuthenticationSchemes = Jellyfin.Api.Constants.AuthenticationSchemes;
 41
 42namespace Jellyfin.Server.Extensions
 43{
 44    /// <summary>
 45    /// API specific extensions for the service collection.
 46    /// </summary>
 47    public static class ApiServiceCollectionExtensions
 48    {
 49        /// <summary>
 50        /// Adds jellyfin API authorization policies to the DI container.
 51        /// </summary>
 52        /// <param name="serviceCollection">The service collection.</param>
 53        /// <returns>The updated service collection.</returns>
 54        public static IServiceCollection AddJellyfinApiAuthorization(this IServiceCollection serviceCollection)
 55        {
 56            // The default handler must be first so that it is evaluated first
 2157            serviceCollection.AddSingleton<IAuthorizationHandler, DefaultAuthorizationHandler>();
 2158            serviceCollection.AddSingleton<IAuthorizationHandler, UserPermissionHandler>();
 2159            serviceCollection.AddSingleton<IAuthorizationHandler, FirstTimeSetupHandler>();
 2160            serviceCollection.AddSingleton<IAuthorizationHandler, AnonymousLanAccessHandler>();
 2161            serviceCollection.AddSingleton<IAuthorizationHandler, SyncPlayAccessHandler>();
 2162            serviceCollection.AddSingleton<IAuthorizationHandler, LocalAccessOrRequiresElevationHandler>();
 63
 2164            return serviceCollection.AddAuthorizationCore(options =>
 2165            {
 2166                options.DefaultPolicy = new AuthorizationPolicyBuilder()
 2167                    .AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication)
 2168                    .AddRequirements(new DefaultAuthorizationRequirement())
 2169                    .Build();
 2170
 2171                options.AddPolicy(Policies.AnonymousLanAccessPolicy, new AnonymousLanAccessRequirement());
 2172                options.AddPolicy(Policies.CollectionManagement, new UserPermissionRequirement(PermissionKind.EnableColl
 2173                options.AddPolicy(Policies.Download, new UserPermissionRequirement(PermissionKind.EnableContentDownloadi
 2174                options.AddPolicy(Policies.FirstTimeSetupOrDefault, new FirstTimeSetupRequirement(requireAdmin: false));
 2175                options.AddPolicy(Policies.FirstTimeSetupOrElevated, new FirstTimeSetupRequirement());
 2176                options.AddPolicy(Policies.FirstTimeSetupOrIgnoreParentalControl, new FirstTimeSetupRequirement(false, f
 2177                options.AddPolicy(Policies.IgnoreParentalControl, new DefaultAuthorizationRequirement(validateParentalSc
 2178                options.AddPolicy(Policies.LiveTvAccess, new UserPermissionRequirement(PermissionKind.EnableLiveTvAccess
 2179                options.AddPolicy(Policies.LiveTvManagement, new UserPermissionRequirement(PermissionKind.EnableLiveTvMa
 2180                options.AddPolicy(Policies.LocalAccessOrRequiresElevation, new LocalAccessOrRequiresElevationRequirement
 2181                options.AddPolicy(Policies.SyncPlayHasAccess, new SyncPlayAccessRequirement(SyncPlayAccessRequirementTyp
 2182                options.AddPolicy(Policies.SyncPlayCreateGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementT
 2183                options.AddPolicy(Policies.SyncPlayJoinGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementTyp
 2184                options.AddPolicy(Policies.SyncPlayIsInGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementTyp
 2185                options.AddPolicy(Policies.SubtitleManagement, new UserPermissionRequirement(PermissionKind.EnableSubtit
 2186                options.AddPolicy(Policies.LyricManagement, new UserPermissionRequirement(PermissionKind.EnableLyricMana
 2187                options.AddPolicy(
 2188                    Policies.RequiresElevation,
 2189                    policy => policy.AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication)
 2190                        .RequireClaim(ClaimTypes.Role, UserRoles.Administrator));
 2191            });
 92        }
 93
 94        /// <summary>
 95        /// Adds custom legacy authentication to the service collection.
 96        /// </summary>
 97        /// <param name="serviceCollection">The service collection.</param>
 98        /// <returns>The updated service collection.</returns>
 99        public static AuthenticationBuilder AddCustomAuthentication(this IServiceCollection serviceCollection)
 100        {
 21101            return serviceCollection.AddAuthentication(AuthenticationSchemes.CustomAuthentication)
 21102                .AddScheme<AuthenticationSchemeOptions, CustomAuthenticationHandler>(AuthenticationSchemes.CustomAuthent
 103        }
 104
 105        /// <summary>
 106        /// Extension method for adding the Jellyfin API to the service collection.
 107        /// </summary>
 108        /// <param name="serviceCollection">The service collection.</param>
 109        /// <param name="pluginAssemblies">An IEnumerable containing all plugin assemblies with API controllers.</param>
 110        /// <param name="config">The <see cref="NetworkConfiguration"/>.</param>
 111        /// <returns>The MVC builder.</returns>
 112        public static IMvcBuilder AddJellyfinApi(this IServiceCollection serviceCollection, IEnumerable<Assembly> plugin
 113        {
 21114            IMvcBuilder mvcBuilder = serviceCollection
 21115                .AddCors()
 21116                .AddTransient<ICorsPolicyProvider, CorsPolicyProvider>()
 21117                .Configure<ForwardedHeadersOptions>(options =>
 21118                {
 21119                    // https://github.com/dotnet/aspnetcore/blob/master/src/Middleware/HttpOverrides/src/ForwardedHeader
 21120                    // Enable debug logging on Microsoft.AspNetCore.HttpOverrides.ForwardedHeadersMiddleware to help inv
 21121
 21122                    if (config.KnownProxies.Length == 0)
 21123                    {
 21124                        options.ForwardedHeaders = ForwardedHeaders.None;
 21125                        options.KnownNetworks.Clear();
 21126                        options.KnownProxies.Clear();
 21127                    }
 21128                    else
 21129                    {
 21130                        options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto | F
 21131                        AddProxyAddresses(config, config.KnownProxies, options);
 21132                    }
 21133
 21134                    // Only set forward limit if we have some known proxies or some known networks.
 21135                    if (options.KnownProxies.Count != 0 || options.KnownNetworks.Count != 0)
 21136                    {
 21137                        options.ForwardLimit = null;
 21138                    }
 21139                })
 21140                .AddMvc(opts =>
 21141                {
 21142                    // Allow requester to change between camelCase and PascalCase
 21143                    opts.RespectBrowserAcceptHeader = true;
 21144
 21145                    opts.OutputFormatters.Insert(0, new CamelCaseJsonProfileFormatter());
 21146                    opts.OutputFormatters.Insert(0, new PascalCaseJsonProfileFormatter());
 21147
 21148                    opts.OutputFormatters.Add(new CssOutputFormatter());
 21149                    opts.OutputFormatters.Add(new XmlOutputFormatter());
 21150
 21151                    opts.ModelBinderProviders.Insert(0, new NullableEnumModelBinderProvider());
 21152                })
 21153
 21154                // Clear app parts to avoid other assemblies being picked up
 21155                .ConfigureApplicationPartManager(a => a.ApplicationParts.Clear())
 21156                .AddApplicationPart(typeof(StartupController).Assembly)
 21157                .AddJsonOptions(options =>
 21158                {
 21159                    // Update all properties that are set in JsonDefaults
 21160                    var jsonOptions = JsonDefaults.PascalCaseOptions;
 21161
 21162                    // From JsonDefaults
 21163                    options.JsonSerializerOptions.ReadCommentHandling = jsonOptions.ReadCommentHandling;
 21164                    options.JsonSerializerOptions.WriteIndented = jsonOptions.WriteIndented;
 21165                    options.JsonSerializerOptions.DefaultIgnoreCondition = jsonOptions.DefaultIgnoreCondition;
 21166                    options.JsonSerializerOptions.NumberHandling = jsonOptions.NumberHandling;
 21167
 21168                    options.JsonSerializerOptions.Converters.Clear();
 21169                    foreach (var converter in jsonOptions.Converters)
 21170                    {
 21171                        options.JsonSerializerOptions.Converters.Add(converter);
 21172                    }
 21173
 21174                    // From JsonDefaults.PascalCase
 21175                    options.JsonSerializerOptions.PropertyNamingPolicy = jsonOptions.PropertyNamingPolicy;
 21176                });
 177
 126178            foreach (Assembly pluginAssembly in pluginAssemblies)
 179            {
 42180                mvcBuilder.AddApplicationPart(pluginAssembly);
 181            }
 182
 21183            return mvcBuilder.AddControllersAsServices();
 184        }
 185
 186        /// <summary>
 187        /// Adds Swagger to the service collection.
 188        /// </summary>
 189        /// <param name="serviceCollection">The service collection.</param>
 190        /// <returns>The updated service collection.</returns>
 191        public static IServiceCollection AddJellyfinApiSwagger(this IServiceCollection serviceCollection)
 192        {
 21193            return serviceCollection.AddSwaggerGen(c =>
 21194            {
 21195                var version = typeof(ApplicationHost).Assembly.GetName().Version?.ToString(3) ?? "0.0.1";
 21196                c.SwaggerDoc("api-docs", new OpenApiInfo
 21197                {
 21198                    Title = "Jellyfin API",
 21199                    Version = version,
 21200                    Extensions = new Dictionary<string, IOpenApiExtension>
 21201                    {
 21202                        {
 21203                            "x-jellyfin-version",
 21204                            new OpenApiString(version)
 21205                        }
 21206                    }
 21207                });
 21208
 21209                c.AddSecurityDefinition(AuthenticationSchemes.CustomAuthentication, new OpenApiSecurityScheme
 21210                {
 21211                    Type = SecuritySchemeType.ApiKey,
 21212                    In = ParameterLocation.Header,
 21213                    Name = "Authorization",
 21214                    Description = "API key header parameter"
 21215                });
 21216
 21217                // Add all xml doc files to swagger generator.
 21218                var xmlFiles = Directory.GetFiles(
 21219                    AppContext.BaseDirectory,
 21220                    "*.xml",
 21221                    SearchOption.TopDirectoryOnly);
 21222
 21223                foreach (var xmlFile in xmlFiles)
 21224                {
 21225                    c.IncludeXmlComments(xmlFile);
 21226                }
 21227
 21228                // Order actions by route path, then by http method.
 21229                c.OrderActionsBy(description =>
 21230                    $"{description.ActionDescriptor.RouteValues["controller"]}_{description.RelativePath}");
 21231
 21232                // Use method name as operationId
 21233                c.CustomOperationIds(
 21234                    description =>
 21235                    {
 21236                        description.TryGetMethodInfo(out MethodInfo methodInfo);
 21237                        // Attribute name, method name, none.
 21238                        return description?.ActionDescriptor.AttributeRouteInfo?.Name
 21239                               ?? methodInfo?.Name
 21240                               ?? null;
 21241                    });
 21242
 21243                // Allow parameters to properly be nullable.
 21244                c.UseAllOfToExtendReferenceSchemas();
 21245                c.SupportNonNullableReferenceTypes();
 21246
 21247                // TODO - remove when all types are supported in System.Text.Json
 21248                c.AddSwaggerTypeMappings();
 21249
 21250                c.SchemaFilter<IgnoreEnumSchemaFilter>();
 21251                c.OperationFilter<RetryOnTemporarlyUnavailableFilter>();
 21252                c.OperationFilter<SecurityRequirementsOperationFilter>();
 21253                c.OperationFilter<FileResponseFilter>();
 21254                c.OperationFilter<FileRequestFilter>();
 21255                c.OperationFilter<ParameterObsoleteFilter>();
 21256                c.DocumentFilter<AdditionalModelFilter>();
 21257            });
 258        }
 259
 260        private static void AddPolicy(this AuthorizationOptions authorizationOptions, string policyName, IAuthorizationR
 261        {
 336262            authorizationOptions.AddPolicy(policyName, policy =>
 336263            {
 336264                policy.AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication).AddRequirements(authorizatio
 336265            });
 336266        }
 267
 268        /// <summary>
 269        /// Sets up the proxy configuration based on the addresses/subnets in <paramref name="allowedProxies"/>.
 270        /// </summary>
 271        /// <param name="config">The <see cref="NetworkConfiguration"/> containing the config settings.</param>
 272        /// <param name="allowedProxies">The string array to parse.</param>
 273        /// <param name="options">The <see cref="ForwardedHeadersOptions"/> instance.</param>
 274        internal static void AddProxyAddresses(NetworkConfiguration config, string[] allowedProxies, ForwardedHeadersOpt
 275        {
 38276            for (var i = 0; i < allowedProxies.Length; i++)
 277            {
 12278                if (IPAddress.TryParse(allowedProxies[i], out var addr))
 279                {
 4280                    AddIPAddress(config, options, addr, addr.AddressFamily == AddressFamily.InterNetwork ? NetworkConsta
 281                }
 8282                else if (NetworkUtils.TryParseToSubnet(allowedProxies[i], out var subnet))
 283                {
 0284                    if (subnet is not null)
 285                    {
 0286                        AddIPAddress(config, options, subnet.Prefix, subnet.PrefixLength);
 287                    }
 288                }
 8289                else if (NetworkUtils.TryParseHost(allowedProxies[i], out var addresses, config.EnableIPv4, config.Enabl
 290                {
 24291                    foreach (var address in addresses)
 292                    {
 8293                        AddIPAddress(config, options, address, address.AddressFamily == AddressFamily.InterNetwork ? Net
 294                    }
 295                }
 296            }
 7297        }
 298
 299        private static void AddIPAddress(NetworkConfiguration config, ForwardedHeadersOptions options, IPAddress addr, i
 300        {
 12301            if (addr.IsIPv4MappedToIPv6)
 302            {
 0303                addr = addr.MapToIPv4();
 304            }
 305
 12306            if ((!config.EnableIPv4 && addr.AddressFamily == AddressFamily.InterNetwork) || (!config.EnableIPv6 && addr.
 307            {
 4308                return;
 309            }
 310
 8311            if (prefixLength == NetworkConstants.MinimumIPv4PrefixSize)
 312            {
 4313                options.KnownProxies.Add(addr);
 314            }
 315            else
 316            {
 4317                options.KnownNetworks.Add(new Microsoft.AspNetCore.HttpOverrides.IPNetwork(addr, prefixLength));
 318            }
 4319        }
 320
 321        private static void AddSwaggerTypeMappings(this SwaggerGenOptions options)
 322        {
 323            /*
 324             * TODO remove when System.Text.Json properly supports non-string keys.
 325             * Used in BaseItemDto.ImageBlurHashes
 326             */
 20327            options.MapType<Dictionary<ImageType, string>>(() =>
 20328                new OpenApiSchema
 20329                {
 20330                    Type = "object",
 20331                    AdditionalProperties = new OpenApiSchema
 20332                    {
 20333                        Type = "string"
 20334                    }
 20335                });
 336
 337            /*
 338             * Support BlurHash dictionary
 339             */
 20340            options.MapType<Dictionary<ImageType, Dictionary<string, string>>>(() =>
 20341                new OpenApiSchema
 20342                {
 20343                    Type = "object",
 20344                    Properties = typeof(ImageType).GetEnumNames().ToDictionary(
 20345                        name => name,
 20346                        _ => new OpenApiSchema
 20347                        {
 20348                            Type = "object",
 20349                            AdditionalProperties = new OpenApiSchema
 20350                            {
 20351                                Type = "string"
 20352                            }
 20353                        })
 20354                });
 355
 356            // Support dictionary with nullable string value.
 20357            options.MapType<Dictionary<string, string?>>(() =>
 20358                new OpenApiSchema
 20359                {
 20360                    Type = "object",
 20361                    AdditionalProperties = new OpenApiSchema
 20362                    {
 20363                        Type = "string",
 20364                        Nullable = true
 20365                    }
 20366                });
 367
 368            // Manually describe Flags enum.
 20369            options.MapType<TranscodeReason>(() =>
 20370                new OpenApiSchema
 20371                {
 20372                    Type = "array",
 20373                    Items = new OpenApiSchema
 20374                    {
 20375                        Reference = new OpenApiReference
 20376                        {
 20377                            Id = nameof(TranscodeReason),
 20378                            Type = ReferenceType.Schema,
 20379                        }
 20380                    }
 20381                });
 382
 383            // Swashbuckle doesn't use JsonOptions to describe responses, so we need to manually describe it.
 20384            options.MapType<Version>(() => new OpenApiSchema
 20385            {
 20386                Type = "string"
 20387            });
 20388        }
 389    }
 390}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:58 AM
GitHub | reportgenerator.io

Methods/Properties

AddJellyfinApiAuthorization(Microsoft.Extensions.DependencyInjection.IServiceCollection)
AddCustomAuthentication(Microsoft.Extensions.DependencyInjection.IServiceCollection)
AddJellyfinApi(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Collections.Generic.IEnumerable`1<System.Reflection.Assembly>,MediaBrowser.Common.Net.NetworkConfiguration)
AddJellyfinApiSwagger(Microsoft.Extensions.DependencyInjection.IServiceCollection)
AddPolicy(Microsoft.AspNetCore.Authorization.AuthorizationOptions,System.String,Microsoft.AspNetCore.Authorization.IAuthorizationRequirement)
AddProxyAddresses(MediaBrowser.Common.Net.NetworkConfiguration,System.String[],Microsoft.AspNetCore.Builder.ForwardedHeadersOptions)
AddIPAddress(MediaBrowser.Common.Net.NetworkConfiguration,Microsoft.AspNetCore.Builder.ForwardedHeadersOptions,System.Net.IPAddress,System.Int32)
AddSwaggerTypeMappings(Swashbuckle.AspNetCore.SwaggerGen.SwaggerGenOptions)