Replace libevent with our own HTTP and socket-handling implementation #32061

391+        LogPrintf("connection from %s dropped: non-selectable socket\n", them.ToStringAddrPort());
392+        return;
393+    }
394+
395+    // According to the internet TCP_NODELAY is not carried into accepted sockets
396+    // on all platforms.  Set it again here just to be sure.

118@@ -116,6 +119,20 @@ std::optional<int64_t> ParseISO8601DateTime(std::string_view str)
119     return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
120 }
121 
122+std::string FormatRFC7231DateTime(int64_t nTime)
123+{
124+    const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
125+    const auto days{std::chrono::floor<std::chrono::days>(secs)};
126+    // 1970-01-01 was a Thursday
127+    std::string weekday{weekdays[(days.time_since_epoch().count() + 4) % 7]};

496@@ -497,3 +497,10 @@ std::optional<uint64_t> ParseByteUnits(std::string_view str, ByteUnit default_mu
497     }
498     return *parsed_num * unit_amount;
499 }
500+
501+std::vector<std::byte> StringToBuffer(const std::string& str)
502+{
503+    return std::vector<std::byte>(

25+
26+    auto line_start = it;
27+    std::string line{};
28+    while (it != end) {
29+        char c = static_cast<char>(*it);
30+        line += c;

31+        ++it;
32+        if (c == '\n') break;
33+        if ((size_t)std::distance(line_start, it) >= max_read) throw std::runtime_error("max_read exceeded by LineReader");
34+    }
35+
36+    line = TrimString(line); // delete trailing \r and/or \n

40+// Ignores max_read but won't overflow
41+std::string LineReader::ReadLength(size_t len)
42+{
43+    if (len == 0) return "";
44+    if (Left() < len) throw std::runtime_error("Not enough data in buffer");
45+    std::string out(reinterpret_cast<const char*>(&(*it)), len);

780@@ -781,3 +781,69 @@ void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
781         pathHandlers.erase(i);
782     }
783 }
784+
785+
786+namespace http_bitcoin {
787+std::optional<std::string> HTTPHeaders::Find(const std::string key) const

835+}
836+
837+std::string HTTPHeaders::Stringify() const
838+{
839+    std::string out;
840+    for (auto it = m_map.begin(); it != m_map.end(); ++it) {

915+    if (!req->LoadBody(reader)) return false;
916+
917+    // Remove the bytes read out of the buffer.
918+    // If one of the above calls throws an error, the caller must
919+    // catch it and disconnect the client.
920+    m_recv_buffer.erase(

940@@ -940,6 +941,92 @@ bool HTTPRequest::LoadBody(LineReader& reader)
941     }
942 }
943 
944+void HTTPRequest::WriteReply(HTTPStatusCode status, std::span<const std::byte> reply_body)

1009+        m_client->m_send_buffer.insert(m_client->m_send_buffer.end(), headers_bytes.begin(), headers_bytes.end());
1010+
1011+        // We've been using std::span up until now but it is finally time to copy
1012+        // data. The original data will go out of scope when WriteReply() returns.
1013+        // This is analogous to the memcpy() in libevent's evbuffer_add()
1014+        m_client->m_send_buffer.insert(m_client->m_send_buffer.end(), reply_body.begin(), reply_body.end());

270+    // Response headers may be set in advance before response body is known
271+    HTTPHeaders m_response_headers;
272+    void WriteReply(HTTPStatusCode status, std::span<const std::byte> reply_body = {});
273+    void WriteReply(HTTPStatusCode status, const char* reply_body) {
274+        auto reply_body_view = std::string_view(reply_body);
275+        std::span<const std::byte> byte_span(reinterpret_cast<const std::byte*>(reply_body_view.data()), reply_body_view.size());

170+    {
171+        auto reply_body_view = std::string_view(reply_body);
172+        std::span<const std::byte> byte_span(reinterpret_cast<const std::byte*>(reply_body_view.data()), reply_body_view.size());
173+        WriteReply(status, byte_span);
174+    }
175+    void WriteReply(HTTPStatusCode status, const std::string& reply_body)

242@@ -243,18 +243,18 @@ static bool InitHTTPAllowList()
243 }
244 
245 /** HTTP request method as string - use for logging only */
246-std::string RequestMethodString(HTTPRequest::RequestMethod m)
247+std::string RequestMethodString(HTTPRequestMethod m)

975+    if (end == std::string::npos) {
976+        end = decoded_uri.length();
977+    }
978+    const std::string query{decoded_uri.substr(start + 1, end - start - 1)};
979+    // find requested parameter in query
980+    const std::vector<std::string> params{SplitString(query, "&")};

989+        }
990+    }
991+    return std::nullopt;
992+}
993+
994+std::pair<bool, std::string> HTTPRequest::GetHeader(const std::string& hdr) const

127+        req2 += body2
128+        # Get the underlying socket from HTTP connection so we can send something unusual
129+        conn = http.client.HTTPConnection(urlNode2.hostname, urlNode2.port)
130+        conn.connect()
131+        sock = conn.sock
132+        sock.settimeout(1)

135+        sock.sendall(req2.encode("utf-8"))
136+        try:
137+            # The server should not respond to the fast, second request
138+            # until the (very) slow first request has been handled:
139+            res = sock.recv(1024)
140+            assert not res

212+        try:
213+            conn.request('GET', '/')
214+            conn.getresponse()
215+        #       macos/linux           windows
216+        except (ConnectionResetError, ConnectionAbortedError):
217+            pass

164+            b'0A' * 1000000,
165+            b'0B' * 1000000,
166+            b'0C' * 1000000,
167+            b'0D' * 1000000,
168+            b'"]}'
169+        ]

174+            url='/',
175+            body=iter(body_chunked),
176+            headers=headers_chunked,
177+            encode_chunked=True)
178+        out1 = conn.getresponse().read()
179+        assert out1 == b'{"result":"high-hash","error":null}\n'

1068+    BOOST_CHECK(!ParseUInt64Hex("", &n));
1069+    BOOST_CHECK(!ParseUInt64Hex("-1", &n));
1070+    BOOST_CHECK(!ParseUInt64Hex("10 00", &n));
1071+    BOOST_CHECK(!ParseUInt64Hex("1 ", &n));
1072+    BOOST_CHECK(!ParseUInt64Hex("0xAB", &n));
1073+}

265+    }
266+    if (out != nullptr) {
267+        *out = total;
268+    }
269+    return true;
270+}

118@@ -116,6 +119,20 @@ std::optional<int64_t> ParseISO8601DateTime(std::string_view str)
119     return int64_t{TicksSinceEpoch<std::chrono::seconds>(tp)};
120 }
121 
122+std::string FormatRFC7231DateTime(int64_t nTime)
123+{
124+    const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}};
125+    const auto days{std::chrono::floor<std::chrono::days>(secs)};
126+    // 1970-01-01 was a Thursday
127+    std::string_view weekday{weekdays[(days.time_since_epoch().count() + 4) % 7]};

327 
328-bool InitHTTPServer(const util::SignalInterrupt& interrupt)
329+namespace http_bitcoin {
330+using util::Split;
331+
332+std::optional<std::string_view> HTTPHeaders::Find(const std::string key) const

340 
341-    // Redirect libevent's logging to our own log
342-    event_set_log_callback(&libevent_log_cb);
343-    // Update libevent's log handling.
344-    UpdateHTTPServerLogging(LogInstance().WillLogCategory(BCLog::LIBEVENT));
345+void HTTPHeaders::Write(const std::string key, const std::string value)

356-#ifdef WIN32
357-    evthread_use_windows_threads();
358-#else
359-    evthread_use_pthreads();
360-#endif
361+void HTTPHeaders::Remove(const std::string key)

 96+{
 97+public:
 98+    std::optional<std::string_view> Find(const std::string key) const;
 99+    void Write(const std::string key, const std::string value);
100+    void Remove(const std::string key);
101+    bool Read(util::LineReader& reader);

19@@ -20,6 +20,20 @@ enum HTTPStatusCode
20     HTTP_SERVICE_UNAVAILABLE   = 503,
21 };
22 
23+// Copied from libevent http.c success_phrases[] and client_error_phrases[]
24+// TODO: Should HTTPStatusCode and HTTPReason be moved since they are not RPC protocols?
25+const std::map<HTTPStatusCode, std::string> HTTPReason{
26+    {HTTP_OK, "OK"},

129-private:
130-    struct evhttp_request* req;
131-    const util::SignalInterrupt& m_interrupt;
132-    bool replySent;
133+public:
134+    std::string m_method;

301+        HTTPRequest req;
302+        std::vector<std::byte> buffer{StringToBuffer(bad_content_length)};
303+        LineReader reader(buffer, MAX_HEADERS_SIZE);
304+        BOOST_CHECK(req.LoadControlData(reader));
305+        BOOST_CHECK(req.LoadHeaders(reader));
306+        BOOST_CHECK_THROW(req.LoadBody(reader), std::runtime_error);

512+        if (!ParseUInt64(content_length_value.value(), &content_length)) throw std::runtime_error("Cannot parse Content-Length value");
513+
514+        // Not enough data in buffer for expected body
515+        if (reader.Left() < content_length) return false;
516+
517+        m_body = reader.ReadLength(content_length);

351+        accepted_sockets->Push(std::move(connected_socket));
352+
353+        // Prepare a request handler that just stores received requests so we can examine them
354+        // Mutex is required to prevent a race between this test's main thread and the Sockman I/O loop.
355+        Mutex requests_mutex;
356+        std::deque<std::unique_ptr<HTTPRequest>> requests;

352+
353+        // Prepare a request handler that just stores received requests so we can examine them
354+        // Mutex is required to prevent a race between this test's main thread and the Sockman I/O loop.
355+        Mutex requests_mutex;
356+        std::deque<std::unique_ptr<HTTPRequest>> requests;
357+        auto StoreRequest = [&](std::unique_ptr<HTTPRequest> req) {

468+bool HTTPRequest::LoadBody(LineReader& reader)
469+{
470+    // https://httpwg.org/specs/rfc9112.html#message.body
471+
472+    auto transfer_encoding_header = m_headers.Find("Transfer-Encoding");
473+    if (transfer_encoding_header && ToLower(transfer_encoding_header.value()) == "chunked") {

829+    if (CloseConnection(client->m_node_id)) {
830+        LogDebug(BCLog::HTTP, "Disconnected HTTP client %s (id=%d)\n", client->m_origin, client->m_node_id);
831+    } else {
832+        LogDebug(BCLog::HTTP, "Failed to disconnect non-existent HTTP client %s (id=%d)\n", client->m_origin, client->m_node_id);
833+    }
834 }

222+    std::atomic_bool m_send_ready{false};
223+
224+    // Set to true when we receive request data and set to false once m_send_buffer is cleared.
225+    // Checked during DisconnectClients(). All of these operations take place in the Sockman I/O loop,
226+    // however it may get set my a worker thread during an "optimistic send".
227+    std::atomic_bool m_prevent_disconnect{false};

224+    // Set to true when we receive request data and set to false once m_send_buffer is cleared.
225+    // Checked during DisconnectClients(). All of these operations take place in the Sockman I/O loop,
226+    // however it may get set my a worker thread during an "optimistic send".
227+    std::atomic_bool m_prevent_disconnect{false};
228+
229+    // Client request to keep connection open after all requests have been responded to.

1134-        struct evkeyvalq params_q;
1135-        evhttp_parse_query_str(query, &params_q);
1136+bool InitHTTPServer(const util::SignalInterrupt& interrupt)
1137+{
1138+    if (!InitHTTPAllowList())
1139+        return false;

1148+    g_http_server->m_rpcservertimeout = std::chrono::seconds(gArgs.GetIntArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
1149+
1150+    // Bind HTTP server to specified addresses
1151+    std::vector<std::pair<std::string, uint16_t>> endpoints{GetBindAddresses()};
1152+    bool bind_success{false};
1153+    for (std::vector<std::pair<std::string, uint16_t> >::iterator i = endpoints.begin(); i != endpoints.end(); ++i) {

1153+    for (std::vector<std::pair<std::string, uint16_t> >::iterator i = endpoints.begin(); i != endpoints.end(); ++i) {
1154+        LogPrintf("Binding RPC on address %s port %i\n", i->first, i->second);
1155+        const std::optional<CService> addr{Lookup(i->first, i->second, false)};
1156+        if (addr) {
1157+            if (addr->IsBindAny()) {
1158+                LogPrintf("WARNING: the RPC server is not safe to expose to untrusted networks such as the public internet\n");

1241+    if (g_http_server) {
1242+        // Disconnect clients as their remaining responses are flushed
1243+        g_http_server->m_disconnect_all_clients = true;
1244+        // Wait for all disconnections
1245+        while (!g_http_server->m_no_clients) {
1246+            std::this_thread::sleep_for(std::chrono::milliseconds{50});

1246+            std::this_thread::sleep_for(std::chrono::milliseconds{50});
1247+        }
1248+        // Break sockman I/O loop: stop accepting connections, sending and receiving data
1249+        g_http_server->interruptNet();
1250+        // Wait for sockman threads to exit
1251+        g_http_server->JoinSocketsThreads();

48     {
49-        struct timeval tv;
50-        tv.tv_sec = millis/1000;
51-        tv.tv_usec = (millis%1000)*1000;
52-        ev.trigger(&tv);
53+        context->scheduler->scheduleFromNow(func, std::chrono::milliseconds(millis));

59@@ -62,10 +60,10 @@ class HTTPRPCTimerInterface : public RPCTimerInterface
60     }
61     RPCTimerBase* NewTimer(std::function<void()>& func, int64_t millis) override
62     {
63-        return new HTTPRPCTimer(base, func, millis);
64+        return new HTTPRPCTimer(m_context, func, millis);
65     }
66 private:
67-    struct event_base* base;
68+    NodeContext* m_context;

129@@ -132,7 +130,7 @@ static bool multiUserAuthorized(std::string strUserPass)
130     return false;
131 }
132 
133-static bool RPCAuthorized(const std::string& strAuth, std::string& strAuthUsernameOut)
134+static bool RPCAuthorized(const std::string_view& strAuth, std::string& strAuthUsernameOut)

100+    void Remove(const std::string key);
101+    bool Read(util::LineReader& reader);
102+    std::string Stringify() const;
103+
104+private:
105+    std::map<std::string, std::string, util::CaseInsensitiveComparator> m_map;

333 {
334-    if (!InitHTTPAllowList())
335-        return false;
336+    const auto it = m_map.find(key);
337+    if (it == m_map.end()) return std::nullopt;
338+    return std::string_view(it->second);

68+    virtual ~HTTPClosure() = default;
69+};
70 
71-/** Change logging level for libevent. */
72-void UpdateHTTPServerLogging(bool enable);
73+namespace http_bitcoin {

377+        std::transform(s.begin(), s.end(), lowered.begin(),
378+            [](char c) {
379+                // Avoid implicit-integer-sign-change UB by only
380+                // processing ASCII.
381+                unsigned char uc = static_cast<unsigned char>(c);
382+                if (uc >= 128) return c;

140+        std::string headers_string{headers.Stringify()};
141+        BOOST_REQUIRE(headers_string.find("Sandwich: ham\r\n") != std::string::npos);
142+        BOOST_REQUIRE(headers_string.find("Coffee: black\r\n") != std::string::npos);
143+        BOOST_REQUIRE(headers_string.find("Cache-Control: no-cache, no-store\r\n") != std::string::npos);
144+        // No matter what order the headers end up in, it should be terminated by an empty line
145+        BOOST_REQUIRE(headers_string.ends_with("\r\n\r\n"));

409+                if (actual.ends_with("\r\n\r\n874140\n") &&
410+                    actual.find("HTTP/1.1 200 OK\r\n") != std::string::npos &&
411+                    actual.find("Connection: close\r\n") != std::string::npos &&
412+                    actual.find("Content-Length: 7\r\n") != std::string::npos &&
413+                    actual.find("Content-Type: text/html; charset=ISO-8859-1\r\n") != std::string::npos &&
414+                    actual.find("Date: Wed, 11 Dec 2024 00:47:09 GMT\r\n") != std::string::npos

163+
164+    // These methods reimplement the API from http_libevent::HTTPRequest
165+    // for downstream JSONRPC and REST modules.
166+    std::string GetURI() const {return m_target;};
167+    CService GetPeer() const;
168+    HTTPRequestMethod GetRequestMethod() const {return m_method;};

361@@ -362,4 +362,7 @@ bool IsBadPort(uint16_t port);
362  */
363 CService MaybeFlipIPv6toCJDNS(const CService& service);
364 
365+/** Get the bind address for a socket as CService. */
366+CService GetBindAddress(const Sock& sock);

956-    if (!sock.GetSockName((struct sockaddr*)&sockaddr_bind, &sockaddr_bind_len)) {
957-        addr_bind.SetSockAddr((const struct sockaddr*)&sockaddr_bind, sockaddr_bind_len);
958+    sockaddr_storage storage;
959+    socklen_t len = sizeof(storage);
960+
961+    auto sa = static_cast<sockaddr*>(static_cast<void*>(&storage));

958+    sockaddr_storage storage;
959+    socklen_t len = sizeof(storage);
960+
961+    auto sa = static_cast<sockaddr*>(static_cast<void*>(&storage));
962+
963+    if (!sock.GetSockName(sa, &len)) {

176  * @returns std::nullopt if the entire string could not be parsed, or if the
177  *   parsed value is not in the range representable by the type T.
178  */
179 template <typename T>
180-std::optional<T> ToIntegral(std::string_view str)
181+std::optional<T> ToIntegral(std::string_view str, size_t base = 10)