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