2020-04-19 19:24:32 +02:00
|
|
|
using System;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.IO;
|
|
|
|
using System.Linq;
|
2020-09-10 11:05:46 +02:00
|
|
|
using System.Net;
|
2021-01-08 01:05:15 +01:00
|
|
|
using System.Net.Sockets;
|
2020-05-08 16:40:37 +02:00
|
|
|
using System.Reflection;
|
2023-02-08 23:55:26 +01:00
|
|
|
using System.Security.Claims;
|
2020-11-06 21:00:14 +01:00
|
|
|
using Emby.Server.Implementations;
|
2019-11-23 19:43:30 +01:00
|
|
|
using Jellyfin.Api.Auth;
|
2021-09-10 11:44:50 +02:00
|
|
|
using Jellyfin.Api.Auth.AnonymousLanAccessPolicy;
|
2020-06-15 20:49:54 +02:00
|
|
|
using Jellyfin.Api.Auth.DefaultAuthorizationPolicy;
|
2023-02-08 23:55:26 +01:00
|
|
|
using Jellyfin.Api.Auth.FirstTimeSetupPolicy;
|
2020-08-06 16:17:45 +02:00
|
|
|
using Jellyfin.Api.Auth.LocalAccessOrRequiresElevationPolicy;
|
2020-12-03 10:43:44 +01:00
|
|
|
using Jellyfin.Api.Auth.SyncPlayAccessPolicy;
|
2023-02-08 23:55:26 +01:00
|
|
|
using Jellyfin.Api.Auth.UserPermissionPolicy;
|
2019-11-24 19:25:46 +01:00
|
|
|
using Jellyfin.Api.Constants;
|
2019-11-23 19:43:30 +01:00
|
|
|
using Jellyfin.Api.Controllers;
|
2023-01-14 04:23:22 +01:00
|
|
|
using Jellyfin.Api.Formatters;
|
2020-11-21 19:58:35 +01:00
|
|
|
using Jellyfin.Api.ModelBinders;
|
2020-12-03 10:43:44 +01:00
|
|
|
using Jellyfin.Data.Enums;
|
2021-06-19 18:02:33 +02:00
|
|
|
using Jellyfin.Extensions.Json;
|
2020-09-05 21:02:53 +02:00
|
|
|
using Jellyfin.Server.Configuration;
|
2020-09-02 01:26:49 +02:00
|
|
|
using Jellyfin.Server.Filters;
|
2023-11-10 16:49:40 +01:00
|
|
|
using MediaBrowser.Common.Net;
|
2020-06-02 19:47:00 +02:00
|
|
|
using MediaBrowser.Model.Entities;
|
2022-03-23 15:32:33 +01:00
|
|
|
using MediaBrowser.Model.Session;
|
2019-11-23 19:43:30 +01:00
|
|
|
using Microsoft.AspNetCore.Authentication;
|
|
|
|
using Microsoft.AspNetCore.Authorization;
|
2020-06-17 16:05:30 +02:00
|
|
|
using Microsoft.AspNetCore.Builder;
|
2020-09-05 17:10:05 +02:00
|
|
|
using Microsoft.AspNetCore.Cors.Infrastructure;
|
2020-06-17 16:05:30 +02:00
|
|
|
using Microsoft.AspNetCore.HttpOverrides;
|
2019-11-23 19:43:30 +01:00
|
|
|
using Microsoft.Extensions.DependencyInjection;
|
2020-11-06 21:00:14 +01:00
|
|
|
using Microsoft.OpenApi.Any;
|
|
|
|
using Microsoft.OpenApi.Interfaces;
|
2019-11-23 19:43:30 +01:00
|
|
|
using Microsoft.OpenApi.Models;
|
2020-05-08 16:40:37 +02:00
|
|
|
using Swashbuckle.AspNetCore.SwaggerGen;
|
2020-09-10 11:05:46 +02:00
|
|
|
using AuthenticationSchemes = Jellyfin.Api.Constants.AuthenticationSchemes;
|
2019-11-23 19:43:30 +01:00
|
|
|
|
2019-11-24 15:27:58 +01:00
|
|
|
namespace Jellyfin.Server.Extensions
|
2019-11-23 19:43:30 +01:00
|
|
|
{
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <summary>
|
|
|
|
/// API specific extensions for the service collection.
|
|
|
|
/// </summary>
|
2019-11-23 19:43:30 +01:00
|
|
|
public static class ApiServiceCollectionExtensions
|
|
|
|
{
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Adds jellyfin API authorization policies to the DI container.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="serviceCollection">The service collection.</param>
|
|
|
|
/// <returns>The updated service collection.</returns>
|
2019-11-23 19:43:30 +01:00
|
|
|
public static IServiceCollection AddJellyfinApiAuthorization(this IServiceCollection serviceCollection)
|
|
|
|
{
|
2023-02-08 23:55:26 +01:00
|
|
|
// The default handler must be first so that it is evaluated first
|
2020-06-15 20:49:54 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, DefaultAuthorizationHandler>();
|
2023-02-08 23:55:26 +01:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, UserPermissionHandler>();
|
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, FirstTimeSetupHandler>();
|
2021-09-10 11:44:50 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, AnonymousLanAccessHandler>();
|
2020-12-03 10:43:44 +01:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, SyncPlayAccessHandler>();
|
2023-09-23 23:58:03 +02:00
|
|
|
serviceCollection.AddSingleton<IAuthorizationHandler, LocalAccessOrRequiresElevationHandler>();
|
2023-02-08 23:55:26 +01:00
|
|
|
|
2019-11-23 19:43:30 +01:00
|
|
|
return serviceCollection.AddAuthorizationCore(options =>
|
|
|
|
{
|
2023-02-08 23:55:26 +01:00
|
|
|
options.DefaultPolicy = new AuthorizationPolicyBuilder()
|
|
|
|
.AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication)
|
2023-02-09 13:15:58 +01:00
|
|
|
.AddRequirements(new DefaultAuthorizationRequirement())
|
2023-02-08 23:55:26 +01:00
|
|
|
.Build();
|
|
|
|
|
2023-02-14 19:04:18 +01:00
|
|
|
options.AddPolicy(Policies.AnonymousLanAccessPolicy, new AnonymousLanAccessRequirement());
|
|
|
|
options.AddPolicy(Policies.CollectionManagement, new UserPermissionRequirement(PermissionKind.EnableCollectionManagement));
|
2023-02-08 23:55:26 +01:00
|
|
|
options.AddPolicy(Policies.Download, new UserPermissionRequirement(PermissionKind.EnableContentDownloading));
|
2023-02-09 21:06:51 +01:00
|
|
|
options.AddPolicy(Policies.FirstTimeSetupOrDefault, new FirstTimeSetupRequirement(requireAdmin: false));
|
|
|
|
options.AddPolicy(Policies.FirstTimeSetupOrElevated, new FirstTimeSetupRequirement());
|
|
|
|
options.AddPolicy(Policies.FirstTimeSetupOrIgnoreParentalControl, new FirstTimeSetupRequirement(false, false));
|
2023-02-08 23:55:26 +01:00
|
|
|
options.AddPolicy(Policies.IgnoreParentalControl, new DefaultAuthorizationRequirement(validateParentalSchedule: false));
|
2023-02-14 19:04:18 +01:00
|
|
|
options.AddPolicy(Policies.LiveTvAccess, new UserPermissionRequirement(PermissionKind.EnableLiveTvAccess));
|
|
|
|
options.AddPolicy(Policies.LiveTvManagement, new UserPermissionRequirement(PermissionKind.EnableLiveTvManagement));
|
|
|
|
options.AddPolicy(Policies.LocalAccessOrRequiresElevation, new LocalAccessOrRequiresElevationRequirement());
|
2023-02-08 23:55:26 +01:00
|
|
|
options.AddPolicy(Policies.SyncPlayHasAccess, new SyncPlayAccessRequirement(SyncPlayAccessRequirementType.HasAccess));
|
|
|
|
options.AddPolicy(Policies.SyncPlayCreateGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementType.CreateGroup));
|
|
|
|
options.AddPolicy(Policies.SyncPlayJoinGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementType.JoinGroup));
|
|
|
|
options.AddPolicy(Policies.SyncPlayIsInGroup, new SyncPlayAccessRequirement(SyncPlayAccessRequirementType.IsInGroup));
|
2023-10-16 23:57:08 +02:00
|
|
|
options.AddPolicy(Policies.SubtitleManagement, new UserPermissionRequirement(PermissionKind.EnableSubtitleManagement));
|
2020-06-15 20:49:54 +02:00
|
|
|
options.AddPolicy(
|
|
|
|
Policies.RequiresElevation,
|
2023-02-08 23:55:26 +01:00
|
|
|
policy => policy.AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication)
|
|
|
|
.RequireClaim(ClaimTypes.Role, UserRoles.Administrator));
|
2019-11-23 19:43:30 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Adds custom legacy authentication to the service collection.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="serviceCollection">The service collection.</param>
|
|
|
|
/// <returns>The updated service collection.</returns>
|
2019-11-23 19:43:30 +01:00
|
|
|
public static AuthenticationBuilder AddCustomAuthentication(this IServiceCollection serviceCollection)
|
|
|
|
{
|
2019-11-24 19:25:46 +01:00
|
|
|
return serviceCollection.AddAuthentication(AuthenticationSchemes.CustomAuthentication)
|
|
|
|
.AddScheme<AuthenticationSchemeOptions, CustomAuthenticationHandler>(AuthenticationSchemes.CustomAuthentication, null);
|
2019-11-23 19:43:30 +01:00
|
|
|
}
|
|
|
|
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <summary>
|
2022-07-20 09:48:20 +02:00
|
|
|
/// Extension method for adding the Jellyfin API to the service collection.
|
2019-11-23 20:31:17 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="serviceCollection">The service collection.</param>
|
2020-09-02 16:03:15 +02:00
|
|
|
/// <param name="pluginAssemblies">An IEnumerable containing all plugin assemblies with API controllers.</param>
|
2021-01-08 01:05:15 +01:00
|
|
|
/// <param name="config">The <see cref="NetworkConfiguration"/>.</param>
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <returns>The MVC builder.</returns>
|
2021-01-19 11:36:37 +01:00
|
|
|
public static IMvcBuilder AddJellyfinApi(this IServiceCollection serviceCollection, IEnumerable<Assembly> pluginAssemblies, NetworkConfiguration config)
|
2019-11-23 19:43:30 +01:00
|
|
|
{
|
2020-08-10 16:12:22 +02:00
|
|
|
IMvcBuilder mvcBuilder = serviceCollection
|
2021-01-12 21:43:25 +01:00
|
|
|
.AddCors()
|
|
|
|
.AddTransient<ICorsPolicyProvider, CorsPolicyProvider>()
|
|
|
|
.Configure<ForwardedHeadersOptions>(options =>
|
2020-06-17 16:05:30 +02:00
|
|
|
{
|
2021-01-08 01:05:15 +01:00
|
|
|
// https://github.com/dotnet/aspnetcore/blob/master/src/Middleware/HttpOverrides/src/ForwardedHeadersMiddleware.cs
|
|
|
|
// Enable debug logging on Microsoft.AspNetCore.HttpOverrides.ForwardedHeadersMiddleware to help investigate issues.
|
|
|
|
|
2021-08-31 22:22:55 +02:00
|
|
|
options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedHost;
|
|
|
|
|
2021-01-08 01:05:15 +01:00
|
|
|
if (config.KnownProxies.Length == 0)
|
2020-09-10 11:05:46 +02:00
|
|
|
{
|
2021-01-08 01:05:15 +01:00
|
|
|
options.KnownNetworks.Clear();
|
2021-01-12 14:23:10 +01:00
|
|
|
options.KnownProxies.Clear();
|
2020-12-05 10:18:56 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-01-19 20:29:51 +01:00
|
|
|
AddProxyAddresses(config, config.KnownProxies, options);
|
2020-09-10 11:05:46 +02:00
|
|
|
}
|
2021-01-08 01:05:15 +01:00
|
|
|
|
|
|
|
// Only set forward limit if we have some known proxies or some known networks.
|
|
|
|
if (options.KnownProxies.Count != 0 || options.KnownNetworks.Count != 0)
|
|
|
|
{
|
|
|
|
options.ForwardLimit = null;
|
|
|
|
}
|
2020-06-17 16:05:30 +02:00
|
|
|
})
|
2020-06-01 19:03:08 +02:00
|
|
|
.AddMvc(opts =>
|
2019-11-23 19:43:30 +01:00
|
|
|
{
|
2020-08-20 19:17:27 +02:00
|
|
|
// Allow requester to change between camelCase and PascalCase
|
|
|
|
opts.RespectBrowserAcceptHeader = true;
|
|
|
|
|
2020-04-20 02:10:59 +02:00
|
|
|
opts.OutputFormatters.Insert(0, new CamelCaseJsonProfileFormatter());
|
|
|
|
opts.OutputFormatters.Insert(0, new PascalCaseJsonProfileFormatter());
|
2020-06-07 00:51:21 +02:00
|
|
|
|
|
|
|
opts.OutputFormatters.Add(new CssOutputFormatter());
|
2020-08-15 18:39:24 +02:00
|
|
|
opts.OutputFormatters.Add(new XmlOutputFormatter());
|
2020-11-21 19:58:35 +01:00
|
|
|
|
|
|
|
opts.ModelBinderProviders.Insert(0, new NullableEnumModelBinderProvider());
|
2019-11-23 19:43:30 +01:00
|
|
|
})
|
2019-11-23 20:31:17 +01:00
|
|
|
|
2019-11-23 19:43:30 +01:00
|
|
|
// Clear app parts to avoid other assemblies being picked up
|
|
|
|
.ConfigureApplicationPartManager(a => a.ApplicationParts.Clear())
|
|
|
|
.AddApplicationPart(typeof(StartupController).Assembly)
|
2020-04-15 08:24:15 +02:00
|
|
|
.AddJsonOptions(options =>
|
2020-04-13 03:17:46 +02:00
|
|
|
{
|
2020-05-21 16:44:15 +02:00
|
|
|
// Update all properties that are set in JsonDefaults
|
2021-03-09 05:57:38 +01:00
|
|
|
var jsonOptions = JsonDefaults.PascalCaseOptions;
|
2020-05-21 16:44:15 +02:00
|
|
|
|
|
|
|
// From JsonDefaults
|
|
|
|
options.JsonSerializerOptions.ReadCommentHandling = jsonOptions.ReadCommentHandling;
|
|
|
|
options.JsonSerializerOptions.WriteIndented = jsonOptions.WriteIndented;
|
2020-08-25 15:33:58 +02:00
|
|
|
options.JsonSerializerOptions.DefaultIgnoreCondition = jsonOptions.DefaultIgnoreCondition;
|
2020-08-26 16:22:48 +02:00
|
|
|
options.JsonSerializerOptions.NumberHandling = jsonOptions.NumberHandling;
|
2020-08-23 15:48:12 +02:00
|
|
|
|
2020-05-21 16:44:15 +02:00
|
|
|
options.JsonSerializerOptions.Converters.Clear();
|
|
|
|
foreach (var converter in jsonOptions.Converters)
|
|
|
|
{
|
|
|
|
options.JsonSerializerOptions.Converters.Add(converter);
|
|
|
|
}
|
|
|
|
|
|
|
|
// From JsonDefaults.PascalCase
|
|
|
|
options.JsonSerializerOptions.PropertyNamingPolicy = jsonOptions.PropertyNamingPolicy;
|
2020-08-11 17:04:11 +02:00
|
|
|
});
|
2020-08-10 16:12:22 +02:00
|
|
|
|
2020-08-31 17:53:55 +02:00
|
|
|
foreach (Assembly pluginAssembly in pluginAssemblies)
|
2020-08-10 16:12:22 +02:00
|
|
|
{
|
2020-08-11 17:04:11 +02:00
|
|
|
mvcBuilder.AddApplicationPart(pluginAssembly);
|
2020-08-10 16:12:22 +02:00
|
|
|
}
|
|
|
|
|
2020-08-11 17:04:11 +02:00
|
|
|
return mvcBuilder.AddControllersAsServices();
|
2019-11-23 19:43:30 +01:00
|
|
|
}
|
|
|
|
|
2019-11-23 20:31:17 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Adds Swagger to the service collection.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="serviceCollection">The service collection.</param>
|
|
|
|
/// <returns>The updated service collection.</returns>
|
2019-11-23 19:43:30 +01:00
|
|
|
public static IServiceCollection AddJellyfinApiSwagger(this IServiceCollection serviceCollection)
|
|
|
|
{
|
|
|
|
return serviceCollection.AddSwaggerGen(c =>
|
|
|
|
{
|
2021-03-30 15:15:16 +02:00
|
|
|
var version = typeof(ApplicationHost).Assembly.GetName().Version?.ToString(3) ?? "0.0.1";
|
2020-11-06 21:00:14 +01:00
|
|
|
c.SwaggerDoc("api-docs", new OpenApiInfo
|
|
|
|
{
|
|
|
|
Title = "Jellyfin API",
|
2021-03-13 01:11:43 +01:00
|
|
|
Version = version,
|
2020-11-06 21:00:14 +01:00
|
|
|
Extensions = new Dictionary<string, IOpenApiExtension>
|
|
|
|
{
|
|
|
|
{
|
|
|
|
"x-jellyfin-version",
|
2021-03-13 01:11:43 +01:00
|
|
|
new OpenApiString(version)
|
2020-11-06 21:00:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-06-01 19:12:33 +02:00
|
|
|
c.AddSecurityDefinition(AuthenticationSchemes.CustomAuthentication, new OpenApiSecurityScheme
|
|
|
|
{
|
|
|
|
Type = SecuritySchemeType.ApiKey,
|
|
|
|
In = ParameterLocation.Header,
|
2021-09-15 19:28:20 +02:00
|
|
|
Name = "Authorization",
|
2020-06-01 19:12:33 +02:00
|
|
|
Description = "API key header parameter"
|
|
|
|
});
|
|
|
|
|
2020-04-19 19:24:32 +02:00
|
|
|
// Add all xml doc files to swagger generator.
|
|
|
|
var xmlFiles = Directory.GetFiles(
|
|
|
|
AppContext.BaseDirectory,
|
|
|
|
"*.xml",
|
|
|
|
SearchOption.TopDirectoryOnly);
|
|
|
|
|
|
|
|
foreach (var xmlFile in xmlFiles)
|
|
|
|
{
|
|
|
|
c.IncludeXmlComments(xmlFile);
|
|
|
|
}
|
2020-04-27 07:28:32 +02:00
|
|
|
|
|
|
|
// Order actions by route path, then by http method.
|
|
|
|
c.OrderActionsBy(description =>
|
2020-06-26 01:44:11 +02:00
|
|
|
$"{description.ActionDescriptor.RouteValues["controller"]}_{description.RelativePath}");
|
2020-05-08 16:40:37 +02:00
|
|
|
|
|
|
|
// Use method name as operationId
|
2020-08-03 22:38:51 +02:00
|
|
|
c.CustomOperationIds(
|
|
|
|
description =>
|
|
|
|
{
|
|
|
|
description.TryGetMethodInfo(out MethodInfo methodInfo);
|
|
|
|
// Attribute name, method name, none.
|
2021-08-04 14:40:09 +02:00
|
|
|
return description?.ActionDescriptor.AttributeRouteInfo?.Name
|
2020-08-03 22:38:51 +02:00
|
|
|
?? methodInfo?.Name
|
|
|
|
?? null;
|
|
|
|
});
|
2020-06-02 19:47:00 +02:00
|
|
|
|
2021-01-24 22:36:36 +01:00
|
|
|
// Allow parameters to properly be nullable.
|
|
|
|
c.UseAllOfToExtendReferenceSchemas();
|
2021-02-15 18:08:38 +01:00
|
|
|
c.SupportNonNullableReferenceTypes();
|
2021-01-24 22:36:36 +01:00
|
|
|
|
2020-06-02 19:47:00 +02:00
|
|
|
// TODO - remove when all types are supported in System.Text.Json
|
|
|
|
c.AddSwaggerTypeMappings();
|
2020-09-02 01:26:49 +02:00
|
|
|
|
2023-11-09 22:00:29 +01:00
|
|
|
c.SchemaFilter<IgnoreEnumSchemaFilter>();
|
2020-12-02 22:59:57 +01:00
|
|
|
c.OperationFilter<SecurityRequirementsOperationFilter>();
|
2020-09-02 01:26:49 +02:00
|
|
|
c.OperationFilter<FileResponseFilter>();
|
2021-02-11 00:12:52 +01:00
|
|
|
c.OperationFilter<FileRequestFilter>();
|
2021-01-21 00:24:15 +01:00
|
|
|
c.OperationFilter<ParameterObsoleteFilter>();
|
2021-04-03 14:54:09 +02:00
|
|
|
c.DocumentFilter<AdditionalModelFilter>();
|
2019-11-23 19:43:30 +01:00
|
|
|
});
|
|
|
|
}
|
2020-06-02 19:47:00 +02:00
|
|
|
|
2023-02-08 23:55:26 +01:00
|
|
|
private static void AddPolicy(this AuthorizationOptions authorizationOptions, string policyName, IAuthorizationRequirement authorizationRequirement)
|
|
|
|
{
|
|
|
|
authorizationOptions.AddPolicy(policyName, policy =>
|
|
|
|
{
|
|
|
|
policy.AddAuthenticationSchemes(AuthenticationSchemes.CustomAuthentication).AddRequirements(authorizationRequirement);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-01-19 11:36:37 +01:00
|
|
|
/// <summary>
|
2022-07-20 09:48:20 +02:00
|
|
|
/// Sets up the proxy configuration based on the addresses/subnets in <paramref name="allowedProxies"/>.
|
2021-01-19 11:36:37 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="config">The <see cref="NetworkConfiguration"/> containing the config settings.</param>
|
2021-01-19 20:29:51 +01:00
|
|
|
/// <param name="allowedProxies">The string array to parse.</param>
|
2021-01-19 11:36:37 +01:00
|
|
|
/// <param name="options">The <see cref="ForwardedHeadersOptions"/> instance.</param>
|
2021-01-19 20:29:51 +01:00
|
|
|
internal static void AddProxyAddresses(NetworkConfiguration config, string[] allowedProxies, ForwardedHeadersOptions options)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2021-01-19 20:29:51 +01:00
|
|
|
for (var i = 0; i < allowedProxies.Length; i++)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2022-07-19 21:28:04 +02:00
|
|
|
if (IPAddress.TryParse(allowedProxies[i], out var addr))
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2023-11-10 16:49:40 +01:00
|
|
|
AddIPAddress(config, options, addr, addr.AddressFamily == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : NetworkConstants.MinimumIPv6PrefixSize);
|
2021-01-19 11:36:37 +01:00
|
|
|
}
|
2023-11-10 16:59:45 +01:00
|
|
|
else if (NetworkUtils.TryParseToSubnet(allowedProxies[i], out var subnet))
|
2022-07-20 09:48:20 +02:00
|
|
|
{
|
2023-08-22 21:14:54 +02:00
|
|
|
if (subnet is not null)
|
2022-07-20 09:48:20 +02:00
|
|
|
{
|
2023-02-17 19:27:36 +01:00
|
|
|
AddIPAddress(config, options, subnet.Prefix, subnet.PrefixLength);
|
2022-07-20 09:48:20 +02:00
|
|
|
}
|
|
|
|
}
|
2023-11-10 16:59:45 +01:00
|
|
|
else if (NetworkUtils.TryParseHost(allowedProxies[i], out var addresses, config.EnableIPv4, config.EnableIPv6))
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2022-07-21 22:09:54 +02:00
|
|
|
foreach (var address in addresses)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2023-11-10 16:49:40 +01:00
|
|
|
AddIPAddress(config, options, address, address.AddressFamily == AddressFamily.InterNetwork ? NetworkConstants.MinimumIPv4PrefixSize : NetworkConstants.MinimumIPv6PrefixSize);
|
2021-01-19 11:36:37 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-17 19:27:36 +01:00
|
|
|
private static void AddIPAddress(NetworkConfiguration config, ForwardedHeadersOptions options, IPAddress addr, int prefixLength)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2023-07-03 21:51:36 +02:00
|
|
|
if (addr.IsIPv4MappedToIPv6)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
2023-07-03 21:51:36 +02:00
|
|
|
addr = addr.MapToIPv4();
|
2021-01-19 11:36:37 +01:00
|
|
|
}
|
|
|
|
|
2023-07-03 21:51:36 +02:00
|
|
|
if ((!config.EnableIPv4 && addr.AddressFamily == AddressFamily.InterNetwork) || (!config.EnableIPv6 && addr.AddressFamily == AddressFamily.InterNetworkV6))
|
2022-07-20 11:47:48 +02:00
|
|
|
{
|
2023-07-03 21:51:36 +02:00
|
|
|
return;
|
2022-07-20 11:47:48 +02:00
|
|
|
}
|
|
|
|
|
2023-11-10 16:49:40 +01:00
|
|
|
if (prefixLength == NetworkConstants.MinimumIPv4PrefixSize)
|
2021-01-19 11:36:37 +01:00
|
|
|
{
|
|
|
|
options.KnownProxies.Add(addr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
options.KnownNetworks.Add(new IPNetwork(addr, prefixLength));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-02 19:47:00 +02:00
|
|
|
private static void AddSwaggerTypeMappings(this SwaggerGenOptions options)
|
|
|
|
{
|
|
|
|
/*
|
2020-11-30 16:47:52 +01:00
|
|
|
* TODO remove when System.Text.Json properly supports non-string keys.
|
|
|
|
* Used in BaseItemDto.ImageBlurHashes
|
2020-06-02 19:47:00 +02:00
|
|
|
*/
|
|
|
|
options.MapType<Dictionary<ImageType, string>>(() =>
|
|
|
|
new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "object",
|
2020-11-30 16:47:52 +01:00
|
|
|
AdditionalProperties = new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "string"
|
|
|
|
}
|
2020-06-02 19:47:00 +02:00
|
|
|
});
|
2020-06-19 12:24:39 +02:00
|
|
|
|
2020-06-19 15:49:44 +02:00
|
|
|
/*
|
|
|
|
* Support BlurHash dictionary
|
|
|
|
*/
|
2020-06-19 12:24:39 +02:00
|
|
|
options.MapType<Dictionary<ImageType, Dictionary<string, string>>>(() =>
|
|
|
|
new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "object",
|
|
|
|
Properties = typeof(ImageType).GetEnumNames().ToDictionary(
|
|
|
|
name => name,
|
2021-08-04 14:40:09 +02:00
|
|
|
_ => new OpenApiSchema
|
2020-06-19 12:24:39 +02:00
|
|
|
{
|
2020-11-30 16:47:52 +01:00
|
|
|
Type = "object",
|
|
|
|
AdditionalProperties = new OpenApiSchema
|
2020-06-19 15:49:44 +02:00
|
|
|
{
|
2020-11-30 16:47:52 +01:00
|
|
|
Type = "string"
|
2020-06-19 15:49:44 +02:00
|
|
|
}
|
2020-06-19 12:24:39 +02:00
|
|
|
})
|
|
|
|
});
|
2021-11-13 15:29:58 +01:00
|
|
|
|
|
|
|
// Support dictionary with nullable string value.
|
|
|
|
options.MapType<Dictionary<string, string?>>(() =>
|
|
|
|
new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "object",
|
|
|
|
AdditionalProperties = new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "string",
|
|
|
|
Nullable = true
|
|
|
|
}
|
|
|
|
});
|
2022-03-23 15:32:33 +01:00
|
|
|
|
|
|
|
// Manually describe Flags enum.
|
|
|
|
options.MapType<TranscodeReason>(() =>
|
|
|
|
new OpenApiSchema
|
|
|
|
{
|
2022-10-29 04:39:00 +02:00
|
|
|
Type = "array",
|
|
|
|
Items = new OpenApiSchema
|
|
|
|
{
|
|
|
|
Reference = new OpenApiReference
|
|
|
|
{
|
|
|
|
Id = nameof(TranscodeReason),
|
|
|
|
Type = ReferenceType.Schema,
|
|
|
|
}
|
|
|
|
}
|
2022-03-23 15:32:33 +01:00
|
|
|
});
|
2022-05-21 16:59:24 +02:00
|
|
|
|
|
|
|
// Swashbuckle doesn't use JsonOptions to describe responses, so we need to manually describe it.
|
|
|
|
options.MapType<Version>(() => new OpenApiSchema
|
|
|
|
{
|
|
|
|
Type = "string"
|
|
|
|
});
|
2020-06-02 19:47:00 +02:00
|
|
|
}
|
2019-11-23 19:43:30 +01:00
|
|
|
}
|
|
|
|
}
|