22#include <condition_variable>
31#include <unordered_map>
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>
65 std::unique_ptr<HTTPRequest>
req;
75template <
typename WorkItem>
96 if (!running || queue.size() >=
maxDepth) {
99 queue.emplace_back(std::unique_ptr<WorkItem>(item));
107 std::unique_ptr<WorkItem> i;
110 while (running && queue.empty())
112 if (!running && queue.empty())
114 i = std::move(queue.front());
164 mutable std::condition_variable
m_cv;
171 if (m_tracker.empty())
m_cv.notify_all();
177 const evhttp_connection* conn{
Assert(evhttp_request_get_connection(
Assert(req)))};
183 const evhttp_connection* conn{
Assert(evhttp_request_get_connection(
Assert(req)))};
185 auto it{m_tracker.find(conn)};
186 if (it != m_tracker.end() && it->second > 0) {
194 auto it{m_tracker.find(
Assert(conn))};
217 if (subnet.Match(netaddr))
228 for (
const std::string& strAllow :
gArgs.
GetArgs(
"-rpcallowip")) {
230 if (!subnet.IsValid()) {
232 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)),
238 std::string strAllowed;
240 strAllowed += subnet.ToString() +
" ";
266 evhttp_connection* conn{evhttp_request_get_connection(req)};
270 evhttp_request_set_on_complete_cb(req, [](
struct evhttp_request* req,
void*) {
273 evhttp_connection_set_closecb(conn, [](evhttp_connection* conn,
void* arg) {
281 if (event_get_version_number() >= 0x02010600 && event_get_version_number() < 0x02010900) {
283 bufferevent* bev = evhttp_connection_get_bufferevent(conn);
285 bufferevent_disable(bev, EV_READ);
293 LogDebug(
BCLog::HTTP,
"HTTP request from %s rejected: Client network is not allowed RPC access\n",
294 hreq->GetPeer().ToStringAddrPort());
302 hreq->GetPeer().ToStringAddrPort());
311 std::string strURI = hreq->GetURI();
314 std::vector<HTTPPathHandler>::const_iterator i = pathHandlers.begin();
315 std::vector<HTTPPathHandler>::const_iterator iend = pathHandlers.end();
316 for (; i != iend; ++i) {
319 match = (strURI == i->prefix);
321 match = strURI.starts_with(i->prefix);
323 path = strURI.substr(i->prefix.size());
330 std::unique_ptr<HTTPWorkItem> item(
new HTTPWorkItem(std::move(hreq), path, i->handler));
335 LogPrintf(
"WARNING: request rejected because http work queue depth exceeded, it can be increased with the -rpcworkqueue= setting\n");
347 evhttp_send_error(req, HTTP_SERVUNAVAIL,
nullptr);
355 event_base_dispatch(base);
364 std::vector<std::pair<std::string, uint16_t>> endpoints;
372 endpoints.emplace_back(
"::1", http_port);
373 endpoints.emplace_back(
"127.0.0.1", http_port);
375 LogPrintf(
"WARNING: option -rpcallowip was specified without -rpcbind; this doesn't usually make sense\n");
378 LogPrintf(
"WARNING: option -rpcbind was ignored because -rpcallowip was not specified, refusing to allow everyone to connect\n");
381 for (
const std::string& strRPCBind :
gArgs.
GetArgs(
"-rpcbind")) {
382 uint16_t port{http_port};
388 endpoints.emplace_back(host, port);
393 for (std::vector<std::pair<std::string, uint16_t> >::iterator i = endpoints.begin(); i != endpoints.end(); ++i) {
394 LogPrintf(
"Binding RPC on address %s port %i\n", i->first, i->second);
395 evhttp_bound_socket *bind_handle = evhttp_bind_socket_with_handle(http, i->first.empty() ?
nullptr : i->first.c_str(), i->second);
397 const std::optional<CNetAddr> addr{
LookupHost(i->first,
false)};
398 if (i->first.empty() || (addr.has_value() && addr->IsBindAny())) {
399 LogPrintf(
"WARNING: the RPC server is not safe to expose to untrusted networks such as the public internet\n");
402 evutil_socket_t fd = evhttp_bound_socket_get_fd(bind_handle);
405 LogInfo(
"WARNING: Unable to set TCP_NODELAY on RPC server socket, continuing anyway\n");
409 LogPrintf(
"Binding RPC on address %s port %i failed.\n", i->first, i->second);
427 case EVENT_LOG_DEBUG:
454 evthread_use_windows_threads();
456 evthread_use_pthreads();
463 struct evhttp* http = http_ctr.get();
465 LogPrintf(
"couldn't create evhttp. Exiting.\n");
471 evhttp_set_max_body_size(http,
MAX_SIZE);
475 LogPrintf(
"Unable to bind any endpoint for RPC server\n");
483 g_work_queue = std::make_unique<WorkQueue<HTTPClosure>>(workQueueDepth);
492 event_enable_debug_logging(EVENT_DBG_ALL);
494 event_enable_debug_logging(EVENT_DBG_NONE);
504 LogInfo(
"Starting HTTP server with %d worker threads\n", rpcThreads);
507 for (
int i = 0; i < rpcThreads; i++) {
537 evhttp_del_accept_socket(
eventHTTP, socket);
550 event_base_once(
eventBase, -1, EV_TIMEOUT, [](evutil_socket_t,
short,
void*) {
553 },
nullptr,
nullptr);
579HTTPEvent::HTTPEvent(
struct event_base* base,
bool _deleteWhenTriggered,
const std::function<
void()>& _handler):
580 deleteWhenTriggered(_deleteWhenTriggered),
handler(_handler)
592 event_active(
ev, 0, 0);
597 : req(_req), m_interrupt(interrupt), replySent(_replySent)
605 LogPrintf(
"%s: Unhandled request\n", __func__);
613 const struct evkeyvalq* headers = evhttp_request_get_input_headers(
req);
615 const char* val = evhttp_find_header(headers, hdr.c_str());
617 return std::make_pair(
true, val);
619 return std::make_pair(
false,
"");
624 struct evbuffer* buf = evhttp_request_get_input_buffer(
req);
627 size_t size = evbuffer_get_length(buf);
634 const char*
data = (
const char*)evbuffer_pullup(buf, size);
637 std::string rv(
data, size);
638 evbuffer_drain(buf, size);
644 struct evkeyvalq* headers = evhttp_request_get_output_headers(
req);
646 evhttp_add_header(headers, hdr.c_str(), value.c_str());
661 struct evbuffer* evb = evhttp_request_get_output_buffer(
req);
663 evbuffer_add(evb, reply.data(), reply.size());
666 evhttp_send_reply(req_copy, nStatus,
nullptr,
nullptr);
669 if (event_get_version_number() >= 0x02010600 && event_get_version_number() < 0x02010900) {
670 evhttp_connection* conn = evhttp_request_get_connection(req_copy);
672 bufferevent* bev = evhttp_connection_get_bufferevent(conn);
674 bufferevent_enable(bev, EV_READ | EV_WRITE);
686 evhttp_connection* con = evhttp_request_get_connection(
req);
690 const char* address =
"";
693#ifdef HAVE_EVHTTP_CONNECTION_GET_PEER_CONST_CHAR
694 evhttp_connection_get_peer(con, &address, &port);
696 evhttp_connection_get_peer(con, (
char**)&address, &port);
706 return evhttp_request_get_uri(
req);
711 switch (evhttp_request_get_command(
req)) {
714 case EVHTTP_REQ_POST:
716 case EVHTTP_REQ_HEAD:
727 const char* uri{evhttp_request_get_uri(
req)};
734 evhttp_uri* uri_parsed{evhttp_uri_parse(uri)};
736 throw std::runtime_error(
"URI parsing failed, it likely contained RFC 3986 invalid characters");
738 const char* query{evhttp_uri_get_query(uri_parsed)};
739 std::optional<std::string> result;
743 struct evkeyvalq params_q;
744 evhttp_parse_query_str(query, ¶ms_q);
746 for (
struct evkeyval* param{params_q.tqh_first}; param !=
nullptr; param = param->next.tqe_next) {
747 if (param->key == key) {
748 result = param->value;
752 evhttp_clear_headers(¶ms_q);
754 evhttp_uri_free(uri_parsed);
769 std::vector<HTTPPathHandler>::iterator i = pathHandlers.begin();
770 std::vector<HTTPPathHandler>::iterator iend = pathHandlers.end();
771 for (; i != iend; ++i)
772 if (i->prefix ==
prefix && i->exactMatch == exactMatch)
777 pathHandlers.erase(i);
const CBaseChainParams & BaseParams()
Return the currently selected parameters.
#define Assert(val)
Identity function.
std::vector< std::string > GetArgs(const std::string &strArg) const
Return a vector of strings of the given argument.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
A combination of a network address (CNetAddr) and a (TCP) port.
Different type to mark Mutex at global scope.
std::function< void()> handler
HTTPEvent(struct event_base *base, bool deleteWhenTriggered, const std::function< void()> &handler)
Create a new event.
void trigger(struct timeval *tv)
Trigger the event.
std::optional< std::string > GetQueryParameter(const std::string &key) const
Get the query parameter value from request uri for a specified key, or std::nullopt if the key is not...
std::pair< bool, std::string > GetHeader(const std::string &hdr) const
Get the request header specified by hdr, or an empty string.
std::string GetURI() const
Get requested URI.
void WriteReply(int nStatus, std::string_view reply="")
Write HTTP reply.
void WriteHeader(const std::string &hdr, const std::string &value)
Write output header.
HTTPRequest(struct evhttp_request *req, const util::SignalInterrupt &interrupt, bool replySent=false)
struct evhttp_request * req
RequestMethod GetRequestMethod() const
Get request method.
const util::SignalInterrupt & m_interrupt
std::string ReadBody()
Read request body.
CService GetPeer() const
Get CService (address:ip) for the origin of the http request.
Helps keep track of open evhttp_connections with active evhttp_requests
void WaitUntilEmpty() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Wait until there are no more connections with active requests in the tracker.
size_t CountActiveConnections() const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
void AddRequest(evhttp_request *req) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Increase request counter for the associated connection by 1.
void RemoveConnection(const evhttp_connection *conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Remove a connection entirely.
std::unordered_map< const evhttp_connection *, size_t > m_tracker GUARDED_BY(m_mutex)
For each connection, keep a counter of how many requests are open.
void RemoveRequest(evhttp_request *req) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Decrease request counter for the associated connection by 1, remove connection if counter is 0.
std::condition_variable m_cv
void RemoveConnectionInternal(const decltype(m_tracker)::iterator it) EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
void operator()() override
std::unique_ptr< HTTPRequest > req
HTTPWorkItem(std::unique_ptr< HTTPRequest > _req, const std::string &_path, const HTTPRequestHandler &_func)
Simple work queue for distributing work over multiple threads.
bool Enqueue(WorkItem *item) EXCLUSIVE_LOCKS_REQUIRED(!cs)
Enqueue a work item.
~WorkQueue()=default
Precondition: worker threads have all stopped (they have been joined).
std::deque< std::unique_ptr< WorkItem > > queue GUARDED_BY(cs)
std::condition_variable cond GUARDED_BY(cs)
void Interrupt() EXCLUSIVE_LOCKS_REQUIRED(!cs)
Interrupt and exit loops.
bool running GUARDED_BY(cs)
WorkQueue(size_t _maxDepth)
void Run() EXCLUSIVE_LOCKS_REQUIRED(!cs)
Thread function.
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
raii_evhttp obtain_evhttp(struct event_base *base)
raii_event_base obtain_event_base()
static struct evhttp * eventHTTP
HTTP server.
void InterruptHTTPServer()
Interrupt HTTP server threads.
static void http_request_cb(struct evhttp_request *req, void *arg)
HTTP request callback.
static bool HTTPBindAddresses(struct evhttp *http)
Bind HTTP server to specified addresses.
static std::vector< evhttp_bound_socket * > boundSockets
Bound listening sockets.
void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
Unregister handler for prefix.
void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler)
Register handler for prefix.
std::optional< std::string > GetQueryParameterFromUri(const char *uri, const std::string &key)
Get the query parameter value from request uri for a specified key, or std::nullopt if the key is not...
void StartHTTPServer()
Start HTTP server.
static struct event_base * eventBase
HTTP module state.
void UpdateHTTPServerLogging(bool enable)
Change logging level for libevent.
static std::thread g_thread_http
static std::unique_ptr< WorkQueue< HTTPClosure > > g_work_queue
Work queue for handling longer requests off the event loop thread.
struct event_base * EventBase()
Return evhttp event base.
static void httpevent_callback_fn(evutil_socket_t, short, void *data)
std::string RequestMethodString(HTTPRequest::RequestMethod m)
HTTP request method as string - use for logging only.
static HTTPRequestTracker g_requests
Track active requests.
bool InitHTTPServer(const util::SignalInterrupt &interrupt)
Initialize HTTP server.
static void HTTPWorkQueueRun(WorkQueue< HTTPClosure > *queue, int worker_num)
Simple wrapper to set thread name and run work queue.
static bool InitHTTPAllowList()
Initialize ACL list for HTTP server.
static void libevent_log_cb(int severity, const char *msg)
libevent event log callback
static std::vector< CSubNet > rpc_allow_subnets
List of subnets to allow RPC connections from.
static bool ClientAllowed(const CNetAddr &netaddr)
Check if a network address is allowed to access the HTTP server.
static void http_reject_request_cb(struct evhttp_request *req, void *)
Callback to reject HTTP requests after shutdown.
static const size_t MAX_HEADERS_SIZE
Maximum size of http request (request line + headers)
void StopHTTPServer()
Stop HTTP server.
static void ThreadHTTP(struct event_base *base)
Event dispatcher thread.
static std::vector< std::thread > g_thread_http_workers
static std::vector< HTTPPathHandler > pathHandlers GUARDED_BY(g_httppathhandlers_mutex)
static GlobalMutex g_httppathhandlers_mutex
Handlers for (sub)paths.
static const int DEFAULT_HTTP_SERVER_TIMEOUT
static const int DEFAULT_HTTP_WORKQUEUE
The default value for -rpcworkqueue.
static const int DEFAULT_HTTP_THREADS
The default value for -rpcthreads.
std::function< bool(HTTPRequest *req, const std::string &)> HTTPRequestHandler
Handler for requests to a certain HTTP path.
CClientUIInterface uiInterface
BCLog::Logger & LogInstance()
#define LogPrintLevel(category, level,...)
#define LogDebug(category,...)
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
bilingual_str InvalidPortErrMsg(const std::string &optname, const std::string &invalid_value)
void ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
CSubNet LookupSubNet(const std::string &subnet_str)
Parse and resolve a specified subnet string into the appropriate internal representation.
std::vector< CNetAddr > LookupHost(const std::string &name, unsigned int nMaxSolutions, bool fAllowLookup, DNSLookupFn dns_lookup_function)
Resolve a host string to its corresponding network addresses.
CService MaybeFlipIPv6toCJDNS(const CService &service)
If an IPv6 address belongs to the address range used by the CJDNS network and the CJDNS network is re...
CService LookupNumeric(const std::string &name, uint16_t portDefault, DNSLookupFn dns_lookup_function)
Resolve a service string with a numeric IP to its first corresponding service.
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
@ HTTP_SERVICE_UNAVAILABLE
@ HTTP_INTERNAL_SERVER_ERROR
static constexpr uint64_t MAX_SIZE
The maximum size of a serialized object in bytes or number of elements (for eg vectors) when the size...
@ SAFE_CHARS_URI
Chars allowed in URIs (RFC 3986)
HTTPPathHandler(std::string _prefix, bool _exactMatch, HTTPRequestHandler _handler)
HTTPRequestHandler handler
#define WAIT_LOCK(cs, name)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
bool SplitHostPort(std::string_view in, uint16_t &portOut, std::string &hostOut)
Splits socket address string into host string and port value.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.