HttpConnection.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpParser.h"
 
#include "../AsyncStreams/AsyncStreams.h"
#include "../Foundation/StringSpan.h"
 
namespace SC
{
 
struct SC_COMPILER_EXPORT HttpRequest
{
    const HttpParser& getParser() const { return parser; }
 
    StringSpan getURL() const { return url; }
 
    [[nodiscard]] bool isMultipart() const;
 
    [[nodiscard]] StringSpan getBoundary() const;
 
    [[nodiscard]] bool getHeader(StringSpan headerName, StringSpan& value) const;
 
    void reset();
 
  private:
    friend struct HttpConnectionsPool;
    friend struct HttpResponse;
    friend struct HttpAsyncServer;
 
    [[nodiscard]] bool findParserToken(HttpParser::Token token, StringSpan& res) const;
 
    Result writeHeaders(const uint32_t maxHeaderSize, Span<const char> readData, AsyncReadableStream& stream,
                        AsyncBufferView::ID bufferID);
 
    [[nodiscard]] size_t getHeadersLength() const;
 
    struct SC_COMPILER_EXPORT HttpHeaderOffset
    {
        HttpParser::Token token = HttpParser::Token::Method;
 
        uint32_t start  = 0;
        uint32_t length = 0;
    };
    Span<char> readHeaders;     
    Span<char> availableHeader; 
 
    bool headersEndReceived = false; 
    bool parsedSuccessfully = true;  
 
    HttpParser parser; 
    StringSpan url;    
 
    static constexpr size_t MaxNumHeaders = 64;
 
    HttpHeaderOffset headerOffsets[MaxNumHeaders]; 
    size_t           numHeaders = 0;
};
 
struct SC_COMPILER_EXPORT HttpResponse
{
    Result startResponse(int httpCode);
 
    Result addHeader(StringSpan headerName, StringSpan headerValue);
 
    Result sendHeaders();
 
    void reset();
 
    Result end();
 
    AsyncWritableStream& getWritableStream() { return *writableStream; }
 
    void setKeepAlive(bool keepAlive);
 
    [[nodiscard]] bool getKeepAlive() const { return forceDisableKeepAlive ? false : keepAlive; }
 
  private:
    friend struct HttpConnectionsPool;
    friend struct HttpAsyncServer;
 
    void grabUnusedHeaderMemory(HttpRequest& request);
 
    Span<char> responseHeaders;
    size_t     responseHeadersCapacity = 0;
 
    bool headersSent = false;
 
    bool forceDisableKeepAlive = false; 
    bool keepAlive             = true;  
    bool connectionHeaderAdded = false; 
 
    AsyncWritableStream* writableStream = nullptr;
};
 
struct SC_COMPILER_EXPORT HttpConnection
{
    HttpConnection();
 
    struct SC_COMPILER_EXPORT ID
    {
        size_t getIndex() const { return index; }
 
      private:
        friend struct HttpConnectionsPool;
        size_t index = 0;
    };
 
    void reset();
 
    void setHeaderMemory(Span<char> memory) { headerMemory = memory; }
 
    ID getConnectionID() const { return connectionID; }
 
    HttpRequest  request;
    HttpResponse response;
 
    AsyncBuffersPool buffersPool;
    AsyncPipeline    pipeline;
 
  protected:
    enum class State
    {
        Inactive,
        Active
    };
    friend struct HttpConnectionsPool;
    friend struct HttpAsyncServer;
 
    State state = State::Inactive;
    ID    connectionID;
 
    Span<char> headerMemory;
};
 
template <typename Type>
struct SC_COMPILER_EXPORT SpanWithStride
{
    constexpr SpanWithStride() : data(nullptr), sizeElements(0), strideInBytes(0) {}
 
    constexpr SpanWithStride(void* data, size_t sizeInElements, size_t strideInBytes)
        : data(data), sizeElements(sizeInElements), strideInBytes(strideInBytes)
    {}
 
    template <typename U>
    constexpr SpanWithStride(Span<U> span)
        : data(span.data()), sizeElements(span.sizeInElements()), strideInBytes(sizeof(U))
    {}
 
    [[nodiscard]] constexpr size_t sizeInElements() const { return sizeElements; }
    [[nodiscard]] constexpr bool   empty() const { return sizeElements == 0; }
 
    template <typename U>
    SpanWithStride<U> castTo()
    {
        return {static_cast<U*>(reinterpret_cast<Type*>(data)), sizeElements, strideInBytes};
    }
 
    [[nodiscard]] Type& operator[](size_t idx)
    {
        return *reinterpret_cast<Type*>(reinterpret_cast<char*>(data) + idx * strideInBytes);
    }
 
    [[nodiscard]] const Type& operator[](size_t idx) const
    {
        return *reinterpret_cast<const Type*>(reinterpret_cast<const char*>(data) + idx * strideInBytes);
    }
 
  private:
    void*  data;
    size_t sizeElements;
    size_t strideInBytes;
};
 
struct SC_COMPILER_EXPORT HttpConnectionsPool
{
    Result init(SpanWithStride<HttpConnection> connectionsStorage);
 
    Result close();
 
    [[nodiscard]] size_t getNumActiveConnections() const { return numConnections; }
 
    [[nodiscard]] size_t getNumTotalConnections() const { return connections.sizeInElements(); }
 
    [[nodiscard]] size_t getHighestActiveConnection() const { return highestActiveConnection; }
 
    [[nodiscard]] HttpConnection& getConnection(HttpConnection::ID connectionID)
    {
        return connections[connectionID.index];
    }
 
    [[nodiscard]] HttpConnection& getConnectionAt(size_t idx) { return connections[idx]; }
 
    [[nodiscard]] bool activateNew(HttpConnection::ID& connectionID);
 
    [[nodiscard]] bool deactivate(HttpConnection::ID connectionID);
 
  private:
    SpanWithStride<HttpConnection> connections;
 
    size_t numConnections          = 0;
    size_t highestActiveConnection = 0;
};
 
} // namespace SC