HttpConnection.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpParser.h"
 
#include "../Async/Async.h"
#include "../AsyncStreams/AsyncRequestStreams.h"
#include "../Foundation/Function.h"
#include "../Foundation/StringSpan.h"
 
namespace SC
{
 
struct SC_COMPILER_EXPORT HttpRequest
{
    const HttpParser& getParser() const { return parser; }
 
    StringSpan getURL() const { return url; }
 
    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);
 
    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; }
 
  private:
    friend struct HttpConnectionsPool;
    friend struct HttpAsyncServer;
 
    void grabUnusedHeaderMemory(HttpRequest& request);
 
    Span<char> responseHeaders;
    size_t     responseHeadersCapacity = 0;
 
    bool headersSent = 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();
 
    ID getConnectionID() const { return connectionID; }
 
    HttpRequest  request;
    HttpResponse response;
 
  private:
    enum class State
    {
        Inactive,
        Active
    };
    friend struct HttpConnectionsPool;
    friend struct HttpAsyncServer;
 
    State state = State::Inactive;
    ID    connectionID;
 
    ReadableSocketStream readableSocketStream;
    WritableSocketStream writableSocketStream;
 
    SocketDescriptor socket;
};
 
struct SC_COMPILER_EXPORT HttpConnectionsPool
{
    Result init(Span<HttpConnection> connectionsStorage, Span<char> headersMemoryStorage);
 
    Result close();
 
    [[nodiscard]] size_t getNumActiveConnections() const { return numConnections; }
 
    [[nodiscard]] size_t getNumTotalConnections() const { return connections.sizeInElements(); }
 
    [[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:
    Span<HttpConnection> connections;
    Span<char>           headersMemory;
 
    size_t numConnections = 0;
};
 
} // namespace SC