FunctionProxy.cs

using System.Net;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Microsoft.Net.Http.Headers;

namespace FunctionProxy;

public sealed class ProxyFunction
{
    private const string TargetBaseUrl = "https://github.com/osysltd/";

    private static readonly (string Source, string Target)[] Replacements =
    [
        ("/source.html", "/target.html")
    ];

    private readonly ILogger<ProxyFunction> _logger;
    private readonly bool _debug;
    private readonly string? _userAgent;

    public ProxyFunction(ILogger<ProxyFunction> logger)
    {
        _logger = logger;
        _debug = bool.TryParse(Environment.GetEnvironmentVariable("debug"), out var debug) && debug;
        _userAgent = Environment.GetEnvironmentVariable("UserAgent");
    }

    // Azure Functions substitutes the function name for an empty route, so this constraint matches only the root path.
    [Function("RootRedirect")]
    public IActionResult RedirectToRunApp(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "{ignored:maxlength(0)?}")] HttpRequest request,
        string? ignored)
    {
        return new RedirectResult("/api/runapp", permanent: true);
    }

    [Function("RunApp")]
    public async Task<ProxyOutput> RunAsync(
        [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", "put", Route = "api/runapp")] HttpRequest request,
        CancellationToken cancellationToken)
    {
        var requestEncoding = ResolveEncoding(request.ContentType);
        var requestMediaType = ResolveMediaType(request.ContentType);

        using var reader = new StreamReader(
            request.Body,
            requestEncoding,
            detectEncodingFromByteOrderMarks: true,
            leaveOpen: true);

        var requestBody = await reader.ReadToEndAsync(cancellationToken);
        var targetUri = new Uri(TargetBaseUrl + request.QueryString);

        if (_debug)
        {
            _logger.LogInformation("Incoming request query: {QueryString}", request.QueryString.Value);
            _logger.LogInformation("Incoming request body: {RequestBody}", requestBody);
            _logger.LogInformation("Proxy requested URL: {TargetUri}", targetUri);
        }

        var queueMessage = requestBody.Length > 0
            ? $"[{request.Host}] {WebUtility.UrlDecode(requestBody)}"
            : null;

        using var handler = new HttpClientHandler
        {
            CookieContainer = new CookieContainer()
        };
        using var client = new HttpClient(handler);

        if (!string.IsNullOrWhiteSpace(_userAgent))
        {
            client.DefaultRequestHeaders.TryAddWithoutValidation(HeaderNames.UserAgent, _userAgent);
        }

        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(requestMediaType));
        client.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue { NoCache = true };

        foreach (var cookie in request.Cookies)
        {
            if (!cookie.Key.Equals("referer", StringComparison.Ordinal))
            {
                handler.CookieContainer.Add(
                    targetUri,
                    new Cookie(cookie.Key, WebUtility.UrlEncode(cookie.Value) ?? string.Empty));
            }
            else
            {
                client.DefaultRequestHeaders.TryAddWithoutValidation(HeaderNames.Referer, cookie.Value);
            }
        }

        using var upstreamResponse = await SendUpstreamAsync(
            client,
            request.Method,
            targetUri,
            requestBody,
            requestEncoding,
            requestMediaType,
            cancellationToken);

        var referer = upstreamResponse.RequestMessage?.RequestUri?.ToString() ?? targetUri.ToString();
        var resultContent = await upstreamResponse.Content.ReadAsStringAsync(cancellationToken);
        var proxyAddress = $"{request.Scheme}://{request.Host}".ToLowerInvariant();

        foreach (var replacement in Replacements)
        {
            resultContent = resultContent.Replace(
                replacement.Source,
                replacement.Target.Replace("<addr>", proxyAddress, StringComparison.Ordinal),
                StringComparison.Ordinal);
        }

        AppendResponseCookies(
            request.HttpContext.Response,
            handler.CookieContainer,
            targetUri,
            referer);

        return new ProxyOutput
        {
            Result = new ContentResult
            {
                StatusCode = (int)upstreamResponse.StatusCode,
                Content = resultContent,
                ContentType = upstreamResponse.Content.Headers.ContentType?.ToString()
            },
            QueueMessage = queueMessage
        };
    }

    private async Task<HttpResponseMessage> SendUpstreamAsync(
        HttpClient client,
        string method,
        Uri targetUri,
        string requestBody,
        Encoding requestEncoding,
        string requestMediaType,
        CancellationToken cancellationToken)
    {
        switch (method)
        {
            case "POST":
                return await client.PostAsync(
                    targetUri,
                    new StringContent(requestBody, requestEncoding, requestMediaType),
                    cancellationToken);

            case "PUT":
                return await client.PutAsync(
                    targetUri,
                    new StringContent(requestBody, requestEncoding, requestMediaType),
                    cancellationToken);

            default:
                return await client.GetAsync(targetUri, cancellationToken);
        }
    }

    private Encoding ResolveEncoding(string? contentType)
    {
        const string defaultCharset = "utf-8";
        var charset = defaultCharset;

        if (!string.IsNullOrEmpty(contentType))
        {
            foreach (var segment in contentType.Split(';', StringSplitOptions.TrimEntries))
            {
                if (!segment.StartsWith("charset=", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                charset = segment[(segment.IndexOf('=') + 1)..].Trim().Trim('"');
                break;
            }
        }

        if (_debug)
        {
            _logger.LogInformation("Charset: {Charset}", charset);
        }

        return Encoding.GetEncoding(charset);
    }

    private string ResolveMediaType(string? contentType)
    {
        const string defaultMediaType = "text/html";
        var mediaType = defaultMediaType;

        if (!string.IsNullOrEmpty(contentType))
        {
            foreach (var segment in contentType.Split(';', StringSplitOptions.TrimEntries))
            {
                if (segment.StartsWith("charset=", StringComparison.OrdinalIgnoreCase) || segment.Length == 0)
                {
                    continue;
                }

                mediaType = segment.ToLowerInvariant();
                break;
            }
        }

        if (_debug)
        {
            _logger.LogInformation("Media Content-Type: {MediaType}", mediaType);
        }

        return mediaType;
    }

    private static void AppendResponseCookies(
        HttpResponse response,
        CookieContainer cookieContainer,
        Uri targetUri,
        string referer)
    {
        foreach (Cookie cookie in cookieContainer.GetCookies(targetUri))
        {
            var responseCookie = new SetCookieHeaderValue(
                cookie.Name,
                WebUtility.UrlDecode(cookie.Value) ?? string.Empty);

            if (cookie.Expires.Ticks != 0)
            {
                responseCookie.Expires = new DateTimeOffset(cookie.Expires.ToUniversalTime());
            }

            response.Headers.Append(HeaderNames.SetCookie, responseCookie.ToString());
        }

        var refererCookie = new SetCookieHeaderValue(
            "referer",
            WebUtility.UrlDecode(referer) ?? string.Empty);
        response.Headers.Append(HeaderNames.SetCookie, refererCookie.ToString());
    }

    public sealed class ProxyOutput
    {
        [HttpResult]
        public IActionResult Result { get; set; } = null!;

        [QueueOutput("queue", Connection = "AzureWebJobsStorage")]
        public string? QueueMessage { get; set; }
    }
}