1 // Copyright (c) 2015-2016 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.
5 #include "httpserver.h"
7 #include "chainparamsbase.h"
11 #include "rpc/protocol.h" // For HTTP status codes
13 #include "ui_interface.h"
19 #include <sys/types.h>
24 #include <event2/event.h>
25 #include <event2/http.h>
26 #include <event2/thread.h>
27 #include <event2/buffer.h>
28 #include <event2/util.h>
29 #include <event2/keyvalq_struct.h>
31 #ifdef EVENT__HAVE_NETINET_IN_H
32 #include <netinet/in.h>
33 #ifdef _XOPEN_SOURCE_EXTENDED
34 #include <arpa/inet.h>
38 /** Maximum size of http request (request line + headers) */
39 static const size_t MAX_HEADERS_SIZE
= 8192;
41 /** HTTP request work item */
42 class HTTPWorkItem
: public HTTPClosure
45 HTTPWorkItem(std::unique_ptr
<HTTPRequest
> _req
, const std::string
&_path
, const HTTPRequestHandler
& _func
):
46 req(std::move(_req
)), path(_path
), func(_func
)
51 func(req
.get(), path
);
54 std::unique_ptr
<HTTPRequest
> req
;
58 HTTPRequestHandler func
;
61 /** Simple work queue for distributing work over multiple threads.
62 * Work items are simply callable objects.
64 template <typename WorkItem
>
68 /** Mutex protects entire object */
70 std::condition_variable cond
;
71 std::deque
<std::unique_ptr
<WorkItem
>> queue
;
76 /** RAII object to keep track of number of running worker threads */
81 ThreadCounter(WorkQueue
&w
): wq(w
)
83 std::lock_guard
<std::mutex
> lock(wq
.cs
);
88 std::lock_guard
<std::mutex
> lock(wq
.cs
);
95 WorkQueue(size_t _maxDepth
) : running(true),
100 /** Precondition: worker threads have all stopped
106 /** Enqueue a work item */
107 bool Enqueue(WorkItem
* item
)
109 std::unique_lock
<std::mutex
> lock(cs
);
110 if (queue
.size() >= maxDepth
) {
113 queue
.emplace_back(std::unique_ptr
<WorkItem
>(item
));
117 /** Thread function */
120 ThreadCounter
count(*this);
122 std::unique_ptr
<WorkItem
> i
;
124 std::unique_lock
<std::mutex
> lock(cs
);
125 while (running
&& queue
.empty())
129 i
= std::move(queue
.front());
135 /** Interrupt and exit loops */
138 std::unique_lock
<std::mutex
> lock(cs
);
142 /** Wait for worker threads to exit */
145 std::unique_lock
<std::mutex
> lock(cs
);
146 while (numThreads
> 0)
151 struct HTTPPathHandler
154 HTTPPathHandler(std::string _prefix
, bool _exactMatch
, HTTPRequestHandler _handler
):
155 prefix(_prefix
), exactMatch(_exactMatch
), handler(_handler
)
160 HTTPRequestHandler handler
;
163 /** HTTP module state */
165 //! libevent event loop
166 static struct event_base
* eventBase
= 0;
168 struct evhttp
* eventHTTP
= 0;
169 //! List of subnets to allow RPC connections from
170 static std::vector
<CSubNet
> rpc_allow_subnets
;
171 //! Work queue for handling longer requests off the event loop thread
172 static WorkQueue
<HTTPClosure
>* workQueue
= 0;
173 //! Handlers for (sub)paths
174 std::vector
<HTTPPathHandler
> pathHandlers
;
175 //! Bound listening sockets
176 std::vector
<evhttp_bound_socket
*> boundSockets
;
178 /** Check if a network address is allowed to access the HTTP server */
179 static bool ClientAllowed(const CNetAddr
& netaddr
)
181 if (!netaddr
.IsValid())
183 for(const CSubNet
& subnet
: rpc_allow_subnets
)
184 if (subnet
.Match(netaddr
))
189 /** Initialize ACL list for HTTP server */
190 static bool InitHTTPAllowList()
192 rpc_allow_subnets
.clear();
195 LookupHost("127.0.0.1", localv4
, false);
196 LookupHost("::1", localv6
, false);
197 rpc_allow_subnets
.push_back(CSubNet(localv4
, 8)); // always allow IPv4 local subnet
198 rpc_allow_subnets
.push_back(CSubNet(localv6
)); // always allow IPv6 localhost
199 if (mapMultiArgs
.count("-rpcallowip")) {
200 const std::vector
<std::string
>& vAllow
= mapMultiArgs
.at("-rpcallowip");
201 for (std::string strAllow
: vAllow
) {
203 LookupSubNet(strAllow
.c_str(), subnet
);
204 if (!subnet
.IsValid()) {
205 uiInterface
.ThreadSafeMessageBox(
206 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
),
207 "", CClientUIInterface::MSG_ERROR
);
210 rpc_allow_subnets
.push_back(subnet
);
213 std::string strAllowed
;
214 for (const CSubNet
& subnet
: rpc_allow_subnets
)
215 strAllowed
+= subnet
.ToString() + " ";
216 LogPrint(BCLog::HTTP
, "Allowing HTTP connections from: %s\n", strAllowed
);
220 /** HTTP request method as string - use for logging only */
221 static std::string
RequestMethodString(HTTPRequest::RequestMethod m
)
224 case HTTPRequest::GET
:
227 case HTTPRequest::POST
:
230 case HTTPRequest::HEAD
:
233 case HTTPRequest::PUT
:
241 /** HTTP request callback */
242 static void http_request_cb(struct evhttp_request
* req
, void* arg
)
244 std::unique_ptr
<HTTPRequest
> hreq(new HTTPRequest(req
));
246 LogPrint(BCLog::HTTP
, "Received a %s request for %s from %s\n",
247 RequestMethodString(hreq
->GetRequestMethod()), hreq
->GetURI(), hreq
->GetPeer().ToString());
249 // Early address-based allow check
250 if (!ClientAllowed(hreq
->GetPeer())) {
251 hreq
->WriteReply(HTTP_FORBIDDEN
);
255 // Early reject unknown HTTP methods
256 if (hreq
->GetRequestMethod() == HTTPRequest::UNKNOWN
) {
257 hreq
->WriteReply(HTTP_BADMETHOD
);
261 // Find registered handler for prefix
262 std::string strURI
= hreq
->GetURI();
264 std::vector
<HTTPPathHandler
>::const_iterator i
= pathHandlers
.begin();
265 std::vector
<HTTPPathHandler
>::const_iterator iend
= pathHandlers
.end();
266 for (; i
!= iend
; ++i
) {
269 match
= (strURI
== i
->prefix
);
271 match
= (strURI
.substr(0, i
->prefix
.size()) == i
->prefix
);
273 path
= strURI
.substr(i
->prefix
.size());
278 // Dispatch to worker thread
280 std::unique_ptr
<HTTPWorkItem
> item(new HTTPWorkItem(std::move(hreq
), path
, i
->handler
));
282 if (workQueue
->Enqueue(item
.get()))
283 item
.release(); /* if true, queue took ownership */
285 LogPrintf("WARNING: request rejected because http work queue depth exceeded, it can be increased with the -rpcworkqueue= setting\n");
286 item
->req
->WriteReply(HTTP_INTERNAL
, "Work queue depth exceeded");
289 hreq
->WriteReply(HTTP_NOTFOUND
);
293 /** Callback to reject HTTP requests after shutdown. */
294 static void http_reject_request_cb(struct evhttp_request
* req
, void*)
296 LogPrint(BCLog::HTTP
, "Rejecting request while shutting down\n");
297 evhttp_send_error(req
, HTTP_SERVUNAVAIL
, NULL
);
300 /** Event dispatcher thread */
301 static bool ThreadHTTP(struct event_base
* base
, struct evhttp
* http
)
303 RenameThread("bitcoin-http");
304 LogPrint(BCLog::HTTP
, "Entering http event loop\n");
305 event_base_dispatch(base
);
306 // Event loop will be interrupted by InterruptHTTPServer()
307 LogPrint(BCLog::HTTP
, "Exited http event loop\n");
308 return event_base_got_break(base
) == 0;
311 /** Bind HTTP server to specified addresses */
312 static bool HTTPBindAddresses(struct evhttp
* http
)
314 int defaultPort
= GetArg("-rpcport", BaseParams().RPCPort());
315 std::vector
<std::pair
<std::string
, uint16_t> > endpoints
;
317 // Determine what addresses to bind to
318 if (!IsArgSet("-rpcallowip")) { // Default to loopback if not allowing external IPs
319 endpoints
.push_back(std::make_pair("::1", defaultPort
));
320 endpoints
.push_back(std::make_pair("127.0.0.1", defaultPort
));
321 if (IsArgSet("-rpcbind")) {
322 LogPrintf("WARNING: option -rpcbind was ignored because -rpcallowip was not specified, refusing to allow everyone to connect\n");
324 } else if (mapMultiArgs
.count("-rpcbind")) { // Specific bind address
325 const std::vector
<std::string
>& vbind
= mapMultiArgs
.at("-rpcbind");
326 for (std::vector
<std::string
>::const_iterator i
= vbind
.begin(); i
!= vbind
.end(); ++i
) {
327 int port
= defaultPort
;
329 SplitHostPort(*i
, port
, host
);
330 endpoints
.push_back(std::make_pair(host
, port
));
332 } else { // No specific bind address specified, bind to any
333 endpoints
.push_back(std::make_pair("::", defaultPort
));
334 endpoints
.push_back(std::make_pair("0.0.0.0", defaultPort
));
338 for (std::vector
<std::pair
<std::string
, uint16_t> >::iterator i
= endpoints
.begin(); i
!= endpoints
.end(); ++i
) {
339 LogPrint(BCLog::HTTP
, "Binding RPC on address %s port %i\n", i
->first
, i
->second
);
340 evhttp_bound_socket
*bind_handle
= evhttp_bind_socket_with_handle(http
, i
->first
.empty() ? NULL
: i
->first
.c_str(), i
->second
);
342 boundSockets
.push_back(bind_handle
);
344 LogPrintf("Binding RPC on address %s port %i failed.\n", i
->first
, i
->second
);
347 return !boundSockets
.empty();
350 /** Simple wrapper to set thread name and run work queue */
351 static void HTTPWorkQueueRun(WorkQueue
<HTTPClosure
>* queue
)
353 RenameThread("bitcoin-httpworker");
357 /** libevent event log callback */
358 static void libevent_log_cb(int severity
, const char *msg
)
360 #ifndef EVENT_LOG_WARN
361 // EVENT_LOG_WARN was added in 2.0.19; but before then _EVENT_LOG_WARN existed.
362 # define EVENT_LOG_WARN _EVENT_LOG_WARN
364 if (severity
>= EVENT_LOG_WARN
) // Log warn messages and higher without debug category
365 LogPrintf("libevent: %s\n", msg
);
367 LogPrint(BCLog::LIBEVENT
, "libevent: %s\n", msg
);
370 bool InitHTTPServer()
372 struct evhttp
* http
= 0;
373 struct event_base
* base
= 0;
375 if (!InitHTTPAllowList())
378 if (GetBoolArg("-rpcssl", false)) {
379 uiInterface
.ThreadSafeMessageBox(
380 "SSL mode for RPC (-rpcssl) is no longer supported.",
381 "", CClientUIInterface::MSG_ERROR
);
385 // Redirect libevent's logging to our own log
386 event_set_log_callback(&libevent_log_cb
);
387 #if LIBEVENT_VERSION_NUMBER >= 0x02010100
388 // If -debug=libevent, set full libevent debugging.
389 // Otherwise, disable all libevent debugging.
390 if (LogAcceptCategory(BCLog::LIBEVENT
)) {
391 event_enable_debug_logging(EVENT_DBG_ALL
);
393 event_enable_debug_logging(EVENT_DBG_NONE
);
397 evthread_use_windows_threads();
399 evthread_use_pthreads();
402 base
= event_base_new(); // XXX RAII
404 LogPrintf("Couldn't create an event_base: exiting\n");
408 /* Create a new evhttp object to handle requests. */
409 http
= evhttp_new(base
); // XXX RAII
411 LogPrintf("couldn't create evhttp. Exiting.\n");
412 event_base_free(base
);
416 evhttp_set_timeout(http
, GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT
));
417 evhttp_set_max_headers_size(http
, MAX_HEADERS_SIZE
);
418 evhttp_set_max_body_size(http
, MAX_SIZE
);
419 evhttp_set_gencb(http
, http_request_cb
, NULL
);
421 if (!HTTPBindAddresses(http
)) {
422 LogPrintf("Unable to bind any endpoint for RPC server\n");
424 event_base_free(base
);
428 LogPrint(BCLog::HTTP
, "Initialized HTTP server\n");
429 int workQueueDepth
= std::max((long)GetArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE
), 1L);
430 LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth
);
432 workQueue
= new WorkQueue
<HTTPClosure
>(workQueueDepth
);
438 std::thread threadHTTP
;
439 std::future
<bool> threadResult
;
441 bool StartHTTPServer()
443 LogPrint(BCLog::HTTP
, "Starting HTTP server\n");
444 int rpcThreads
= std::max((long)GetArg("-rpcthreads", DEFAULT_HTTP_THREADS
), 1L);
445 LogPrintf("HTTP: starting %d worker threads\n", rpcThreads
);
446 std::packaged_task
<bool(event_base
*, evhttp
*)> task(ThreadHTTP
);
447 threadResult
= task
.get_future();
448 threadHTTP
= std::thread(std::move(task
), eventBase
, eventHTTP
);
450 for (int i
= 0; i
< rpcThreads
; i
++) {
451 std::thread
rpc_worker(HTTPWorkQueueRun
, workQueue
);
457 void InterruptHTTPServer()
459 LogPrint(BCLog::HTTP
, "Interrupting HTTP server\n");
462 for (evhttp_bound_socket
*socket
: boundSockets
) {
463 evhttp_del_accept_socket(eventHTTP
, socket
);
465 // Reject requests on current connections
466 evhttp_set_gencb(eventHTTP
, http_reject_request_cb
, NULL
);
469 workQueue
->Interrupt();
472 void StopHTTPServer()
474 LogPrint(BCLog::HTTP
, "Stopping HTTP server\n");
476 LogPrint(BCLog::HTTP
, "Waiting for HTTP worker threads to exit\n");
477 workQueue
->WaitExit();
482 LogPrint(BCLog::HTTP
, "Waiting for HTTP event thread to exit\n");
483 // Give event loop a few seconds to exit (to send back last RPC responses), then break it
484 // Before this was solved with event_base_loopexit, but that didn't work as expected in
485 // at least libevent 2.0.21 and always introduced a delay. In libevent
486 // master that appears to be solved, so in the future that solution
487 // could be used again (if desirable).
488 // (see discussion in https://github.com/bitcoin/bitcoin/pull/6990)
489 if (threadResult
.valid() && threadResult
.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout
) {
490 LogPrintf("HTTP event loop did not exit within allotted time, sending loopbreak\n");
491 event_base_loopbreak(eventBase
);
496 evhttp_free(eventHTTP
);
500 event_base_free(eventBase
);
503 LogPrint(BCLog::HTTP
, "Stopped HTTP server\n");
506 struct event_base
* EventBase()
511 static void httpevent_callback_fn(evutil_socket_t
, short, void* data
)
513 // Static handler: simply call inner handler
514 HTTPEvent
*self
= ((HTTPEvent
*)data
);
516 if (self
->deleteWhenTriggered
)
520 HTTPEvent::HTTPEvent(struct event_base
* base
, bool _deleteWhenTriggered
, const std::function
<void(void)>& _handler
):
521 deleteWhenTriggered(_deleteWhenTriggered
), handler(_handler
)
523 ev
= event_new(base
, -1, 0, httpevent_callback_fn
, this);
526 HTTPEvent::~HTTPEvent()
530 void HTTPEvent::trigger(struct timeval
* tv
)
533 event_active(ev
, 0, 0); // immediately trigger event in main thread
535 evtimer_add(ev
, tv
); // trigger after timeval passed
537 HTTPRequest::HTTPRequest(struct evhttp_request
* _req
) : req(_req
),
541 HTTPRequest::~HTTPRequest()
544 // Keep track of whether reply was sent to avoid request leaks
545 LogPrintf("%s: Unhandled request\n", __func__
);
546 WriteReply(HTTP_INTERNAL
, "Unhandled request");
548 // evhttpd cleans up the request, as long as a reply was sent.
551 std::pair
<bool, std::string
> HTTPRequest::GetHeader(const std::string
& hdr
)
553 const struct evkeyvalq
* headers
= evhttp_request_get_input_headers(req
);
555 const char* val
= evhttp_find_header(headers
, hdr
.c_str());
557 return std::make_pair(true, val
);
559 return std::make_pair(false, "");
562 std::string
HTTPRequest::ReadBody()
564 struct evbuffer
* buf
= evhttp_request_get_input_buffer(req
);
567 size_t size
= evbuffer_get_length(buf
);
568 /** Trivial implementation: if this is ever a performance bottleneck,
569 * internal copying can be avoided in multi-segment buffers by using
570 * evbuffer_peek and an awkward loop. Though in that case, it'd be even
571 * better to not copy into an intermediate string but use a stream
572 * abstraction to consume the evbuffer on the fly in the parsing algorithm.
574 const char* data
= (const char*)evbuffer_pullup(buf
, size
);
575 if (!data
) // returns NULL in case of empty buffer
577 std::string
rv(data
, size
);
578 evbuffer_drain(buf
, size
);
582 void HTTPRequest::WriteHeader(const std::string
& hdr
, const std::string
& value
)
584 struct evkeyvalq
* headers
= evhttp_request_get_output_headers(req
);
586 evhttp_add_header(headers
, hdr
.c_str(), value
.c_str());
589 /** Closure sent to main thread to request a reply to be sent to
591 * Replies must be sent in the main loop in the main http thread,
592 * this cannot be done from worker threads.
594 void HTTPRequest::WriteReply(int nStatus
, const std::string
& strReply
)
596 assert(!replySent
&& req
);
597 // Send event to main http thread to send reply message
598 struct evbuffer
* evb
= evhttp_request_get_output_buffer(req
);
600 evbuffer_add(evb
, strReply
.data(), strReply
.size());
601 HTTPEvent
* ev
= new HTTPEvent(eventBase
, true,
602 std::bind(evhttp_send_reply
, req
, nStatus
, (const char*)NULL
, (struct evbuffer
*)NULL
));
605 req
= 0; // transferred back to main thread
608 CService
HTTPRequest::GetPeer()
610 evhttp_connection
* con
= evhttp_request_get_connection(req
);
613 // evhttp retains ownership over returned address string
614 const char* address
= "";
616 evhttp_connection_get_peer(con
, (char**)&address
, &port
);
617 peer
= LookupNumeric(address
, port
);
622 std::string
HTTPRequest::GetURI()
624 return evhttp_request_get_uri(req
);
627 HTTPRequest::RequestMethod
HTTPRequest::GetRequestMethod()
629 switch (evhttp_request_get_command(req
)) {
633 case EVHTTP_REQ_POST
:
636 case EVHTTP_REQ_HEAD
:
648 void RegisterHTTPHandler(const std::string
&prefix
, bool exactMatch
, const HTTPRequestHandler
&handler
)
650 LogPrint(BCLog::HTTP
, "Registering HTTP handler for %s (exactmatch %d)\n", prefix
, exactMatch
);
651 pathHandlers
.push_back(HTTPPathHandler(prefix
, exactMatch
, handler
));
654 void UnregisterHTTPHandler(const std::string
&prefix
, bool exactMatch
)
656 std::vector
<HTTPPathHandler
>::iterator i
= pathHandlers
.begin();
657 std::vector
<HTTPPathHandler
>::iterator iend
= pathHandlers
.end();
658 for (; i
!= iend
; ++i
)
659 if (i
->prefix
== prefix
&& i
->exactMatch
== exactMatch
)
663 LogPrint(BCLog::HTTP
, "Unregistering HTTP handler for %s (exactmatch %d)\n", prefix
, exactMatch
);
664 pathHandlers
.erase(i
);