ByteSequenceHttpParser.cs

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using MiniWebServer.Abstractions.Http;
using MiniWebServer.Server.Abstractions.Parsers.Http11;
using System.Buffers;
using System.Text;
using HttpMethod = MiniWebServer.Abstractions.Http.HttpMethod;

namespace MiniWebServer.HttpParser.Http11
{
    // we will migrate code to this, working on RegEx is much slower and also hard to keep it safe (because we cannot control what clients send to us)
    public class ByteSequenceHttpParser : IHttpComponentParser
    {
        private readonly ILogger<ByteSequenceHttpParser> logger;
        private static readonly Dictionary<HttpMethod, byte[]> supportedMethodBytes = new() {
            {
                HttpMethod.Get,
                Encoding.ASCII.GetBytes("GET")
            },
            {
                HttpMethod.Post,
                Encoding.ASCII.GetBytes("POST")
            },
            {
                HttpMethod.Head,
                Encoding.ASCII.GetBytes("HEAD")
            },
            {
                HttpMethod.Put,
                Encoding.ASCII.GetBytes("PUT")
            },
            {
                HttpMethod.Delete,
                Encoding.ASCII.GetBytes("DELETE")
            },
            {
                HttpMethod.Connect,
                Encoding.ASCII.GetBytes("CONNECT")
            },
            {
                HttpMethod.Options,
                Encoding.ASCII.GetBytes("OPTIONS")
            },
            {
                HttpMethod.Trace,
                Encoding.ASCII.GetBytes("TRACE")
            }
        };
        private static readonly byte[] HTTP1_1_Bytes = Encoding.ASCII.GetBytes("HTTP/1.1");
        private static readonly byte[] HTTP1_1_CR_Bytes = Encoding.ASCII.GetBytes("HTTP/1.1\r");
        private readonly int maxUrlPartLength;

        public ByteSequenceHttpParser(ILoggerFactory? loggerFactory = default, int maxUrlPartLength = -1)
        {
            // note that maxUrlPartLength includes all url parts (url, hash, query string)
            if (loggerFactory != null)
            {
                logger = loggerFactory.CreateLogger<ByteSequenceHttpParser>();
            }
            else
            {
                logger = new NullLogger<ByteSequenceHttpParser>();
            }

            this.maxUrlPartLength = maxUrlPartLength <= 0 ? 8192 : maxUrlPartLength; // 8192 = 8KB
        }

        // in any case, if this function returns null, server should return a 400 Bad Request
        public virtual HttpRequestLine? ParseRequestLine(ReadOnlySequence<byte> buffer)
        {
            SequencePosition? pos = buffer.PositionOf((byte)' '); // there are 2 SPs in a request line

            if (pos.HasValue)
            {
                HttpMethod? httpMethod = null;
                var methodBytes = buffer.Slice(0, pos.Value);
                if (methodBytes.Length < 3)
                {
                    logger.LogDebug("Method too short");
                    return null;
                }
                else if (methodBytes.Length > 7)
                {
                    logger.LogDebug("Method too long");
                    return null;
                }

                var span = methodBytes.FirstSpan;
                foreach (var supportedHeader in supportedMethodBytes)
                {
                    if (span.SequenceCompareTo(supportedHeader.Value) == 0)
                    {
                        httpMethod = supportedHeader.Key;
                        break;
                    }
                }
                if (httpMethod == null)
                {
                    logger.LogDebug("Not supported method");
                    return null;
                }

                buffer = buffer.Slice(buffer.GetPosition(1, pos.Value));

                // start parsing Url
                pos = buffer.PositionOf((byte)' '); // find the next SP
                if (!pos.HasValue)
                {
                    logger.LogDebug("2nd SP required");
                    return null;
                }

                if (buffer.Length > maxUrlPartLength + 11) // 11 = length of SP HTTP/1.1 CR LF
                {
                    logger.LogDebug("Url part too long");
                    return null;
                }

                if (TryParseUrl(buffer.Slice(0, pos.Value), out string? url, out string? hash, out string? queryString, out string[]? segments, out HttpParameters? parameters) && !string.IsNullOrEmpty(url)) // url cannot be missing
                {
                    buffer = buffer.Slice(buffer.GetPosition(1, pos.Value));

                    // remove last CR
                    var ba = buffer.ToArray();
                    if (HTTP1_1_CR_Bytes.SequenceEqual(ba) || HTTP1_1_Bytes.SequenceEqual(ba)) // todo: can we use memory pool instead of ToArray?
                    {
                        HttpRequestLine requestLine = new(
                            httpMethod,
                            url,
                            hash ?? string.Empty,
                            queryString ?? string.Empty,
                            new HttpProtocolVersion("1", "1"),
                            segments ?? [],
                            parameters ?? []
                            );

                        return requestLine;
                    }
                    else
                    {
                        logger.LogDebug("HTTP version not supported");
                        return null;
                    }
                }
                else
                {
                    return null;
                }
            }
            else
            {
                logger.LogDebug("1st SP not found");
                return null;
            }
        }

        public virtual HttpHeaderLine? ParseHeaderLine(ReadOnlySequence<byte> buffer)
        {
            SequencePosition? pos = buffer.PositionOf((byte)':'); // there are 2 SPs in a request line

            if (pos.HasValue)
            {
                var headerNameBuffer = buffer.Slice(0, pos.Value);
                var headerValue = string.Empty;

                buffer = buffer.Slice(buffer.GetPosition(1, pos.Value));
                if (!buffer.IsEmpty)
                {
                    if (buffer.FirstSpan[0] == ' ') // since buffer is not empty, we always have at least 1 byte 
                    {
                        buffer = buffer.Slice(buffer.GetPosition(1)); // take the part after ' '
                    }
                }

                if (!buffer.IsEmpty)
                {
                    headerValue = Encoding.ASCII.GetString(buffer).Replace("\r", ""); // todo: find a way to replace before GetString()
                }

                return new HttpHeaderLine(Encoding.ASCII.GetString(headerNameBuffer), headerValue);
            }

            return null;
        }

        private static bool TryParseUrl(ReadOnlySequence<byte> readOnlySequence, out string? url, out string? hash, out string? queryString, out string[]? segments, out HttpParameters? parameters)
        {
            var s = "https://f" + Encoding.ASCII.GetString(readOnlySequence); // hack: add a faked scheme and host to make it an absolute uri
            var uri = new Uri(s);

            if (uri.AbsolutePath.Contains(".."))
            {
                url = null;
                hash = null;
                queryString = null;
                segments = null;
                parameters = null;

                return false;
            }

            url = uri.AbsolutePath;
            hash = uri.Fragment;
            queryString = Uri.UnescapeDataString(uri.Query);
            segments = uri.Segments;

            if (TryParseParameters(queryString, out HttpParameters? ps) && ps != null)
            {
                parameters = ps;
            }
            else
            {
                parameters = null;
                return false;
            }

            return true;
        }

        private static bool TryParseParameters(string queryString, out HttpParameters? parameters)
        {
            ArgumentNullException.ThrowIfNull(queryString);

            var query = queryString.AsMemory();
            if (!query.IsEmpty && query.Span[0] == '?') // remove first ?
                query = query[1..];

            parameters = [];

            while (!query.IsEmpty)
            {
                var ampIdx = query.Span.IndexOf('&');
                ReadOnlyMemory<char> segment;

                if (ampIdx == -1)
                {
                    // this is the only parameter left
                    segment = query;
                    query = default;
                }
                else
                {
                    segment = query[..ampIdx];
                    query = query[(ampIdx + 1)..];
                }

                var equalIdx = segment.Span.IndexOf('=');
                if (equalIdx == -1)
                {
                    if (!segment.IsEmpty)
                    {
                        parameters.Add(new HttpParameter(new string(segment.Span), string.Empty));
                    }
                }
                else
                {
                    var name = segment[..equalIdx];
                    var value = segment[(equalIdx + 1)..];

                    parameters.Add(new HttpParameter(new string(name.Span), new string(value.Span)));
                }
            }

            return true;
        }
    }
}