httpserver.h

Go to the documentation of this file.

// Copyright (c) 2015-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_HTTPSERVER_H
#define BITCOIN_HTTPSERVER_H
 
#include <atomic>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <netaddress.h>
#include <rpc/protocol.h>
#include <util/byte_units.h>
#include <util/expected.h>
#include <util/sock.h>
#include <util/strencodings.h>
#include <util/string.h>
#include <util/threadinterrupt.h>
#include <util/time.h>
 
namespace util {
class SignalInterrupt;
} // namespace util
 
inline constexpr int DEFAULT_HTTP_THREADS=16;
 
inline constexpr int DEFAULT_HTTP_WORKQUEUE=64;
 
inline constexpr int DEFAULT_HTTP_SERVER_TIMEOUT=30;
 
inline constexpr int DEFAULT_MAX_HTTP_CONNECTIONS = 16;
 
enum class HTTPRequestMethod {
    UNKNOWN,
    GET,
    POST,
    HEAD,
    PUT
};
 
class HTTPRequest;
 
using HTTPRequestHandler = std::function<void(HTTPRequest* req, const std::string&)>;
 
void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler);
void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch);
 
namespace bitcoin_http {
inline constexpr size_t MIN_REQUEST_LINE_LENGTH = std::string_view("GET / HTTP/1.0").size();
 
inline constexpr size_t MAX_HEADERS_SIZE{8192};
 
inline constexpr uint64_t MAX_BODY_SIZE{32_MiB};
 
struct ContentTooLargeError : std::runtime_error {
    using std::runtime_error::runtime_error;
};
} // namespace bitcoin_http
 
class HTTPHeaders
{
public:
    std::optional<std::string> FindFirst(std::string_view key) const;
    std::vector<std::string_view> FindAll(std::string_view key) const LIFETIMEBOUND;
    void Write(std::string&& key, std::string&& value);
    void RemoveAll(std::string_view key);
    bool Read(util::LineReader& reader, bool write = true);
    std::string Stringify() const;
 
private:
    std::vector<std::pair<std::string, std::string>> m_headers;
 
    size_t m_consumed{0};
};
 
struct HTTPVersion {
    uint8_t major{1};
    uint8_t minor{1};
};
 
struct HTTPResponse {
    HTTPVersion version;
    HTTPStatusCode status{HTTP_INTERNAL_SERVER_ERROR};
    HTTPHeaders headers;
 
    std::string StringifyHeaders() const;
};
 
class HTTPRemoteClient;
 
class HTTPRequest
{
public:
    explicit HTTPRequest(const std::shared_ptr<HTTPRemoteClient>& client) : m_client{client} {}
    explicit HTTPRequest() : m_client{} {}
 
    bool LoadControlData(util::LineReader& reader);
    bool LoadHeaders(util::LineReader& reader);
    bool LoadBody(util::LineReader& reader);
 
    void WriteReply(HTTPStatusCode status, std::span<const std::byte> reply_body = {});
    void WriteReply(HTTPStatusCode status, std::string_view reply_body_view)
    {
        WriteReply(status, std::as_bytes(std::span{reply_body_view}));
    }
 
    const HTTPVersion& GetVersion() const LIFETIMEBOUND { return m_version; }
    std::shared_ptr<HTTPRemoteClient> GetClient() const { return m_client.lock(); }
 
    // These methods reimplement the API from http_libevent::HTTPRequest
    // for downstream JSONRPC and REST modules.
    std::string GetURI() const { return m_target; }
    CService GetPeer() const;
    HTTPRequestMethod GetRequestMethod() const { return m_method; }
    std::optional<std::string> GetQueryParameter(std::string_view key) const;
    std::optional<std::string> GetHeader(std::string_view hdr) const;
    std::string ReadBody() const { return m_body; }
    void WriteHeader(std::string&& hdr, std::string&& value);
    std::optional<uint64_t> GetChunkSize() const { return m_chunk_size; }
    uint64_t GetChunkProgress() const { return m_chunk_read; }
 
    enum class State {
        Init,
        NeedsHeaders,
        NeedsBody,
        Complete,
        Error
    };
    State GetState() const { return m_state; }
    void SetState(State state) { m_state = state; }
 
private:
    HTTPRequestMethod m_method;
    std::string m_target;
    HTTPVersion m_version;
    HTTPHeaders m_headers;
    std::string m_body;
 
    std::weak_ptr<HTTPRemoteClient> m_client;
 
    HTTPHeaders m_response_headers;
 
    // If a large request is sent with "Transfer-encoding: chunked" we may
    // read the chunk size in a separate I/O loop iteration than the chunk
    // of data itself. Store the chunk size value here until the chunk is read.
    std::optional<uint64_t> m_chunk_size;
    // We may also read a large chunk over multiple loop iterations.
    // Track the progress of the chunk here.
    uint64_t m_chunk_read{0};
 
    State m_state = State::Init;
};
 
class HTTPServer
{
public:
    using Id = uint64_t;
 
    explicit HTTPServer(std::function<void(std::unique_ptr<HTTPRequest>&&)> func)
        : m_request_dispatcher{std::move(func)} {}
 
    virtual ~HTTPServer()
    {
        Assume(!m_thread_socket_handler.joinable()); // Missing call to JoinSocketsThreads()
        Assume(m_connected.empty()); // Missing call to DisconnectClients(), or disconnect flags not set
        Assume(m_listen.empty()); // Missing call to StopListening()
    }
 
    bool InitHTTPAllowList();
 
    util::Expected<void, std::string> BindAndStartListening(const CService& to);
 
    void StopListening();
 
    size_t GetListeningSocketCount() const { return m_listen.size(); }
 
    size_t GetConnectionsCount() const { return m_connected_size.load(std::memory_order_acquire); }
 
    void StartSocketsThreads();
 
    void JoinSocketsThreads();
 
    void InterruptNet() { m_interrupt_net(); }
 
    void DisconnectAllClients() { m_disconnect_all_clients = true; }
 
    void SetRequestHandler(std::function<void(std::unique_ptr<HTTPRequest>&&)> func)
        EXCLUSIVE_LOCKS_REQUIRED(!m_request_dispatcher_mutex)
    {
        WITH_LOCK(m_request_dispatcher_mutex,
                  m_request_dispatcher = std::move(func));
    }
 
    void StopAccepting() { m_stop_accepting = true; }
 
    void SetServerTimeout(std::chrono::seconds seconds) { m_rpcservertimeout = seconds; }
 
    void SetMaxConnections(int max_conn) { m_rpcmaxconnections = max_conn; }
 
    void ClearConnectedClients();
 
private:
    std::vector<std::shared_ptr<Sock>> m_listen;
 
    std::atomic<Id> m_next_id{0};
 
    std::vector<std::shared_ptr<HTTPRemoteClient>> m_connected;
 
    std::atomic_bool m_stop_accepting{false};
 
    std::atomic_bool m_disconnect_all_clients{false};
 
    std::atomic<size_t> m_connected_size{0};
 
    struct IOReadiness {
        Sock::EventsPerSock events_per_sock;
 
        std::unordered_map<Sock::EventsPerSock::key_type,
                           std::shared_ptr<HTTPRemoteClient>,
                           Sock::HashSharedPtrSock,
                           Sock::EqualSharedPtrSock>
            httpclients_per_sock;
    };
 
    CThreadInterrupt m_interrupt_net;
 
    std::thread m_thread_socket_handler;
 
    /*
     * What to do with HTTP requests once received, validated and parsed.
     * Set in main thread by server start and interrupt but read in
     * worker threads.
     */
    mutable Mutex m_request_dispatcher_mutex;
    std::function<void(std::unique_ptr<HTTPRequest>&&)> m_request_dispatcher GUARDED_BY(m_request_dispatcher_mutex);
 
    std::chrono::seconds m_rpcservertimeout{DEFAULT_HTTP_SERVER_TIMEOUT};
 
    std::vector<CSubNet> m_allow_subnets;
 
    bool ClientAllowed(const CNetAddr& netaddr) const;
 
    int m_rpcmaxconnections{DEFAULT_MAX_HTTP_CONNECTIONS};
 
    std::unique_ptr<Sock> AcceptConnection(const Sock& listen_sock, CService& addr);
 
    Id GetNewId();
 
    void NewSockAccepted(std::unique_ptr<Sock>&& sock, const CService& addr);
 
    void SocketHandlerConnected(const IOReadiness& io_readiness) const
        EXCLUSIVE_LOCKS_REQUIRED(!m_request_dispatcher_mutex);
 
    void SocketHandlerListening(const Sock::EventsPerSock& events_per_sock);
 
    IOReadiness GenerateWaitSockets() const;
 
    void ThreadSocketHandler() EXCLUSIVE_LOCKS_REQUIRED(!m_request_dispatcher_mutex);
 
    void DisconnectClients();
};
 
std::optional<std::string> GetQueryParameterFromUri(std::string_view uri, std::string_view key);
 
class HTTPRemoteClient
{
public:
    explicit HTTPRemoteClient(HTTPServer::Id id, const CService& addr, std::unique_ptr<Sock> socket)
        : m_id(id), m_addr(addr), m_origin(addr.ToStringAddrPort()), m_sock{std::move(socket)}, m_idle_since{Now<SteadySeconds>()} {}
 
    // Disable copies (should only be used as shared pointers)
    HTTPRemoteClient(const HTTPRemoteClient&) = delete;
    HTTPRemoteClient& operator=(const HTTPRemoteClient&) = delete;
 
    const std::string& GetOrigin() const LIFETIMEBOUND { return m_origin; }
    const CService& GetPeer() const LIFETIMEBOUND { return m_addr; }
    std::shared_ptr<Sock> GetSock() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex) { return WITH_LOCK(m_sock_mutex, return m_sock;); }
    bool ReadyToSend() const EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex) { return WITH_LOCK(m_send_mutex, return m_send_ready;); }
    bool ReceiveBufferEmpty() const { return m_recv_buffer.empty(); }
 
    void Send(const HTTPResponse& res, std::span<const std::byte> reply_body, bool keep_alive) EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex, !m_sock_mutex);
    void Receive() EXCLUSIVE_LOCKS_REQUIRED(!m_sock_mutex);
 
    bool MaybeDisconnect(std::chrono::time_point<SteadyClock> now, std::chrono::seconds rpcservertimeout, bool disconnect_all);
 
    static std::unique_ptr<HTTPRequest> TryReadRequest(const std::shared_ptr<HTTPRemoteClient>& client) EXCLUSIVE_LOCKS_REQUIRED(!client->m_send_mutex);
 
    bool MaybeSendBytesFromBuffer() EXCLUSIVE_LOCKS_REQUIRED(!m_send_mutex, !m_sock_mutex);
 
    const HTTPRequest* GetRequest() const LIFETIMEBOUND { return m_req.get(); }
 
    const std::string& GetRecvBuffer() const LIFETIMEBOUND { return m_recv_buffer; }
 
protected:
    std::string& MutateRecvBuffer() { return m_recv_buffer; }
 
private:
    void ReadRequest(HTTPRequest& req);
 
    const HTTPServer::Id m_id;
 
    const CService m_addr;
 
    const std::string m_origin;
 
    std::string m_recv_buffer{};
 
    std::unique_ptr<HTTPRequest> m_req;
 
    std::atomic_bool m_req_busy{false};
 
    mutable Mutex m_send_mutex;
    std::vector<std::byte> m_send_buffer GUARDED_BY(m_send_mutex);
 
    bool m_send_ready GUARDED_BY(m_send_mutex){false};
 
    Mutex m_sock_mutex;
 
    std::shared_ptr<Sock> m_sock GUARDED_BY(m_sock_mutex);
 
    std::atomic_bool m_connection_busy{true};
 
    std::atomic_bool m_keep_alive{false};
 
    std::atomic_bool m_disconnect{false};
 
    std::atomic<SteadySeconds> m_idle_since;
};
 
bool InitHTTPServer();
 
void StartHTTPServer();
 
void InterruptHTTPServer();
 
void StopHTTPServer();
 
#endif // BITCOIN_HTTPSERVER_H