No OneTemporary
Actions

Size

43 KB

Subscribers

None

View Options

	diff --git a/src/httpserver.cpp b/src/httpserver.cpp
	index 600e57b7cc..0a7f903e9f 100644
	--- a/src/httpserver.cpp
	+++ b/src/httpserver.cpp
	@@ -1,594 +1,650 @@
	// Copyright (c) 2015 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "httpserver.h"

	#include "chainparamsbase.h"
	#include "compat.h"
	#include "util.h"
	#include "netbase.h"
	#include "rpcprotocol.h" // For HTTP status codes
	#include "sync.h"
	#include "ui_interface.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include <sys/types.h>
	#include <sys/stat.h>
	#include <signal.h>

	#include <event2/event.h>
	#include <event2/http.h>
	#include <event2/thread.h>
	#include <event2/buffer.h>
	#include <event2/util.h>
	#include <event2/keyvalq_struct.h>

	#ifdef EVENT__HAVE_NETINET_IN_H
	#include <netinet/in.h>
	#ifdef _XOPEN_SOURCE_EXTENDED
	#include <arpa/inet.h>
	#endif
	#endif

	#include <boost/algorithm/string/case_conv.hpp> // for to_lower()
	#include <boost/foreach.hpp>
	#include <boost/scoped_ptr.hpp>

	/** HTTP request work item */
	class HTTPWorkItem : public HTTPClosure
	{
	public:
	HTTPWorkItem(HTTPRequest* req, const std::string &path, const HTTPRequestHandler& func):
	req(req), path(path), func(func)
	{
	}
	void operator()()
	{
	func(req.get(), path);
	}

	boost::scoped_ptr<HTTPRequest> req;

	private:
	std::string path;
	HTTPRequestHandler func;
	};

	/** Simple work queue for distributing work over multiple threads.
	* Work items are simply callable objects.
	*/
	template <typename WorkItem>
	class WorkQueue
	{
	private:
	/** Mutex protects entire object */
	CWaitableCriticalSection cs;
	CConditionVariable cond;
	/* XXX in C++11 we can use std::unique_ptr here and avoid manual cleanup */
	std::deque<WorkItem*> queue;
	bool running;
	size_t maxDepth;
	+ int numThreads;
	+
	+ /** RAII object to keep track of number of running worker threads */
	+ class ThreadCounter
	+ {
	+ public:
	+ WorkQueue &wq;
	+ ThreadCounter(WorkQueue &w): wq(w)
	+ {
	+ boost::lock_guard<boost::mutex> lock(wq.cs);
	+ wq.numThreads += 1;
	+ }
	+ ~ThreadCounter()
	+ {
	+ boost::lock_guard<boost::mutex> lock(wq.cs);
	+ wq.numThreads -= 1;
	+ wq.cond.notify_all();
	+ }
	+ };

	public:
	WorkQueue(size_t maxDepth) : running(true),
	- maxDepth(maxDepth)
	+ maxDepth(maxDepth),
	+ numThreads(0)
	{
	}
	- /* Precondition: worker threads have all stopped */
	+ /*( Precondition: worker threads have all stopped
	+ * (call WaitExit)
	+ */
	~WorkQueue()
	{
	while (!queue.empty()) {
	delete queue.front();
	queue.pop_front();
	}
	}
	/** Enqueue a work item */
	bool Enqueue(WorkItem* item)
	{
	boost::unique_lock<boost::mutex> lock(cs);
	if (queue.size() >= maxDepth) {
	return false;
	}
	queue.push_back(item);
	cond.notify_one();
	return true;
	}
	/** Thread function */
	void Run()
	{
	+ ThreadCounter count(*this);
	while (running) {
	WorkItem* i = 0;
	{
	boost::unique_lock<boost::mutex> lock(cs);
	while (running && queue.empty())
	cond.wait(lock);
	if (!running)
	break;
	i = queue.front();
	queue.pop_front();
	}
	(*i)();
	delete i;
	}
	}
	/** Interrupt and exit loops */
	void Interrupt()
	{
	boost::unique_lock<boost::mutex> lock(cs);
	running = false;
	cond.notify_all();
	}
	+ /** Wait for worker threads to exit */
	+ void WaitExit()
	+ {
	+ boost::unique_lock<boost::mutex> lock(cs);
	+ while (numThreads > 0)
	+ cond.wait(lock);
	+ }

	/** Return current depth of queue */
	size_t Depth()
	{
	boost::unique_lock<boost::mutex> lock(cs);
	return queue.size();
	}
	};

	struct HTTPPathHandler
	{
	HTTPPathHandler() {}
	HTTPPathHandler(std::string prefix, bool exactMatch, HTTPRequestHandler handler):
	prefix(prefix), exactMatch(exactMatch), handler(handler)
	{
	}
	std::string prefix;
	bool exactMatch;
	HTTPRequestHandler handler;
	};

	/** HTTP module state */

	//! libevent event loop
	static struct event_base* eventBase = 0;
	//! HTTP server
	struct evhttp* eventHTTP = 0;
	//! List of subnets to allow RPC connections from
	static std::vector<CSubNet> rpc_allow_subnets;
	//! Work queue for handling longer requests off the event loop thread
	static WorkQueue<HTTPClosure>* workQueue = 0;
	//! Handlers for (sub)paths
	std::vector<HTTPPathHandler> pathHandlers;
	+//! Bound listening sockets
	+std::vector<evhttp_bound_socket *> boundSockets;

	/** Check if a network address is allowed to access the HTTP server */
	static bool ClientAllowed(const CNetAddr& netaddr)
	{
	if (!netaddr.IsValid())
	return false;
	BOOST_FOREACH (const CSubNet& subnet, rpc_allow_subnets)
	if (subnet.Match(netaddr))
	return true;
	return false;
	}

	/** Initialize ACL list for HTTP server */
	static bool InitHTTPAllowList()
	{
	rpc_allow_subnets.clear();
	rpc_allow_subnets.push_back(CSubNet("127.0.0.0/8")); // always allow IPv4 local subnet
	rpc_allow_subnets.push_back(CSubNet("::1")); // always allow IPv6 localhost
	if (mapMultiArgs.count("-rpcallowip")) {
	const std::vector<std::string>& vAllow = mapMultiArgs["-rpcallowip"];
	BOOST_FOREACH (std::string strAllow, vAllow) {
	CSubNet subnet(strAllow);
	if (!subnet.IsValid()) {
	uiInterface.ThreadSafeMessageBox(
	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),
	"", CClientUIInterface::MSG_ERROR);
	return false;
	}
	rpc_allow_subnets.push_back(subnet);
	}
	}
	std::string strAllowed;
	BOOST_FOREACH (const CSubNet& subnet, rpc_allow_subnets)
	strAllowed += subnet.ToString() + " ";
	LogPrint("http", "Allowing HTTP connections from: %s\n", strAllowed);
	return true;
	}

	/** HTTP request method as string - use for logging only */
	static std::string RequestMethodString(HTTPRequest::RequestMethod m)
	{
	switch (m) {
	case HTTPRequest::GET:
	return "GET";
	break;
	case HTTPRequest::POST:
	return "POST";
	break;
	case HTTPRequest::HEAD:
	return "HEAD";
	break;
	case HTTPRequest::PUT:
	return "PUT";
	break;
	default:
	return "unknown";
	}
	}

	/** HTTP request callback */
	static void http_request_cb(struct evhttp_request* req, void* arg)
	{
	std::auto_ptr<HTTPRequest> hreq(new HTTPRequest(req));

	LogPrint("http", "Received a %s request for %s from %s\n",
	RequestMethodString(hreq->GetRequestMethod()), hreq->GetURI(), hreq->GetPeer().ToString());

	// Early address-based allow check
	if (!ClientAllowed(hreq->GetPeer())) {
	hreq->WriteReply(HTTP_FORBIDDEN);
	return;
	}

	// Early reject unknown HTTP methods
	if (hreq->GetRequestMethod() == HTTPRequest::UNKNOWN) {
	hreq->WriteReply(HTTP_BADMETHOD);
	return;
	}

	// Find registered handler for prefix
	std::string strURI = hreq->GetURI();
	std::string path;
	std::vector<HTTPPathHandler>::const_iterator i = pathHandlers.begin();
	std::vector<HTTPPathHandler>::const_iterator iend = pathHandlers.end();
	for (; i != iend; ++i) {
	bool match = false;
	if (i->exactMatch)
	match = (strURI == i->prefix);
	else
	match = (strURI.substr(0, i->prefix.size()) == i->prefix);
	if (match) {
	path = strURI.substr(i->prefix.size());
	break;
	}
	}

	// Dispatch to worker thread
	if (i != iend) {
	std::auto_ptr<HTTPWorkItem> item(new HTTPWorkItem(hreq.release(), path, i->handler));
	assert(workQueue);
	if (workQueue->Enqueue(item.get()))
	item.release(); /* if true, queue took ownership */
	else
	item->req->WriteReply(HTTP_INTERNAL, "Work queue depth exceeded");
	} else {
	hreq->WriteReply(HTTP_NOTFOUND);
	}
	}

	+/** Callback to reject HTTP requests after shutdown. */
	+static void http_reject_request_cb(struct evhttp_request* req, void*)
	+{
	+ LogPrint("http", "Rejecting request while shutting down\n");
	+ evhttp_send_error(req, HTTP_SERVUNAVAIL, NULL);
	+}
	+
	/** Event dispatcher thread */
	static void ThreadHTTP(struct event_base* base, struct evhttp* http)
	{
	RenameThread("bitcoin-http");
	LogPrint("http", "Entering http event loop\n");
	event_base_dispatch(base);
	// Event loop will be interrupted by InterruptHTTPServer()
	LogPrint("http", "Exited http event loop\n");
	}

	/** Bind HTTP server to specified addresses */
	static bool HTTPBindAddresses(struct evhttp* http)
	{
	int defaultPort = GetArg("-rpcport", BaseParams().RPCPort());
	- int nBound = 0;
	std::vector<std::pair<std::string, uint16_t> > endpoints;

	// Determine what addresses to bind to
	if (!mapArgs.count("-rpcallowip")) { // Default to loopback if not allowing external IPs
	endpoints.push_back(std::make_pair("::1", defaultPort));
	endpoints.push_back(std::make_pair("127.0.0.1", defaultPort));
	if (mapArgs.count("-rpcbind")) {
	LogPrintf("WARNING: option -rpcbind was ignored because -rpcallowip was not specified, refusing to allow everyone to connect\n");
	}
	} else if (mapArgs.count("-rpcbind")) { // Specific bind address
	const std::vector<std::string>& vbind = mapMultiArgs["-rpcbind"];
	for (std::vector<std::string>::const_iterator i = vbind.begin(); i != vbind.end(); ++i) {
	int port = defaultPort;
	std::string host;
	SplitHostPort(*i, port, host);
	endpoints.push_back(std::make_pair(host, port));
	}
	} else { // No specific bind address specified, bind to any
	endpoints.push_back(std::make_pair("::", defaultPort));
	endpoints.push_back(std::make_pair("0.0.0.0", defaultPort));
	}

	// Bind addresses
	for (std::vector<std::pair<std::string, uint16_t> >::iterator i = endpoints.begin(); i != endpoints.end(); ++i) {
	LogPrint("http", "Binding RPC on address %s port %i\n", i->first, i->second);
	- if (evhttp_bind_socket(http, i->first.empty() ? NULL : i->first.c_str(), i->second) == 0) {
	- nBound += 1;
	+ evhttp_bound_socket *bind_handle = evhttp_bind_socket_with_handle(http, i->first.empty() ? NULL : i->first.c_str(), i->second);
	+ if (bind_handle) {
	+ boundSockets.push_back(bind_handle);
	} else {
	LogPrintf("Binding RPC on address %s port %i failed.\n", i->first, i->second);
	}
	}
	- return nBound > 0;
	+ return !boundSockets.empty();
	}

	/** Simple wrapper to set thread name and run work queue */
	static void HTTPWorkQueueRun(WorkQueue<HTTPClosure>* queue)
	{
	RenameThread("bitcoin-httpworker");
	queue->Run();
	}

	/** libevent event log callback */
	static void libevent_log_cb(int severity, const char *msg)
	{
	if (severity >= EVENT_LOG_WARN) // Log warn messages and higher without debug category
	LogPrintf("libevent: %s\n", msg);
	else
	LogPrint("libevent", "libevent: %s\n", msg);
	}

	bool InitHTTPServer()
	{
	struct evhttp* http = 0;
	struct event_base* base = 0;

	if (!InitHTTPAllowList())
	return false;

	if (GetBoolArg("-rpcssl", false)) {
	uiInterface.ThreadSafeMessageBox(
	"SSL mode for RPC (-rpcssl) is no longer supported.",
	"", CClientUIInterface::MSG_ERROR);
	return false;
	}

	// Redirect libevent's logging to our own log
	event_set_log_callback(&libevent_log_cb);
	#if LIBEVENT_VERSION_NUMBER >= 0x02010100
	// If -debug=libevent, set full libevent debugging.
	// Otherwise, disable all libevent debugging.
	if (LogAcceptCategory("libevent"))
	event_enable_debug_logging(EVENT_DBG_ALL);
	else
	event_enable_debug_logging(EVENT_DBG_NONE);
	#endif
	#ifdef WIN32
	evthread_use_windows_threads();
	#else
	evthread_use_pthreads();
	#endif

	base = event_base_new(); // XXX RAII
	if (!base) {
	LogPrintf("Couldn't create an event_base: exiting\n");
	return false;
	}

	/* Create a new evhttp object to handle requests. */
	http = evhttp_new(base); // XXX RAII
	if (!http) {
	LogPrintf("couldn't create evhttp. Exiting.\n");
	event_base_free(base);
	return false;
	}

	evhttp_set_timeout(http, GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
	evhttp_set_max_body_size(http, MAX_SIZE);
	evhttp_set_gencb(http, http_request_cb, NULL);

	if (!HTTPBindAddresses(http)) {
	LogPrintf("Unable to bind any endpoint for RPC server\n");
	evhttp_free(http);
	event_base_free(base);
	return false;
	}

	LogPrint("http", "Initialized HTTP server\n");
	int workQueueDepth = std::max((long)GetArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L);
	LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth);

	workQueue = new WorkQueue<HTTPClosure>(workQueueDepth);
	eventBase = base;
	eventHTTP = http;
	return true;
	}

	bool StartHTTPServer(boost::thread_group& threadGroup)
	{
	LogPrint("http", "Starting HTTP server\n");
	int rpcThreads = std::max((long)GetArg("-rpcthreads", DEFAULT_HTTP_THREADS), 1L);
	LogPrintf("HTTP: starting %d worker threads\n", rpcThreads);
	threadGroup.create_thread(boost::bind(&ThreadHTTP, eventBase, eventHTTP));

	for (int i = 0; i < rpcThreads; i++)
	threadGroup.create_thread(boost::bind(&HTTPWorkQueueRun, workQueue));
	return true;
	}

	void InterruptHTTPServer()
	{
	LogPrint("http", "Interrupting HTTP server\n");
	- if (eventBase)
	- event_base_loopbreak(eventBase);
	+ if (eventHTTP) {
	+ // Unlisten sockets
	+ BOOST_FOREACH (evhttp_bound_socket *socket, boundSockets) {
	+ evhttp_del_accept_socket(eventHTTP, socket);
	+ }
	+ // Reject requests on current connections
	+ evhttp_set_gencb(eventHTTP, http_reject_request_cb, NULL);
	+ }
	+ if (eventBase) {
	+ // Force-exit event loop after predefined time
	+ struct timeval tv;
	+ tv.tv_sec = 10;
	+ tv.tv_usec = 0;
	+ event_base_loopexit(eventBase, &tv);
	+ }
	if (workQueue)
	workQueue->Interrupt();
	}

	void StopHTTPServer()
	{
	LogPrint("http", "Stopping HTTP server\n");
	- delete workQueue;
	+ if (workQueue) {
	+ LogPrint("http", "Waiting for HTTP worker threads to exit\n");
	+ workQueue->WaitExit();
	+ delete workQueue;
	+ }
	if (eventHTTP) {
	evhttp_free(eventHTTP);
	eventHTTP = 0;
	}
	if (eventBase) {
	event_base_free(eventBase);
	eventBase = 0;
	}
	}

	struct event_base* EventBase()
	{
	return eventBase;
	}

	static void httpevent_callback_fn(evutil_socket_t, short, void* data)
	{
	// Static handler: simply call inner handler
	HTTPEvent self = ((HTTPEvent)data);
	self->handler();
	if (self->deleteWhenTriggered)
	delete self;
	}

	HTTPEvent::HTTPEvent(struct event_base* base, bool deleteWhenTriggered, const boost::function<void(void)>& handler):
	deleteWhenTriggered(deleteWhenTriggered), handler(handler)
	{
	ev = event_new(base, -1, 0, httpevent_callback_fn, this);
	assert(ev);
	}
	HTTPEvent::~HTTPEvent()
	{
	event_free(ev);
	}
	void HTTPEvent::trigger(struct timeval* tv)
	{
	if (tv == NULL)
	event_active(ev, 0, 0); // immediately trigger event in main thread
	else
	evtimer_add(ev, tv); // trigger after timeval passed
	}
	HTTPRequest::HTTPRequest(struct evhttp_request* req) : req(req),
	replySent(false)
	{
	}
	HTTPRequest::~HTTPRequest()
	{
	if (!replySent) {
	// Keep track of whether reply was sent to avoid request leaks
	LogPrintf("%s: Unhandled request\n", __func__);
	WriteReply(HTTP_INTERNAL, "Unhandled request");
	}
	// evhttpd cleans up the request, as long as a reply was sent.
	}

	std::pair<bool, std::string> HTTPRequest::GetHeader(const std::string& hdr)
	{
	const struct evkeyvalq* headers = evhttp_request_get_input_headers(req);
	assert(headers);
	const char* val = evhttp_find_header(headers, hdr.c_str());
	if (val)
	return std::make_pair(true, val);
	else
	return std::make_pair(false, "");
	}

	std::string HTTPRequest::ReadBody()
	{
	struct evbuffer* buf = evhttp_request_get_input_buffer(req);
	if (!buf)
	return "";
	size_t size = evbuffer_get_length(buf);
	/** Trivial implementation: if this is ever a performance bottleneck,
	* internal copying can be avoided in multi-segment buffers by using
	* evbuffer_peek and an awkward loop. Though in that case, it'd be even
	* better to not copy into an intermediate string but use a stream
	* abstraction to consume the evbuffer on the fly in the parsing algorithm.
	*/
	const char* data = (const char*)evbuffer_pullup(buf, size);
	if (!data) // returns NULL in case of empty buffer
	return "";
	std::string rv(data, size);
	evbuffer_drain(buf, size);
	return rv;
	}

	void HTTPRequest::WriteHeader(const std::string& hdr, const std::string& value)
	{
	struct evkeyvalq* headers = evhttp_request_get_output_headers(req);
	assert(headers);
	evhttp_add_header(headers, hdr.c_str(), value.c_str());
	}

	/** Closure sent to main thread to request a reply to be sent to
	* a HTTP request.
	* Replies must be sent in the main loop in the main http thread,
	* this cannot be done from worker threads.
	*/
	void HTTPRequest::WriteReply(int nStatus, const std::string& strReply)
	{
	assert(!replySent && req);
	// Send event to main http thread to send reply message
	struct evbuffer* evb = evhttp_request_get_output_buffer(req);
	assert(evb);
	evbuffer_add(evb, strReply.data(), strReply.size());
	HTTPEvent* ev = new HTTPEvent(eventBase, true,
	boost::bind(evhttp_send_reply, req, nStatus, (const char)NULL, (struct evbuffer )NULL));
	ev->trigger(0);
	replySent = true;
	req = 0; // transferred back to main thread
	}

	CService HTTPRequest::GetPeer()
	{
	evhttp_connection* con = evhttp_request_get_connection(req);
	CService peer;
	if (con) {
	// evhttp retains ownership over returned address string
	const char* address = "";
	uint16_t port = 0;
	evhttp_connection_get_peer(con, (char**)&address, &port);
	peer = CService(address, port);
	}
	return peer;
	}

	std::string HTTPRequest::GetURI()
	{
	return evhttp_request_get_uri(req);
	}

	HTTPRequest::RequestMethod HTTPRequest::GetRequestMethod()
	{
	switch (evhttp_request_get_command(req)) {
	case EVHTTP_REQ_GET:
	return GET;
	break;
	case EVHTTP_REQ_POST:
	return POST;
	break;
	case EVHTTP_REQ_HEAD:
	return HEAD;
	break;
	case EVHTTP_REQ_PUT:
	return PUT;
	break;
	default:
	return UNKNOWN;
	break;
	}
	}

	void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler)
	{
	LogPrint("http", "Registering HTTP handler for %s (exactmatch %d)\n", prefix, exactMatch);
	pathHandlers.push_back(HTTPPathHandler(prefix, exactMatch, handler));
	}

	void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
	{
	std::vector<HTTPPathHandler>::iterator i = pathHandlers.begin();
	std::vector<HTTPPathHandler>::iterator iend = pathHandlers.end();
	for (; i != iend; ++i)
	if (i->prefix == prefix && i->exactMatch == exactMatch)
	break;
	if (i != iend)
	{
	LogPrint("http", "Unregistering HTTP handler for %s (exactmatch %d)\n", prefix, exactMatch);
	pathHandlers.erase(i);
	}
	}

	diff --git a/src/rpcserver.cpp b/src/rpcserver.cpp
	index b831d3d3b2..dbee61efc8 100644
	--- a/src/rpcserver.cpp
	+++ b/src/rpcserver.cpp
	@@ -1,568 +1,569 @@
	// Copyright (c) 2010 Satoshi Nakamoto
	// Copyright (c) 2009-2014 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "rpcserver.h"

	#include "base58.h"
	#include "init.h"
	#include "random.h"
	#include "sync.h"
	#include "ui_interface.h"
	#include "util.h"
	#include "utilstrencodings.h"

	#include "univalue/univalue.h"

	#include <boost/bind.hpp>
	#include <boost/filesystem.hpp>
	#include <boost/foreach.hpp>
	#include <boost/iostreams/concepts.hpp>
	#include <boost/iostreams/stream.hpp>
	#include <boost/shared_ptr.hpp>
	#include <boost/signals2/signal.hpp>
	#include <boost/thread.hpp>
	#include <boost/algorithm/string/case_conv.hpp> // for to_upper()

	using namespace RPCServer;
	using namespace std;

	static bool fRPCRunning = false;
	static bool fRPCInWarmup = true;
	static std::string rpcWarmupStatus("RPC server started");
	static CCriticalSection cs_rpcWarmup;
	/* Timer-creating functions */
	static std::vector<RPCTimerInterface*> timerInterfaces;
	/* Map of name to timer.
	* @note Can be changed to std::unique_ptr when C++11 */
	static std::map<std::string, boost::shared_ptr<RPCTimerBase> > deadlineTimers;

	static struct CRPCSignals
	{
	boost::signals2::signal<void ()> Started;
	boost::signals2::signal<void ()> Stopped;
	boost::signals2::signal<void (const CRPCCommand&)> PreCommand;
	boost::signals2::signal<void (const CRPCCommand&)> PostCommand;
	} g_rpcSignals;

	void RPCServer::OnStarted(boost::function<void ()> slot)
	{
	g_rpcSignals.Started.connect(slot);
	}

	void RPCServer::OnStopped(boost::function<void ()> slot)
	{
	g_rpcSignals.Stopped.connect(slot);
	}

	void RPCServer::OnPreCommand(boost::function<void (const CRPCCommand&)> slot)
	{
	g_rpcSignals.PreCommand.connect(boost::bind(slot, _1));
	}

	void RPCServer::OnPostCommand(boost::function<void (const CRPCCommand&)> slot)
	{
	g_rpcSignals.PostCommand.connect(boost::bind(slot, _1));
	}

	void RPCTypeCheck(const UniValue& params,
	const list<UniValue::VType>& typesExpected,
	bool fAllowNull)
	{
	unsigned int i = 0;
	BOOST_FOREACH(UniValue::VType t, typesExpected)
	{
	if (params.size() <= i)
	break;

	const UniValue& v = params[i];
	if (!((v.type() == t) \|\| (fAllowNull && (v.isNull()))))
	{
	string err = strprintf("Expected type %s, got %s",
	uvTypeName(t), uvTypeName(v.type()));
	throw JSONRPCError(RPC_TYPE_ERROR, err);
	}
	i++;
	}
	}

	void RPCTypeCheckObj(const UniValue& o,
	const map<string, UniValue::VType>& typesExpected,
	bool fAllowNull)
	{
	BOOST_FOREACH(const PAIRTYPE(string, UniValue::VType)& t, typesExpected)
	{
	const UniValue& v = find_value(o, t.first);
	if (!fAllowNull && v.isNull())
	throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));

	if (!((v.type() == t.second) \|\| (fAllowNull && (v.isNull()))))
	{
	string err = strprintf("Expected type %s for %s, got %s",
	uvTypeName(t.second), t.first, uvTypeName(v.type()));
	throw JSONRPCError(RPC_TYPE_ERROR, err);
	}
	}
	}

	CAmount AmountFromValue(const UniValue& value)
	{
	if (!value.isNum() && !value.isStr())
	throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
	CAmount amount;
	if (!ParseFixedPoint(value.getValStr(), 8, &amount))
	throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
	if (!MoneyRange(amount))
	throw JSONRPCError(RPC_TYPE_ERROR, "Amount out of range");
	return amount;
	}

	UniValue ValueFromAmount(const CAmount& amount)
	{
	bool sign = amount < 0;
	int64_t n_abs = (sign ? -amount : amount);
	int64_t quotient = n_abs / COIN;
	int64_t remainder = n_abs % COIN;
	return UniValue(UniValue::VNUM,
	strprintf("%s%d.%08d", sign ? "-" : "", quotient, remainder));
	}

	uint256 ParseHashV(const UniValue& v, string strName)
	{
	string strHex;
	if (v.isStr())
	strHex = v.get_str();
	if (!IsHex(strHex)) // Note: IsHex("") is false
	throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
	uint256 result;
	result.SetHex(strHex);
	return result;
	}
	uint256 ParseHashO(const UniValue& o, string strKey)
	{
	return ParseHashV(find_value(o, strKey), strKey);
	}
	vector<unsigned char> ParseHexV(const UniValue& v, string strName)
	{
	string strHex;
	if (v.isStr())
	strHex = v.get_str();
	if (!IsHex(strHex))
	throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
	return ParseHex(strHex);
	}
	vector<unsigned char> ParseHexO(const UniValue& o, string strKey)
	{
	return ParseHexV(find_value(o, strKey), strKey);
	}

	/**
	* Note: This interface may still be subject to change.
	*/

	std::string CRPCTable::help(const std::string& strCommand) const
	{
	string strRet;
	string category;
	set<rpcfn_type> setDone;
	vector<pair<string, const CRPCCommand*> > vCommands;

	for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
	vCommands.push_back(make_pair(mi->second->category + mi->first, mi->second));
	sort(vCommands.begin(), vCommands.end());

	BOOST_FOREACH(const PAIRTYPE(string, const CRPCCommand*)& command, vCommands)
	{
	const CRPCCommand *pcmd = command.second;
	string strMethod = pcmd->name;
	// We already filter duplicates, but these deprecated screw up the sort order
	if (strMethod.find("label") != string::npos)
	continue;
	if ((strCommand != "" \|\| pcmd->category == "hidden") && strMethod != strCommand)
	continue;
	try
	{
	UniValue params;
	rpcfn_type pfn = pcmd->actor;
	if (setDone.insert(pfn).second)
	(*pfn)(params, true);
	}
	catch (const std::exception& e)
	{
	// Help text is returned in an exception
	string strHelp = string(e.what());
	if (strCommand == "")
	{
	if (strHelp.find('\n') != string::npos)
	strHelp = strHelp.substr(0, strHelp.find('\n'));

	if (category != pcmd->category)
	{
	if (!category.empty())
	strRet += "\n";
	category = pcmd->category;
	string firstLetter = category.substr(0,1);
	boost::to_upper(firstLetter);
	strRet += "== " + firstLetter + category.substr(1) + " ==\n";
	}
	}
	strRet += strHelp + "\n";
	}
	}
	if (strRet == "")
	strRet = strprintf("help: unknown command: %s\n", strCommand);
	strRet = strRet.substr(0,strRet.size()-1);
	return strRet;
	}

	UniValue help(const UniValue& params, bool fHelp)
	{
	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"help ( \"command\" )\n"
	"\nList all commands, or get help for a specified command.\n"
	"\nArguments:\n"
	"1. \"command\" (string, optional) The command to get help on\n"
	"\nResult:\n"
	"\"text\" (string) The help text\n"
	);

	string strCommand;
	if (params.size() > 0)
	strCommand = params[0].get_str();

	return tableRPC.help(strCommand);
	}


	UniValue stop(const UniValue& params, bool fHelp)
	{
	// Accept the deprecated and ignored 'detach' boolean argument
	if (fHelp \|\| params.size() > 1)
	throw runtime_error(
	"stop\n"
	"\nStop Bitcoin server.");
	- // Shutdown will take long enough that the response should get back
	+ // Event loop will exit after current HTTP requests have been handled, so
	+ // this reply will get back to the client.
	StartShutdown();
	return "Bitcoin server stopping";
	}

	/**
	* Call Table
	*/
	static const CRPCCommand vRPCCommands[] =
	{ // category name actor (function) okSafeMode
	// --------------------- ------------------------ ----------------------- ----------
	/* Overall control/query calls */
	{ "control", "getinfo", &getinfo, true }, /* uses wallet if enabled */
	{ "control", "help", &help, true },
	{ "control", "stop", &stop, true },

	/* P2P networking */
	{ "network", "getnetworkinfo", &getnetworkinfo, true },
	{ "network", "addnode", &addnode, true },
	{ "network", "disconnectnode", &disconnectnode, true },
	{ "network", "getaddednodeinfo", &getaddednodeinfo, true },
	{ "network", "getconnectioncount", &getconnectioncount, true },
	{ "network", "getnettotals", &getnettotals, true },
	{ "network", "getpeerinfo", &getpeerinfo, true },
	{ "network", "ping", &ping, true },
	{ "network", "setban", &setban, true },
	{ "network", "listbanned", &listbanned, true },
	{ "network", "clearbanned", &clearbanned, true },

	/* Block chain and UTXO */
	{ "blockchain", "getblockchaininfo", &getblockchaininfo, true },
	{ "blockchain", "getbestblockhash", &getbestblockhash, true },
	{ "blockchain", "getblockcount", &getblockcount, true },
	{ "blockchain", "getblock", &getblock, true },
	{ "blockchain", "getblockhash", &getblockhash, true },
	{ "blockchain", "getblockheader", &getblockheader, true },
	{ "blockchain", "getchaintips", &getchaintips, true },
	{ "blockchain", "getdifficulty", &getdifficulty, true },
	{ "blockchain", "getmempoolinfo", &getmempoolinfo, true },
	{ "blockchain", "getrawmempool", &getrawmempool, true },
	{ "blockchain", "gettxout", &gettxout, true },
	{ "blockchain", "gettxoutproof", &gettxoutproof, true },
	{ "blockchain", "verifytxoutproof", &verifytxoutproof, true },
	{ "blockchain", "gettxoutsetinfo", &gettxoutsetinfo, true },
	{ "blockchain", "verifychain", &verifychain, true },

	/* Mining */
	{ "mining", "getblocktemplate", &getblocktemplate, true },
	{ "mining", "getmininginfo", &getmininginfo, true },
	{ "mining", "getnetworkhashps", &getnetworkhashps, true },
	{ "mining", "prioritisetransaction", &prioritisetransaction, true },
	{ "mining", "submitblock", &submitblock, true },

	/* Coin generation */
	{ "generating", "getgenerate", &getgenerate, true },
	{ "generating", "setgenerate", &setgenerate, true },
	{ "generating", "generate", &generate, true },

	/* Raw transactions */
	{ "rawtransactions", "createrawtransaction", &createrawtransaction, true },
	{ "rawtransactions", "decoderawtransaction", &decoderawtransaction, true },
	{ "rawtransactions", "decodescript", &decodescript, true },
	{ "rawtransactions", "getrawtransaction", &getrawtransaction, true },
	{ "rawtransactions", "sendrawtransaction", &sendrawtransaction, false },
	{ "rawtransactions", "signrawtransaction", &signrawtransaction, false }, /* uses wallet if enabled */
	#ifdef ENABLE_WALLET
	{ "rawtransactions", "fundrawtransaction", &fundrawtransaction, false },
	#endif

	/* Utility functions */
	{ "util", "createmultisig", &createmultisig, true },
	{ "util", "validateaddress", &validateaddress, true }, /* uses wallet if enabled */
	{ "util", "verifymessage", &verifymessage, true },
	{ "util", "estimatefee", &estimatefee, true },
	{ "util", "estimatepriority", &estimatepriority, true },

	/* Not shown in help */
	{ "hidden", "invalidateblock", &invalidateblock, true },
	{ "hidden", "reconsiderblock", &reconsiderblock, true },
	{ "hidden", "setmocktime", &setmocktime, true },
	#ifdef ENABLE_WALLET
	{ "hidden", "resendwallettransactions", &resendwallettransactions, true},
	#endif

	#ifdef ENABLE_WALLET
	/* Wallet */
	{ "wallet", "addmultisigaddress", &addmultisigaddress, true },
	{ "wallet", "backupwallet", &backupwallet, true },
	{ "wallet", "dumpprivkey", &dumpprivkey, true },
	{ "wallet", "dumpwallet", &dumpwallet, true },
	{ "wallet", "encryptwallet", &encryptwallet, true },
	{ "wallet", "getaccountaddress", &getaccountaddress, true },
	{ "wallet", "getaccount", &getaccount, true },
	{ "wallet", "getaddressesbyaccount", &getaddressesbyaccount, true },
	{ "wallet", "getbalance", &getbalance, false },
	{ "wallet", "getnewaddress", &getnewaddress, true },
	{ "wallet", "getrawchangeaddress", &getrawchangeaddress, true },
	{ "wallet", "getreceivedbyaccount", &getreceivedbyaccount, false },
	{ "wallet", "getreceivedbyaddress", &getreceivedbyaddress, false },
	{ "wallet", "gettransaction", &gettransaction, false },
	{ "wallet", "getunconfirmedbalance", &getunconfirmedbalance, false },
	{ "wallet", "getwalletinfo", &getwalletinfo, false },
	{ "wallet", "importprivkey", &importprivkey, true },
	{ "wallet", "importwallet", &importwallet, true },
	{ "wallet", "importaddress", &importaddress, true },
	{ "wallet", "importpubkey", &importpubkey, true },
	{ "wallet", "keypoolrefill", &keypoolrefill, true },
	{ "wallet", "listaccounts", &listaccounts, false },
	{ "wallet", "listaddressgroupings", &listaddressgroupings, false },
	{ "wallet", "listlockunspent", &listlockunspent, false },
	{ "wallet", "listreceivedbyaccount", &listreceivedbyaccount, false },
	{ "wallet", "listreceivedbyaddress", &listreceivedbyaddress, false },
	{ "wallet", "listsinceblock", &listsinceblock, false },
	{ "wallet", "listtransactions", &listtransactions, false },
	{ "wallet", "listunspent", &listunspent, false },
	{ "wallet", "lockunspent", &lockunspent, true },
	{ "wallet", "move", &movecmd, false },
	{ "wallet", "sendfrom", &sendfrom, false },
	{ "wallet", "sendmany", &sendmany, false },
	{ "wallet", "sendtoaddress", &sendtoaddress, false },
	{ "wallet", "setaccount", &setaccount, true },
	{ "wallet", "settxfee", &settxfee, true },
	{ "wallet", "signmessage", &signmessage, true },
	{ "wallet", "walletlock", &walletlock, true },
	{ "wallet", "walletpassphrasechange", &walletpassphrasechange, true },
	{ "wallet", "walletpassphrase", &walletpassphrase, true },
	#endif // ENABLE_WALLET
	};

	CRPCTable::CRPCTable()
	{
	unsigned int vcidx;
	for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
	{
	const CRPCCommand *pcmd;

	pcmd = &vRPCCommands[vcidx];
	mapCommands[pcmd->name] = pcmd;
	}
	}

	const CRPCCommand *CRPCTable::operator[](const std::string &name) const
	{
	map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
	if (it == mapCommands.end())
	return NULL;
	return (*it).second;
	}

	bool StartRPC()
	{
	LogPrint("rpc", "Starting RPC\n");
	fRPCRunning = true;
	g_rpcSignals.Started();
	return true;
	}

	void InterruptRPC()
	{
	LogPrint("rpc", "Interrupting RPC\n");
	// Interrupt e.g. running longpolls
	fRPCRunning = false;
	}

	void StopRPC()
	{
	LogPrint("rpc", "Stopping RPC\n");
	deadlineTimers.clear();
	g_rpcSignals.Stopped();
	}

	bool IsRPCRunning()
	{
	return fRPCRunning;
	}

	void SetRPCWarmupStatus(const std::string& newStatus)
	{
	LOCK(cs_rpcWarmup);
	rpcWarmupStatus = newStatus;
	}

	void SetRPCWarmupFinished()
	{
	LOCK(cs_rpcWarmup);
	assert(fRPCInWarmup);
	fRPCInWarmup = false;
	}

	bool RPCIsInWarmup(std::string *outStatus)
	{
	LOCK(cs_rpcWarmup);
	if (outStatus)
	*outStatus = rpcWarmupStatus;
	return fRPCInWarmup;
	}

	void JSONRequest::parse(const UniValue& valRequest)
	{
	// Parse request
	if (!valRequest.isObject())
	throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
	const UniValue& request = valRequest.get_obj();

	// Parse id now so errors from here on will have the id
	id = find_value(request, "id");

	// Parse method
	UniValue valMethod = find_value(request, "method");
	if (valMethod.isNull())
	throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
	if (!valMethod.isStr())
	throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
	strMethod = valMethod.get_str();
	if (strMethod != "getblocktemplate")
	LogPrint("rpc", "ThreadRPCServer method=%s\n", SanitizeString(strMethod));

	// Parse params
	UniValue valParams = find_value(request, "params");
	if (valParams.isArray())
	params = valParams.get_array();
	else if (valParams.isNull())
	params = UniValue(UniValue::VARR);
	else
	throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array");
	}

	static UniValue JSONRPCExecOne(const UniValue& req)
	{
	UniValue rpc_result(UniValue::VOBJ);

	JSONRequest jreq;
	try {
	jreq.parse(req);

	UniValue result = tableRPC.execute(jreq.strMethod, jreq.params);
	rpc_result = JSONRPCReplyObj(result, NullUniValue, jreq.id);
	}
	catch (const UniValue& objError)
	{
	rpc_result = JSONRPCReplyObj(NullUniValue, objError, jreq.id);
	}
	catch (const std::exception& e)
	{
	rpc_result = JSONRPCReplyObj(NullUniValue,
	JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
	}

	return rpc_result;
	}

	std::string JSONRPCExecBatch(const UniValue& vReq)
	{
	UniValue ret(UniValue::VARR);
	for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
	ret.push_back(JSONRPCExecOne(vReq[reqIdx]));

	return ret.write() + "\n";
	}

	UniValue CRPCTable::execute(const std::string &strMethod, const UniValue &params) const
	{
	// Return immediately if in warmup
	{
	LOCK(cs_rpcWarmup);
	if (fRPCInWarmup)
	throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
	}

	// Find method
	const CRPCCommand *pcmd = tableRPC[strMethod];
	if (!pcmd)
	throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");

	g_rpcSignals.PreCommand(*pcmd);

	try
	{
	// Execute
	return pcmd->actor(params, false);
	}
	catch (const std::exception& e)
	{
	throw JSONRPCError(RPC_MISC_ERROR, e.what());
	}

	g_rpcSignals.PostCommand(*pcmd);
	}

	std::string HelpExampleCli(const std::string& methodname, const std::string& args)
	{
	return "> bitcoin-cli " + methodname + " " + args + "\n";
	}

	std::string HelpExampleRpc(const std::string& methodname, const std::string& args)
	{
	return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
	"\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:8332/\n";
	}

	void RPCRegisterTimerInterface(RPCTimerInterface *iface)
	{
	timerInterfaces.push_back(iface);
	}

	void RPCUnregisterTimerInterface(RPCTimerInterface *iface)
	{
	std::vector<RPCTimerInterface*>::iterator i = std::find(timerInterfaces.begin(), timerInterfaces.end(), iface);
	assert(i != timerInterfaces.end());
	timerInterfaces.erase(i);
	}

	void RPCRunLater(const std::string& name, boost::function<void(void)> func, int64_t nSeconds)
	{
	if (timerInterfaces.empty())
	throw JSONRPCError(RPC_INTERNAL_ERROR, "No timer handler registered for RPC");
	deadlineTimers.erase(name);
	RPCTimerInterface* timerInterface = timerInterfaces[0];
	LogPrint("rpc", "queue run of timer %s in %i seconds (using %s)\n", name, nSeconds, timerInterface->Name());
	deadlineTimers.insert(std::make_pair(name, timerInterface->NewTimer(func, nSeconds*1000)));
	}

	const CRPCTable tableRPC;

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 11:13 (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5181514
Default Alt Text: (43 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions