HttpServer.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
{
#if SC_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
struct SC_COMPILER_EXPORT HttpServer;
struct SC_COMPILER_EXPORT HttpServerClient;
namespace detail
{
struct SC_COMPILER_EXPORT HttpHeaderOffset
{
    HttpParser::Token token = HttpParser::Token::Method;
 
    uint32_t start  = 0;
    uint32_t length = 0;
};
} // namespace detail
 
 
struct SC_COMPILER_EXPORT HttpRequest
{
    [[nodiscard]] bool find(HttpParser::Token token, StringSpan& res) const;
 
    const HttpParser& getParser() const { return parser; }
 
    StringSpan getURL() const { return url; }
 
    void reset();
 
    Result parse(const uint32_t maxHeaderSize, Span<const char> readData);
 
  private:
    friend struct HttpServer;
    friend struct HttpAsyncServer;
    using HttpHeaderOffset = detail::HttpHeaderOffset;
 
    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 HttpServer;
    friend struct HttpAsyncServer;
 
    Span<char> responseHeaders;
    size_t     responseHeadersCapacity = 0;
 
    bool headersSent = false;
 
    AsyncWritableStream* writableStream = nullptr;
};
 
struct SC_COMPILER_EXPORT HttpServerClient
{
    HttpServerClient();
 
    void reset()
    {
        request.reset();
        response.reset();
        state = State::Free;
    }
 
    HttpRequest  request;
    HttpResponse response;
 
  private:
    enum class State
    {
        Free,
        Used
    };
    friend struct HttpServer;
    friend struct HttpAsyncServer;
    char debugName[16] = {0};
 
    State  state = State::Free;
    size_t index = 0;
 
    ReadableSocketStream readableSocketStream;
    WritableSocketStream writableSocketStream;
 
    SocketDescriptor socket;
};
#if !DOXYGEN
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Function<void(HttpRequest&, HttpResponse&)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Span<HttpServerClient>;
#endif
struct SC_COMPILER_EXPORT HttpServer
{
    struct Memory
    {
        IGrowableBuffer& headersMemory;
 
        Span<HttpServerClient> clients;
    };
    Result start(Memory& memory);
 
    Function<void(HttpRequest&, HttpResponse&)> onRequest;
 
    Span<HttpServerClient> clients;
 
    [[nodiscard]] size_t getNumClients() const { return numClients; }
 
    [[nodiscard]] bool canAcceptMoreClients() const { return numClients < clients.sizeInElements(); }
    [[nodiscard]] bool allocateClient(size_t& idx);
    [[nodiscard]] bool deallocateClient(HttpServerClient& client);
 
    uint32_t maxHeaderSize = 8 * 1024;
 
  private:
    void closeAsync(HttpServerClient& requestClient);
 
    IGrowableBuffer* headersMemory = nullptr;
    size_t           numClients    = 0;
};
#if SC_COMPILER_MSVC
#pragma warning(pop)
#endif
 
} // namespace SC