Branch data Line data Source code
1 : : // Copyright (c) 2015-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
6 : :
7 : : #include <httpserver.h>
8 : :
9 : : #include <chainparamsbase.h>
10 : : #include <common/args.h>
11 : : #include <common/messages.h>
12 : : #include <compat/compat.h>
13 : : #include <logging.h>
14 : : #include <netbase.h>
15 : : #include <node/interface_ui.h>
16 : : #include <rpc/protocol.h> // For HTTP status codes
17 : : #include <sync.h>
18 : : #include <util/check.h>
19 : : #include <util/signalinterrupt.h>
20 : : #include <util/strencodings.h>
21 : : #include <util/threadnames.h>
22 : : #include <util/translation.h>
23 : :
24 : : #include <condition_variable>
25 : : #include <cstdio>
26 : : #include <cstdlib>
27 : : #include <deque>
28 : : #include <memory>
29 : : #include <optional>
30 : : #include <span>
31 : : #include <string>
32 : : #include <unordered_map>
33 : :
34 : : #include <sys/types.h>
35 : : #include <sys/stat.h>
36 : :
37 : : #include <event2/buffer.h>
38 : : #include <event2/bufferevent.h>
39 : : #include <event2/http.h>
40 : : #include <event2/http_struct.h>
41 : : #include <event2/keyvalq_struct.h>
42 : : #include <event2/thread.h>
43 : : #include <event2/util.h>
44 : :
45 : : #include <support/events.h>
46 : :
47 : : using common::InvalidPortErrMsg;
48 : :
49 : : /** Maximum size of http request (request line + headers) */
50 : : static const size_t MAX_HEADERS_SIZE = 8192;
51 : :
52 : : /** HTTP request work item */
53 : : class HTTPWorkItem final : public HTTPClosure
54 : : {
55 : : public:
56 : 159550 : HTTPWorkItem(std::unique_ptr<HTTPRequest> _req, const std::string &_path, const HTTPRequestHandler& _func):
57 [ + - + - ]: 159550 : req(std::move(_req)), path(_path), func(_func)
58 : : {
59 : 159550 : }
60 : 159549 : void operator()() override
61 : : {
62 : 159549 : func(req.get(), path);
63 : 159549 : }
64 : :
65 : : std::unique_ptr<HTTPRequest> req;
66 : :
67 : : private:
68 : : std::string path;
69 : : HTTPRequestHandler func;
70 : : };
71 : :
72 : : /** Simple work queue for distributing work over multiple threads.
73 : : * Work items are simply callable objects.
74 : : */
75 : : template <typename WorkItem>
76 : : class WorkQueue
77 : : {
78 : : private:
79 : : Mutex cs;
80 : : std::condition_variable cond GUARDED_BY(cs);
81 : : std::deque<std::unique_ptr<WorkItem>> queue GUARDED_BY(cs);
82 : : bool running GUARDED_BY(cs){true};
83 : : const size_t maxDepth;
84 : :
85 : : public:
86 [ + - ]: 978 : explicit WorkQueue(size_t _maxDepth) : maxDepth(_maxDepth)
87 : : {
88 : 978 : }
89 : : /** Precondition: worker threads have all stopped (they have been joined).
90 : : */
91 : 978 : ~WorkQueue() = default;
92 : : /** Enqueue a work item */
93 : 159550 : bool Enqueue(WorkItem* item) EXCLUSIVE_LOCKS_REQUIRED(!cs)
94 : : {
95 : 159550 : LOCK(cs);
96 [ + - + + ]: 159550 : if (!running || queue.size() >= maxDepth) {
97 : : return false;
98 : : }
99 [ + - ]: 159549 : queue.emplace_back(std::unique_ptr<WorkItem>(item));
100 : 159549 : cond.notify_one();
101 : 159549 : return true;
102 : 159550 : }
103 : : /** Thread function */
104 : 3861 : void Run() EXCLUSIVE_LOCKS_REQUIRED(!cs)
105 : : {
106 : 159549 : while (true) {
107 : 163410 : std::unique_ptr<WorkItem> i;
108 : : {
109 [ + - ]: 163410 : WAIT_LOCK(cs, lock);
110 [ + + + + ]: 326806 : while (running && queue.empty())
111 [ + - ]: 163396 : cond.wait(lock);
112 [ + + - + ]: 163410 : if (!running && queue.empty())
113 : : break;
114 : 159549 : i = std::move(queue.front());
115 [ + - ]: 159549 : queue.pop_front();
116 [ + - ]: 163410 : }
117 [ + - ]: 159549 : (*i)();
118 : : }
119 : 3861 : }
120 : : /** Interrupt and exit loops */
121 : 978 : void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!cs)
122 : : {
123 : 978 : LOCK(cs);
124 : 978 : running = false;
125 [ + - ]: 978 : cond.notify_all();
126 : 978 : }
127 : : };
128 : :
129 : 2924 : struct HTTPPathHandler
130 : : {
131 : 1944 : HTTPPathHandler(std::string _prefix, bool _exactMatch, HTTPRequestHandler _handler):
132 [ + - ]: 1944 : prefix(_prefix), exactMatch(_exactMatch), handler(_handler)
133 : : {
134 : 1944 : }
135 : : std::string prefix;
136 : : bool exactMatch;
137 : : HTTPRequestHandler handler;
138 : : };
139 : :
140 : : /** HTTP module state */
141 : :
142 : : //! libevent event loop
143 : : static struct event_base* eventBase = nullptr;
144 : : //! HTTP server
145 : : static struct evhttp* eventHTTP = nullptr;
146 : : //! List of subnets to allow RPC connections from
147 : : static std::vector<CSubNet> rpc_allow_subnets;
148 : : //! Work queue for handling longer requests off the event loop thread
149 : : static std::unique_ptr<WorkQueue<HTTPClosure>> g_work_queue{nullptr};
150 : : //! Handlers for (sub)paths
151 : : static GlobalMutex g_httppathhandlers_mutex;
152 : : static std::vector<HTTPPathHandler> pathHandlers GUARDED_BY(g_httppathhandlers_mutex);
153 : : //! Bound listening sockets
154 : : static std::vector<evhttp_bound_socket *> boundSockets;
155 : :
156 : : /**
157 : : * @brief Helps keep track of open `evhttp_connection`s with active `evhttp_requests`
158 : : *
159 : : */
160 : : class HTTPRequestTracker
161 : : {
162 : : private:
163 : : mutable Mutex m_mutex;
164 : : mutable std::condition_variable m_cv;
165 : : //! For each connection, keep a counter of how many requests are open
166 : : std::unordered_map<const evhttp_connection*, size_t> m_tracker GUARDED_BY(m_mutex);
167 : :
168 : 159552 : void RemoveConnectionInternal(const decltype(m_tracker)::iterator it) EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
169 : : {
170 : 159552 : m_tracker.erase(it);
171 [ + + ]: 159552 : if (m_tracker.empty()) m_cv.notify_all();
172 : 159552 : }
173 : : public:
174 : : //! Increase request counter for the associated connection by 1
175 : 159552 : void AddRequest(evhttp_request* req) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
176 : : {
177 : 159552 : const evhttp_connection* conn{Assert(evhttp_request_get_connection(Assert(req)))};
178 [ + - + - ]: 478656 : WITH_LOCK(m_mutex, ++m_tracker[conn]);
179 : 159552 : }
180 : : //! Decrease request counter for the associated connection by 1, remove connection if counter is 0
181 : 159552 : void RemoveRequest(evhttp_request* req) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
182 : : {
183 : 159552 : const evhttp_connection* conn{Assert(evhttp_request_get_connection(Assert(req)))};
184 : 159552 : LOCK(m_mutex);
185 : 159552 : auto it{m_tracker.find(conn)};
186 [ + - + - ]: 159552 : if (it != m_tracker.end() && it->second > 0) {
187 [ + - ]: 159552 : if (--(it->second) == 0) RemoveConnectionInternal(it);
188 : : }
189 : 159552 : }
190 : : //! Remove a connection entirely
191 : 1856 : void RemoveConnection(const evhttp_connection* conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
192 : : {
193 : 1856 : LOCK(m_mutex);
194 [ + - ]: 1856 : auto it{m_tracker.find(Assert(conn))};
195 [ - + ]: 1856 : if (it != m_tracker.end()) RemoveConnectionInternal(it);
196 : 1856 : }
197 : 1010 : size_t CountActiveConnections() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
198 : : {
199 [ + - ]: 1010 : return WITH_LOCK(m_mutex, return m_tracker.size());
200 : : }
201 : : //! Wait until there are no more connections with active requests in the tracker
202 : 1010 : void WaitUntilEmpty() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
203 : : {
204 : 1010 : WAIT_LOCK(m_mutex, lock);
205 [ + + + - ]: 1012 : m_cv.wait(lock, [this]() EXCLUSIVE_LOCKS_REQUIRED(m_mutex) { return m_tracker.empty(); });
206 : 1010 : }
207 : : };
208 : : //! Track active requests
209 : : static HTTPRequestTracker g_requests;
210 : :
211 : : /** Check if a network address is allowed to access the HTTP server */
212 : 159552 : static bool ClientAllowed(const CNetAddr& netaddr)
213 : : {
214 [ + - ]: 159552 : if (!netaddr.IsValid())
215 : : return false;
216 [ + + ]: 159563 : for(const CSubNet& subnet : rpc_allow_subnets)
217 [ + + ]: 159562 : if (subnet.Match(netaddr))
218 : : return true;
219 : : return false;
220 : : }
221 : :
222 : : /** Initialize ACL list for HTTP server */
223 : 978 : static bool InitHTTPAllowList()
224 : : {
225 : 978 : rpc_allow_subnets.clear();
226 [ + - + - : 2934 : rpc_allow_subnets.emplace_back(LookupHost("127.0.0.1", false).value(), 8); // always allow IPv4 local subnet
+ - ]
227 [ + - + - : 2934 : rpc_allow_subnets.emplace_back(LookupHost("::1", false).value()); // always allow IPv6 localhost
+ - ]
228 [ + - + + ]: 985 : for (const std::string& strAllow : gArgs.GetArgs("-rpcallowip")) {
229 [ + - ]: 7 : const CSubNet subnet{LookupSubNet(strAllow)};
230 [ + - - + ]: 7 : if (!subnet.IsValid()) {
231 [ # # # # ]: 0 : uiInterface.ThreadSafeMessageBox(
232 [ # # # # : 0 : strprintf(Untranslated("Invalid -rpcallowip subnet specification: %s. Valid are a single IP (e.g. 1.2.3.4), a network/netmask (e.g. 1.2.3.4/255.255.255.0) or a network/CIDR (e.g. 1.2.3.4/24)."), strAllow),
# # ]
233 : : "", CClientUIInterface::MSG_ERROR);
234 : 0 : return false;
235 : : }
236 [ + - ]: 7 : rpc_allow_subnets.push_back(subnet);
237 : 985 : }
238 : 978 : std::string strAllowed;
239 [ + + ]: 2941 : for (const CSubNet& subnet : rpc_allow_subnets)
240 [ + - + - ]: 5889 : strAllowed += subnet.ToString() + " ";
241 [ + - + - : 978 : LogDebug(BCLog::HTTP, "Allowing HTTP connections from: %s\n", strAllowed);
+ - ]
242 : 978 : return true;
243 : 978 : }
244 : :
245 : : /** HTTP request method as string - use for logging only */
246 : 159551 : std::string RequestMethodString(HTTPRequest::RequestMethod m)
247 : : {
248 [ + + - - : 159551 : switch (m) {
- - ]
249 : 69 : case HTTPRequest::GET:
250 : 69 : return "GET";
251 : 159482 : case HTTPRequest::POST:
252 : 159482 : return "POST";
253 : 0 : case HTTPRequest::HEAD:
254 : 0 : return "HEAD";
255 : 0 : case HTTPRequest::PUT:
256 : 0 : return "PUT";
257 : 0 : case HTTPRequest::UNKNOWN:
258 : 0 : return "unknown";
259 : : } // no default case, so the compiler can warn about missing cases
260 : 0 : assert(false);
261 : : }
262 : :
263 : : /** HTTP request callback */
264 : 159552 : static void http_request_cb(struct evhttp_request* req, void* arg)
265 : : {
266 : 159552 : evhttp_connection* conn{evhttp_request_get_connection(req)};
267 : : // Track active requests
268 : 159552 : {
269 : 159552 : g_requests.AddRequest(req);
270 : 159552 : evhttp_request_set_on_complete_cb(req, [](struct evhttp_request* req, void*) {
271 : : g_requests.RemoveRequest(req);
272 : : }, nullptr);
273 : 159552 : evhttp_connection_set_closecb(conn, [](evhttp_connection* conn, void* arg) {
274 : : g_requests.RemoveConnection(conn);
275 : : }, nullptr);
276 : : }
277 : :
278 : : // Disable reading to work around a libevent bug, fixed in 2.1.9
279 : : // See https://github.com/libevent/libevent/commit/5ff8eb26371c4dc56f384b2de35bea2d87814779
280 : : // and https://github.com/bitcoin/bitcoin/pull/11593.
281 [ + - - + ]: 159552 : if (event_get_version_number() >= 0x02010600 && event_get_version_number() < 0x02010900) {
282 [ # # ]: 0 : if (conn) {
283 : 0 : bufferevent* bev = evhttp_connection_get_bufferevent(conn);
284 [ # # ]: 0 : if (bev) {
285 : 0 : bufferevent_disable(bev, EV_READ);
286 : : }
287 : : }
288 : : }
289 : 159552 : auto hreq{std::make_unique<HTTPRequest>(req, *static_cast<const util::SignalInterrupt*>(arg))};
290 : :
291 : : // Early address-based allow check
292 [ + - + - : 159552 : if (!ClientAllowed(hreq->GetPeer())) {
+ + ]
293 [ + - + - : 2 : LogDebug(BCLog::HTTP, "HTTP request from %s rejected: Client network is not allowed RPC access\n",
+ - + - +
- ]
294 : : hreq->GetPeer().ToStringAddrPort());
295 [ + - ]: 1 : hreq->WriteReply(HTTP_FORBIDDEN);
296 : : return;
297 : : }
298 : :
299 : : // Early reject unknown HTTP methods
300 [ + - - + ]: 159551 : if (hreq->GetRequestMethod() == HTTPRequest::UNKNOWN) {
301 [ # # # # : 0 : LogDebug(BCLog::HTTP, "HTTP request from %s rejected: Unknown HTTP request method\n",
# # # # #
# ]
302 : : hreq->GetPeer().ToStringAddrPort());
303 [ # # ]: 0 : hreq->WriteReply(HTTP_BAD_METHOD);
304 : : return;
305 : : }
306 : :
307 [ + - + - : 319102 : LogDebug(BCLog::HTTP, "Received a %s request for %s from %s\n",
+ - + - +
- + - + -
+ - + - +
- ]
308 : : RequestMethodString(hreq->GetRequestMethod()), SanitizeString(hreq->GetURI(), SAFE_CHARS_URI).substr(0, 100), hreq->GetPeer().ToStringAddrPort());
309 : :
310 : : // Find registered handler for prefix
311 [ + - ]: 159551 : std::string strURI = hreq->GetURI();
312 [ + - ]: 159551 : std::string path;
313 [ + - ]: 159551 : LOCK(g_httppathhandlers_mutex);
314 : 159551 : std::vector<HTTPPathHandler>::const_iterator i = pathHandlers.begin();
315 : 159551 : std::vector<HTTPPathHandler>::const_iterator iend = pathHandlers.end();
316 [ + + ]: 173064 : for (; i != iend; ++i) {
317 : 173063 : bool match = false;
318 [ + + ]: 173063 : if (i->exactMatch)
319 : 159551 : match = (strURI == i->prefix);
320 : : else
321 : 13512 : match = strURI.starts_with(i->prefix);
322 [ + + ]: 173063 : if (match) {
323 [ + - ]: 159550 : path = strURI.substr(i->prefix.size());
324 : 159550 : break;
325 : : }
326 : : }
327 : :
328 : : // Dispatch to worker thread
329 [ + + ]: 159551 : if (i != iend) {
330 [ + - + - ]: 159550 : std::unique_ptr<HTTPWorkItem> item(new HTTPWorkItem(std::move(hreq), path, i->handler));
331 [ - + ]: 159550 : assert(g_work_queue);
332 [ + - + + ]: 159550 : if (g_work_queue->Enqueue(item.get())) {
333 : 159549 : item.release(); /* if true, queue took ownership */
334 : : } else {
335 [ + - ]: 1 : LogPrintf("WARNING: request rejected because http work queue depth exceeded, it can be increased with the -rpcworkqueue= setting\n");
336 [ + - ]: 1 : item->req->WriteReply(HTTP_SERVICE_UNAVAILABLE, "Work queue depth exceeded");
337 : : }
338 : 159550 : } else {
339 [ + - ]: 1 : hreq->WriteReply(HTTP_NOT_FOUND);
340 : : }
341 : 159552 : }
342 : :
343 : : /** Callback to reject HTTP requests after shutdown. */
344 : 0 : static void http_reject_request_cb(struct evhttp_request* req, void*)
345 : : {
346 [ # # ]: 0 : LogDebug(BCLog::HTTP, "Rejecting request while shutting down\n");
347 : 0 : evhttp_send_error(req, HTTP_SERVUNAVAIL, nullptr);
348 : 0 : }
349 : :
350 : : /** Event dispatcher thread */
351 : 966 : static void ThreadHTTP(struct event_base* base)
352 : : {
353 [ + - ]: 966 : util::ThreadRename("http");
354 [ + - ]: 966 : LogDebug(BCLog::HTTP, "Entering http event loop\n");
355 : 966 : event_base_dispatch(base);
356 : : // Event loop will be interrupted by InterruptHTTPServer()
357 [ + - ]: 966 : LogDebug(BCLog::HTTP, "Exited http event loop\n");
358 : 966 : }
359 : :
360 : : /** Bind HTTP server to specified addresses */
361 : 978 : static bool HTTPBindAddresses(struct evhttp* http)
362 : : {
363 [ + - ]: 978 : uint16_t http_port{static_cast<uint16_t>(gArgs.GetIntArg("-rpcport", BaseParams().RPCPort()))};
364 : 978 : std::vector<std::pair<std::string, uint16_t>> endpoints;
365 : :
366 : : // Determine what addresses to bind to
367 [ + - + - : 1963 : if (!(gArgs.IsArgSet("-rpcallowip") && gArgs.IsArgSet("-rpcbind"))) { // Default to loopback if not allowing external IPs
+ + + - +
- + - + +
- - ]
368 [ + - ]: 971 : endpoints.emplace_back("::1", http_port);
369 [ + - ]: 971 : endpoints.emplace_back("127.0.0.1", http_port);
370 [ + - + - : 971 : if (gArgs.IsArgSet("-rpcallowip")) {
- + ]
371 [ # # ]: 0 : LogPrintf("WARNING: option -rpcallowip was specified without -rpcbind; this doesn't usually make sense\n");
372 : : }
373 [ + - + - : 971 : if (gArgs.IsArgSet("-rpcbind")) {
- + ]
374 [ # # ]: 0 : LogPrintf("WARNING: option -rpcbind was ignored because -rpcallowip was not specified, refusing to allow everyone to connect\n");
375 : : }
376 [ + - + - : 7 : } else if (gArgs.IsArgSet("-rpcbind")) { // Specific bind address
+ - ]
377 [ + - + - : 18 : for (const std::string& strRPCBind : gArgs.GetArgs("-rpcbind")) {
+ + ]
378 : 11 : uint16_t port{http_port};
379 [ + - ]: 11 : std::string host;
380 [ + - - + ]: 11 : if (!SplitHostPort(strRPCBind, port, host)) {
381 [ # # # # : 0 : LogError("%s\n", InvalidPortErrMsg("-rpcbind", strRPCBind).original);
# # ]
382 : 0 : return false;
383 : : }
384 [ + - ]: 11 : endpoints.emplace_back(host, port);
385 : 18 : }
386 : : }
387 : :
388 : : // Bind addresses
389 [ + + ]: 2931 : for (std::vector<std::pair<std::string, uint16_t> >::iterator i = endpoints.begin(); i != endpoints.end(); ++i) {
390 [ + - ]: 1953 : LogPrintf("Binding RPC on address %s port %i\n", i->first, i->second);
391 [ + - + - ]: 1953 : evhttp_bound_socket *bind_handle = evhttp_bind_socket_with_handle(http, i->first.empty() ? nullptr : i->first.c_str(), i->second);
392 [ + + ]: 1953 : if (bind_handle) {
393 [ + - + - ]: 982 : const std::optional<CNetAddr> addr{LookupHost(i->first, false)};
394 [ + - + - : 982 : if (i->first.empty() || (addr.has_value() && addr->IsBindAny())) {
+ - - + ]
395 [ # # ]: 0 : LogPrintf("WARNING: the RPC server is not safe to expose to untrusted networks such as the public internet\n");
396 : : }
397 : : // Set the no-delay option (disable Nagle's algorithm) on the TCP socket.
398 [ + - ]: 982 : evutil_socket_t fd = evhttp_bound_socket_get_fd(bind_handle);
399 : 982 : int one = 1;
400 [ - + ]: 982 : if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (sockopt_arg_type)&one, sizeof(one)) == SOCKET_ERROR) {
401 [ # # ]: 0 : LogInfo("WARNING: Unable to set TCP_NODELAY on RPC server socket, continuing anyway\n");
402 : : }
403 [ + - ]: 982 : boundSockets.push_back(bind_handle);
404 : 982 : } else {
405 [ + - ]: 971 : LogPrintf("Binding RPC on address %s port %i failed.\n", i->first, i->second);
406 : : }
407 : : }
408 : 978 : return !boundSockets.empty();
409 : 978 : }
410 : :
411 : : /** Simple wrapper to set thread name and run work queue */
412 : 3861 : static void HTTPWorkQueueRun(WorkQueue<HTTPClosure>* queue, int worker_num)
413 : : {
414 [ + - ]: 3861 : util::ThreadRename(strprintf("httpworker.%i", worker_num));
415 : 3861 : queue->Run();
416 : 3861 : }
417 : :
418 : : /** libevent event log callback */
419 : 971 : static void libevent_log_cb(int severity, const char *msg)
420 : : {
421 : 971 : BCLog::Level level;
422 [ - + - - ]: 971 : switch (severity) {
423 : : case EVENT_LOG_DEBUG:
424 : : level = BCLog::Level::Debug;
425 : : break;
426 : 0 : case EVENT_LOG_MSG:
427 : 0 : level = BCLog::Level::Info;
428 : 0 : break;
429 : 971 : case EVENT_LOG_WARN:
430 : 971 : level = BCLog::Level::Warning;
431 : 971 : break;
432 : 0 : default: // EVENT_LOG_ERR and others are mapped to error
433 : 0 : level = BCLog::Level::Error;
434 : 0 : break;
435 : : }
436 [ + - ]: 971 : LogPrintLevel(BCLog::LIBEVENT, level, "%s\n", msg);
437 : 971 : }
438 : :
439 : 978 : bool InitHTTPServer(const util::SignalInterrupt& interrupt)
440 : : {
441 [ + - ]: 978 : if (!InitHTTPAllowList())
442 : : return false;
443 : :
444 : : // Redirect libevent's logging to our own log
445 : 978 : event_set_log_callback(&libevent_log_cb);
446 : : // Update libevent's log handling.
447 : 978 : UpdateHTTPServerLogging(LogInstance().WillLogCategory(BCLog::LIBEVENT));
448 : :
449 : : #ifdef WIN32
450 : : evthread_use_windows_threads();
451 : : #else
452 : 978 : evthread_use_pthreads();
453 : : #endif
454 : :
455 : 978 : raii_event_base base_ctr = obtain_event_base();
456 : :
457 : : /* Create a new evhttp object to handle requests. */
458 [ + - ]: 978 : raii_evhttp http_ctr = obtain_evhttp(base_ctr.get());
459 [ - + ]: 978 : struct evhttp* http = http_ctr.get();
460 [ - + ]: 978 : if (!http) {
461 [ # # ]: 0 : LogPrintf("couldn't create evhttp. Exiting.\n");
462 : : return false;
463 : : }
464 : :
465 [ + - + - : 978 : evhttp_set_timeout(http, gArgs.GetIntArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
+ - ]
466 [ + - ]: 978 : evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE);
467 [ + - ]: 978 : evhttp_set_max_body_size(http, MAX_SIZE);
468 [ + - ]: 978 : evhttp_set_gencb(http, http_request_cb, (void*)&interrupt);
469 : :
470 [ + - - + ]: 978 : if (!HTTPBindAddresses(http)) {
471 [ # # ]: 0 : LogPrintf("Unable to bind any endpoint for RPC server\n");
472 : : return false;
473 : : }
474 : :
475 [ + - + - : 978 : LogDebug(BCLog::HTTP, "Initialized HTTP server\n");
+ - ]
476 [ + - + - : 1956 : int workQueueDepth = std::max((long)gArgs.GetIntArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L);
+ - ]
477 [ + - + - : 978 : LogDebug(BCLog::HTTP, "creating work queue of depth %d\n", workQueueDepth);
+ - ]
478 : :
479 [ + - ]: 1956 : g_work_queue = std::make_unique<WorkQueue<HTTPClosure>>(workQueueDepth);
480 : : // transfer ownership to eventBase/HTTP via .release()
481 : 978 : eventBase = base_ctr.release();
482 : 978 : eventHTTP = http_ctr.release();
483 : 978 : return true;
484 [ - + ]: 978 : }
485 : :
486 : 978 : void UpdateHTTPServerLogging(bool enable) {
487 [ - + ]: 978 : if (enable) {
488 : 0 : event_enable_debug_logging(EVENT_DBG_ALL);
489 : : } else {
490 : 978 : event_enable_debug_logging(EVENT_DBG_NONE);
491 : : }
492 : 978 : }
493 : :
494 : : static std::thread g_thread_http;
495 : : static std::vector<std::thread> g_thread_http_workers;
496 : :
497 : 966 : void StartHTTPServer()
498 : : {
499 [ + - + - ]: 1932 : int rpcThreads = std::max((long)gArgs.GetIntArg("-rpcthreads", DEFAULT_HTTP_THREADS), 1L);
500 : 966 : LogInfo("Starting HTTP server with %d worker threads\n", rpcThreads);
501 : 966 : g_thread_http = std::thread(ThreadHTTP, eventBase);
502 : :
503 [ + + ]: 4827 : for (int i = 0; i < rpcThreads; i++) {
504 : 3861 : g_thread_http_workers.emplace_back(HTTPWorkQueueRun, g_work_queue.get(), i);
505 : : }
506 : 966 : }
507 : :
508 : 1010 : void InterruptHTTPServer()
509 : : {
510 [ + + ]: 1010 : LogDebug(BCLog::HTTP, "Interrupting HTTP server\n");
511 [ + + ]: 1010 : if (eventHTTP) {
512 : : // Reject requests on current connections
513 : 978 : evhttp_set_gencb(eventHTTP, http_reject_request_cb, nullptr);
514 : : }
515 [ + + ]: 1010 : if (g_work_queue) {
516 : 978 : g_work_queue->Interrupt();
517 : : }
518 : 1010 : }
519 : :
520 : 1010 : void StopHTTPServer()
521 : : {
522 [ + + ]: 1010 : LogDebug(BCLog::HTTP, "Stopping HTTP server\n");
523 [ + + ]: 1010 : if (g_work_queue) {
524 [ + - ]: 978 : LogDebug(BCLog::HTTP, "Waiting for HTTP worker threads to exit\n");
525 [ + + ]: 4839 : for (auto& thread : g_thread_http_workers) {
526 : 3861 : thread.join();
527 : : }
528 : 978 : g_thread_http_workers.clear();
529 : : }
530 : : // Unlisten sockets, these are what make the event loop running, which means
531 : : // that after this and all connections are closed the event loop will quit.
532 [ + + ]: 1992 : for (evhttp_bound_socket *socket : boundSockets) {
533 : 982 : evhttp_del_accept_socket(eventHTTP, socket);
534 : : }
535 [ + + ]: 1010 : boundSockets.clear();
536 : 1010 : {
537 [ + + ]: 1010 : if (const auto n_connections{g_requests.CountActiveConnections()}; n_connections != 0) {
538 [ + - ]: 2 : LogDebug(BCLog::HTTP, "Waiting for %d connections to stop HTTP server\n", n_connections);
539 : : }
540 : 1010 : g_requests.WaitUntilEmpty();
541 : : }
542 [ + + ]: 1010 : if (eventHTTP) {
543 : : // Schedule a callback to call evhttp_free in the event base thread, so
544 : : // that evhttp_free does not need to be called again after the handling
545 : : // of unfinished request connections that follows.
546 : 978 : event_base_once(eventBase, -1, EV_TIMEOUT, [](evutil_socket_t, short, void*) {
547 : : evhttp_free(eventHTTP);
548 : : eventHTTP = nullptr;
549 : : }, nullptr, nullptr);
550 : : }
551 [ + + ]: 1010 : if (eventBase) {
552 [ + - ]: 978 : LogDebug(BCLog::HTTP, "Waiting for HTTP event thread to exit\n");
553 [ + + ]: 978 : if (g_thread_http.joinable()) g_thread_http.join();
554 : 978 : event_base_free(eventBase);
555 : 978 : eventBase = nullptr;
556 : : }
557 [ + + ]: 1010 : g_work_queue.reset();
558 [ + + ]: 1010 : LogDebug(BCLog::HTTP, "Stopped HTTP server\n");
559 : 1010 : }
560 : :
561 : 966 : struct event_base* EventBase()
562 : : {
563 : 966 : return eventBase;
564 : : }
565 : :
566 : 159556 : static void httpevent_callback_fn(evutil_socket_t, short, void* data)
567 : : {
568 : : // Static handler: simply call inner handler
569 : 159556 : HTTPEvent *self = static_cast<HTTPEvent*>(data);
570 : 159556 : self->handler();
571 [ + + ]: 159556 : if (self->deleteWhenTriggered)
572 : 159552 : delete self;
573 : 159556 : }
574 : :
575 : 159596 : HTTPEvent::HTTPEvent(struct event_base* base, bool _deleteWhenTriggered, const std::function<void()>& _handler):
576 : 159596 : deleteWhenTriggered(_deleteWhenTriggered), handler(_handler)
577 : : {
578 [ + - ]: 159596 : ev = event_new(base, -1, 0, httpevent_callback_fn, this);
579 [ - + ]: 159596 : assert(ev);
580 : 159596 : }
581 : 159596 : HTTPEvent::~HTTPEvent()
582 : : {
583 : 159596 : event_free(ev);
584 : 159596 : }
585 : 159596 : void HTTPEvent::trigger(struct timeval* tv)
586 : : {
587 [ + + ]: 159596 : if (tv == nullptr)
588 : 159552 : event_active(ev, 0, 0); // immediately trigger event in main thread
589 : : else
590 : 44 : evtimer_add(ev, tv); // trigger after timeval passed
591 : 159596 : }
592 : 159552 : HTTPRequest::HTTPRequest(struct evhttp_request* _req, const util::SignalInterrupt& interrupt, bool _replySent)
593 : 159552 : : req(_req), m_interrupt(interrupt), replySent(_replySent)
594 : : {
595 : 159552 : }
596 : :
597 : 159552 : HTTPRequest::~HTTPRequest()
598 : : {
599 [ - + ]: 159552 : if (!replySent) {
600 : : // Keep track of whether reply was sent to avoid request leaks
601 : 0 : LogPrintf("%s: Unhandled request\n", __func__);
602 : 0 : WriteReply(HTTP_INTERNAL_SERVER_ERROR, "Unhandled request");
603 : : }
604 : : // evhttpd cleans up the request, as long as a reply was sent.
605 : 159552 : }
606 : :
607 : 159475 : std::pair<bool, std::string> HTTPRequest::GetHeader(const std::string& hdr) const
608 : : {
609 : 159475 : const struct evkeyvalq* headers = evhttp_request_get_input_headers(req);
610 [ - + ]: 159475 : assert(headers);
611 : 159475 : const char* val = evhttp_find_header(headers, hdr.c_str());
612 [ + - ]: 159475 : if (val)
613 : 159475 : return std::make_pair(true, val);
614 : : else
615 : 0 : return std::make_pair(false, "");
616 : : }
617 : :
618 : 159472 : std::string HTTPRequest::ReadBody()
619 : : {
620 : 159472 : struct evbuffer* buf = evhttp_request_get_input_buffer(req);
621 [ - + ]: 159472 : if (!buf)
622 : 0 : return "";
623 : 159472 : size_t size = evbuffer_get_length(buf);
624 : : /** Trivial implementation: if this is ever a performance bottleneck,
625 : : * internal copying can be avoided in multi-segment buffers by using
626 : : * evbuffer_peek and an awkward loop. Though in that case, it'd be even
627 : : * better to not copy into an intermediate string but use a stream
628 : : * abstraction to consume the evbuffer on the fly in the parsing algorithm.
629 : : */
630 : 159472 : const char* data = (const char*)evbuffer_pullup(buf, size);
631 [ + + ]: 159472 : if (!data) // returns nullptr in case of empty buffer
632 : 18 : return "";
633 : 159454 : std::string rv(data, size);
634 [ + - ]: 159454 : evbuffer_drain(buf, size);
635 : 159454 : return rv;
636 : 159454 : }
637 : :
638 : 160409 : void HTTPRequest::WriteHeader(const std::string& hdr, const std::string& value)
639 : : {
640 : 160409 : struct evkeyvalq* headers = evhttp_request_get_output_headers(req);
641 [ - + ]: 160409 : assert(headers);
642 : 160409 : evhttp_add_header(headers, hdr.c_str(), value.c_str());
643 : 160409 : }
644 : :
645 : : /** Closure sent to main thread to request a reply to be sent to
646 : : * a HTTP request.
647 : : * Replies must be sent in the main loop in the main http thread,
648 : : * this cannot be done from worker threads.
649 : : */
650 : 159552 : void HTTPRequest::WriteReply(int nStatus, std::span<const std::byte> reply)
651 : : {
652 [ + - - + ]: 159552 : assert(!replySent && req);
653 [ + + ]: 159552 : if (m_interrupt) {
654 [ + - + - ]: 1736 : WriteHeader("Connection", "close");
655 : : }
656 : : // Send event to main http thread to send reply message
657 : 159552 : struct evbuffer* evb = evhttp_request_get_output_buffer(req);
658 [ - + ]: 159552 : assert(evb);
659 : 159552 : evbuffer_add(evb, reply.data(), reply.size());
660 : 159552 : auto req_copy = req;
661 [ + - ]: 159552 : HTTPEvent* ev = new HTTPEvent(eventBase, true, [req_copy, nStatus]{
662 : 159552 : evhttp_send_reply(req_copy, nStatus, nullptr, nullptr);
663 : : // Re-enable reading from the socket. This is the second part of the libevent
664 : : // workaround above.
665 [ + - - + ]: 159552 : if (event_get_version_number() >= 0x02010600 && event_get_version_number() < 0x02010900) {
666 : 0 : evhttp_connection* conn = evhttp_request_get_connection(req_copy);
667 [ # # ]: 0 : if (conn) {
668 : 0 : bufferevent* bev = evhttp_connection_get_bufferevent(conn);
669 [ # # ]: 0 : if (bev) {
670 : 0 : bufferevent_enable(bev, EV_READ | EV_WRITE);
671 : : }
672 : : }
673 : : }
674 [ + - ]: 159552 : });
675 : 159552 : ev->trigger(nullptr);
676 : 159552 : replySent = true;
677 : 159552 : req = nullptr; // transferred back to main thread
678 : 159552 : }
679 : :
680 : 478579 : CService HTTPRequest::GetPeer() const
681 : : {
682 : 478579 : evhttp_connection* con = evhttp_request_get_connection(req);
683 : 478579 : CService peer;
684 [ + - ]: 478579 : if (con) {
685 : : // evhttp retains ownership over returned address string
686 : 478579 : const char* address = "";
687 : 478579 : uint16_t port = 0;
688 : :
689 : : #ifdef HAVE_EVHTTP_CONNECTION_GET_PEER_CONST_CHAR
690 : : evhttp_connection_get_peer(con, &address, &port);
691 : : #else
692 [ + - ]: 478579 : evhttp_connection_get_peer(con, (char**)&address, &port);
693 : : #endif // HAVE_EVHTTP_CONNECTION_GET_PEER_CONST_CHAR
694 : :
695 [ + - + - : 957158 : peer = MaybeFlipIPv6toCJDNS(LookupNumeric(address, port));
+ - + - ]
696 : : }
697 : 478579 : return peer;
698 : 0 : }
699 : :
700 : 478552 : std::string HTTPRequest::GetURI() const
701 : : {
702 : 478552 : return evhttp_request_get_uri(req);
703 : : }
704 : :
705 : 478577 : HTTPRequest::RequestMethod HTTPRequest::GetRequestMethod() const
706 : : {
707 [ + - - - : 478577 : switch (evhttp_request_get_command(req)) {
+ ]
708 : : case EVHTTP_REQ_GET:
709 : : return GET;
710 : 478439 : case EVHTTP_REQ_POST:
711 : 478439 : return POST;
712 : 0 : case EVHTTP_REQ_HEAD:
713 : 0 : return HEAD;
714 : 0 : case EVHTTP_REQ_PUT:
715 : 0 : return PUT;
716 : 0 : default:
717 : 0 : return UNKNOWN;
718 : : }
719 : : }
720 : :
721 : 32 : std::optional<std::string> HTTPRequest::GetQueryParameter(const std::string& key) const
722 : : {
723 : 32 : const char* uri{evhttp_request_get_uri(req)};
724 : :
725 : 32 : return GetQueryParameterFromUri(uri, key);
726 : : }
727 : :
728 : 40 : std::optional<std::string> GetQueryParameterFromUri(const char* uri, const std::string& key)
729 : : {
730 : 40 : evhttp_uri* uri_parsed{evhttp_uri_parse(uri)};
731 [ + + ]: 40 : if (!uri_parsed) {
732 [ + - ]: 4 : throw std::runtime_error("URI parsing failed, it likely contained RFC 3986 invalid characters");
733 : : }
734 : 36 : const char* query{evhttp_uri_get_query(uri_parsed)};
735 : 36 : std::optional<std::string> result;
736 : :
737 [ + + ]: 36 : if (query) {
738 : : // Parse the query string into a key-value queue and iterate over it
739 : 30 : struct evkeyvalq params_q;
740 [ + - ]: 30 : evhttp_parse_query_str(query, ¶ms_q);
741 : :
742 [ + + ]: 37 : for (struct evkeyval* param{params_q.tqh_first}; param != nullptr; param = param->next.tqe_next) {
743 [ + + ]: 35 : if (param->key == key) {
744 [ + - ]: 28 : result = param->value;
745 : : break;
746 : : }
747 : : }
748 [ + - ]: 30 : evhttp_clear_headers(¶ms_q);
749 : : }
750 [ + - ]: 36 : evhttp_uri_free(uri_parsed);
751 : :
752 : 36 : return result;
753 : 0 : }
754 : :
755 : 1944 : void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler)
756 : : {
757 [ + - ]: 1944 : LogDebug(BCLog::HTTP, "Registering HTTP handler for %s (exactmatch %d)\n", prefix, exactMatch);
758 : 1944 : LOCK(g_httppathhandlers_mutex);
759 [ + - ]: 1944 : pathHandlers.emplace_back(prefix, exactMatch, handler);
760 : 1944 : }
761 : :
762 : 14140 : void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
763 : : {
764 : 14140 : LOCK(g_httppathhandlers_mutex);
765 : 14140 : std::vector<HTTPPathHandler>::iterator i = pathHandlers.begin();
766 : 14140 : std::vector<HTTPPathHandler>::iterator iend = pathHandlers.end();
767 [ + + ]: 14140 : for (; i != iend; ++i)
768 [ + - - + ]: 1944 : if (i->prefix == prefix && i->exactMatch == exactMatch)
769 : : break;
770 [ + + ]: 14140 : if (i != iend)
771 : : {
772 [ + - + - : 1944 : LogDebug(BCLog::HTTP, "Unregistering HTTP handler for %s (exactmatch %d)\n", prefix, exactMatch);
+ - ]
773 : 1944 : pathHandlers.erase(i);
774 : : }
775 : 14140 : }
|
