HttpServer.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "HttpParser.h"
 
#include "../Async/Async.h"
#include "../Foundation/Function.h"
#include "../Foundation/StringSpan.h"
#include "../Memory/Buffer.h"
 
namespace SC
{
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();
 
  private:
    friend struct HttpServer;
    using HttpHeaderOffset = detail::HttpHeaderOffset; // TODO: hide class implementation
 
    bool headersEndReceived = false; 
    bool parsedSuccessfully = true;  
 
    HttpParser parser; 
    StringSpan url;    
 
    Span<char> readHeaders;
    Span<char> availableHeader; 
 
    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 write(Span<const char> data);
 
    Result end(Span<const char> data);
    Result end();
 
    void reset()
    {
        responseEnded = false;
        outputBuffer.clear();
    }
 
  private:
    friend struct HttpServer;
    [[nodiscard]] bool mustBeFlushed() const { return responseEnded or outputBuffer.size() > highwaterMark; }
 
    HttpServer* server = nullptr;
 
    size_t key;
 
    Buffer outputBuffer;
 
    bool   responseEnded = false;
    size_t highwaterMark = 1024;
};
 
struct SC_COMPILER_EXPORT HttpServerClient
{
    enum class State
    {
        Free,
        Used
    };
    State state = State::Free;
 
    HttpRequest  request;
    HttpResponse response;
 
    void setFree()
    {
        request.reset();
        response.reset();
        state = State::Free;
    }
 
    SocketDescriptor   socket;
    char               debugName[16] = {0};
    AsyncSocketReceive asyncReceive;
    AsyncSocketSend    asyncSend;
};
#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(AsyncEventLoop& loop, StringSpan address, uint16_t port, Memory& memory);
 
    Result stopAsync();
 
    Result stopSync();
 
    [[nodiscard]] bool isStarted() const { return started; }
 
    Function<void(HttpRequest&, HttpResponse&)> onRequest;
 
  private:
    void onNewClient(AsyncSocketAccept::Result& result);
    void onReceive(AsyncSocketReceive::Result& result);
    void onAfterSend(AsyncSocketSend::Result& result);
    void closeAsync(HttpServerClient& requestClient);
 
    Result parse(HttpRequest& request, const uint32_t maxHeaderSize, Span<const char> readData);
 
    IGrowableBuffer* headersMemory = nullptr;
 
    Span<HttpServerClient> clients;
    size_t                 numClients = 0;
 
    SocketDescriptor  serverSocket;
    AsyncSocketAccept asyncServerAccept;
 
    uint32_t maxHeaderSize = 8 * 1024;
 
    bool started  = false;
    bool stopping = false;
 
    AsyncEventLoop* eventLoop = nullptr;
};
 
} // namespace SC