ApiHeaders.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Http.Headers;
using System.Reflection;
using Microsoft.AspNetCore.Http.Headers;
using Microsoft.Net.Http.Headers;
using Microsoft.Extensions.Primitives;

namespace Tgstation.Server.Api
{
    public sealed class ApiHeaders
    {
        public const string ApplicationJson = "application/json";

        const string ApiVersionHeader = "Api";

        const string usernameHeader = "Username";

        const string instanceIdHeader = "Instance";

        const string jwtAuthenticationScheme = "Bearer";

        const string passwordAuthenticationScheme = "Password";

        static readonly AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();

        public static Version Version => assemblyName.Version;

        public long? InstanceId { get; set; }

        public ProductHeaderValue UserAgent { get; }

        public Version ApiVersion { get; }

        public string Token { get; }

        public string Username { get; }

        public string Password { get; }

        public bool IsTokenAuthentication => Token != null;

        public static bool CheckCompatibility(Version otherVersion) => !(Version.Major != otherVersion.Major || Version.Minor != otherVersion.Minor || Version.Build > otherVersion.Build);

        public ApiHeaders(ProductHeaderValue userAgent, string token) : this(userAgent, token, null, null)
        {
            if (userAgent == null)
                throw new ArgumentNullException(nameof(userAgent));
            if (token == null)
                throw new ArgumentNullException(nameof(token));
        }

        public ApiHeaders(ProductHeaderValue userAgent, string username, string password) : this(userAgent, null, username, password)
        {
            if (userAgent == null)
                throw new ArgumentNullException(nameof(userAgent));
            if (username == null)
                throw new ArgumentNullException(nameof(username));
            if (password == null)
                throw new ArgumentNullException(nameof(password));
        }

        public ApiHeaders(RequestHeaders requestHeaders)
        {
            var jsonAccept = new Microsoft.Net.Http.Headers.MediaTypeHeaderValue(ApplicationJson);
            if (!requestHeaders.Accept.Any(x => x.MediaType == jsonAccept.MediaType))
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Client does not accept {0}!", ApplicationJson));

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.UserAgent, out var userAgentValues) || !ProductInfoHeaderValue.TryParse(userAgentValues.FirstOrDefault(), out var clientUserAgent))
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Missing {0} headers!", HeaderNames.UserAgent));

            //assure the client user agent has a name and version
            if (String.IsNullOrWhiteSpace(clientUserAgent.Product.Name) || !Version.TryParse(clientUserAgent.Product.Version, out var clientVersion))
                throw new InvalidOperationException("Malformed client user agent!");

            //make sure the api header matches ours
            if (!requestHeaders.Headers.TryGetValue(ApiVersionHeader, out var apiUserAgentHeaderValues) || !ProductInfoHeaderValue.TryParse(apiUserAgentHeaderValues.FirstOrDefault(), out var apiUserAgent) || apiUserAgent.Product.Name != assemblyName.Name)
                throw new InvalidOperationException("Missing API version!");

            if (!Version.TryParse(apiUserAgent.Product.Version, out var apiVersion))
                throw new InvalidOperationException("Malformed API version!");

            ApiVersion = apiVersion;
            UserAgent = clientUserAgent.Product;

            if (!requestHeaders.Headers.TryGetValue(HeaderNames.Authorization, out StringValues authorization))
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Missing {0} header!", HeaderNames.Authorization));
            var auth = authorization.First();
            var splits = new List<string>(auth.Split(' '));
            var scheme = splits.First();
            if (String.IsNullOrWhiteSpace(scheme))
                throw new InvalidOperationException("Missing authentication scheme!");

            splits.RemoveAt(0);
            var parameter = String.Concat(splits);
            if (String.IsNullOrEmpty(parameter))
                throw new InvalidOperationException("Missing authentication parameter!");

            if (requestHeaders.Headers.TryGetValue(instanceIdHeader, out var instanceIdValues))
            {
                var instanceIdString = instanceIdValues.FirstOrDefault();
                if (instanceIdString != default && Int64.TryParse(instanceIdString, out var instanceId))
                    InstanceId = instanceId;
            }

            switch (scheme)
            {
                case jwtAuthenticationScheme:
                    Token = parameter;
                    break;
                case passwordAuthenticationScheme:
                    Password = parameter;
                    var fail = !requestHeaders.Headers.TryGetValue(usernameHeader, out var values);
                    if (!fail)
                    {
                        Username = values.FirstOrDefault();
                        fail = String.IsNullOrWhiteSpace(Username);
                    }
                    if (fail)
                        throw new InvalidOperationException("Missing Username header!");
                    break;
                default:
                    throw new InvalidOperationException("Invalid authentication scheme!");
            }
        }

        ApiHeaders(ProductHeaderValue userAgent, string token, string username, string password)
        {
            UserAgent = userAgent;
            Token = token;
            Username = username;
            Password = password;
            ApiVersion = Version;
        }

        public bool Compatible() => CheckCompatibility(ApiVersion);

        public void SetRequestHeaders(HttpRequestHeaders headers, long? instanceId = null)
        {
            if (headers == null)
                throw new ArgumentNullException(nameof(headers));
            if (instanceId.HasValue && InstanceId.HasValue && instanceId != InstanceId)
                throw new InvalidOperationException("Specified instance ID in constructor and SetRequestHeaders!");

            headers.Clear();
            headers.Accept.Add(new MediaTypeWithQualityHeaderValue(ApplicationJson));
            if (IsTokenAuthentication)
                headers.Authorization = new AuthenticationHeaderValue(jwtAuthenticationScheme, Token);
            else
            {
                headers.Authorization = new AuthenticationHeaderValue(passwordAuthenticationScheme, Password);
                headers.Add(usernameHeader, Username);
            }
            headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent));
            headers.Add(ApiVersionHeader, new ProductHeaderValue(assemblyName.Name, ApiVersion.ToString()).ToString());
            instanceId = instanceId ?? InstanceId;
            if (instanceId.HasValue)
                headers.Add(instanceIdHeader, instanceId.ToString());
        }
    }
}