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