LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity
lbrycrd/src/rpcserver.cpp

994 lines
39 KiB
C++
Raw Normal View History

integration of core bitcoin
2011-05-14 20:10:21 +02:00
// Copyright (c) 2010 Satoshi Nakamoto
Copyright header updates s/2013/2014 on files whose last git commit was done in 2014. contrib/devtools/fix-copyright-headers.py script to be able to perform this maintenance task with ease during the rest of the year, every year. Modifications to contrib/devtools/README.md to document what fix-copyright-headers.py does.
2014-02-08 22:50:24 +01:00
// Copyright (c) 2009-2014 The Bitcoin developers
integration of core bitcoin
2011-05-14 20:10:21 +02:00
// Distributed under the MIT/X11 software license, see the accompanying
Update License in File Headers I originally created a pull to replace the "COPYING" in crypter.cpp and crypter.h, but it turned out that COPYING was actually the correct file.
2012-05-18 16:02:28 +02:00
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Split up bitcoinrpc (code movement only) Split bitcoinrpc up into - rpcserver: bitcoind RPC server - rpcclient: bitcoin-cli RPC client - rpcprotocol: shared common HTTP/JSON-RPC protocol code One step towards making bitcoin-cli independent from the rest of the code, and thus a smaller executable that doesn't have to be linked against leveldb. This commit only does code movement, there are no functional changes.
2013-11-20 14:18:57 +01:00
#include "rpcserver.h"
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
#include "base58.h"
update bitcoin core from git (eeac8727bc0a951631bd)
2011-06-18 18:46:01 +02:00
#include "init.h"
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
#include "main.h"
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#include "ui_interface.h"
small headers ordering cleanup - keep headers in alphabetical order - fix Makefile.am (2 files in 1 line - leftover) - remove some spaces etc.
2014-01-11 18:14:29 +01:00
#include "util.h"
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#ifdef ENABLE_WALLET
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
#include "wallet.h"
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#endif
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
#include <boost/algorithm/string.hpp>
integration of core bitcoin
2011-05-14 20:10:21 +02:00
#include <boost/asio.hpp>
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
#include <boost/asio/ssl.hpp>
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
#include <boost/bind.hpp>
Key import and export Introduces two new RPC calls: * dumpprivkey: retrieve the private key corresponding to an address * importprivkey: add a private key to your wallet The private key format is analoguous to the address format. It is a 51-character base58-encoded string, that includes a version number and a checksum. Includes patch by mhanne: * add optional account parameter for importprivkey, if omitted use default
2011-07-13 11:56:38 +02:00
#include <boost/filesystem.hpp>
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
#include <boost/foreach.hpp>
integration of core bitcoin
2011-05-14 20:10:21 +02:00
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
#include <boost/shared_ptr.hpp>
Split up util.cpp/h Split up util.cpp/h into: - string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach) - money utilities (parsesmoney, formatmoney) - time utilities (gettime*, sleep, format date): - and the rest (logging, argument parsing, config file parsing) The latter is basically the environment and OS handling, and is stripped of all utility functions, so we may want to rename it to something else than util.cpp/h for clarity (Matt suggested osinterface). Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
#include <boost/thread.hpp>
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
#include "json/json_spirit_writer_template.h"
Remove USE_SSL #define
2012-04-05 03:19:27 +02:00
integration of core bitcoin
2011-05-14 20:10:21 +02:00
using namespace boost;
using namespace boost::asio;
using namespace json_spirit;
minor code format fix in rpc-related files
2014-06-27 11:13:25 +02:00
using namespace std;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Speed up RPC authentication (reworked pull from Joel Katz)
2011-12-01 15:07:02 +01:00
static std::string strRPCUserColonPass;
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
static bool fRPCRunning = false;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
// These are created by StartRPCThreads, destroyed in StopRPCThreads
static asio::io_service* rpc_io_service = NULL;
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
static ssl::context* rpc_ssl_context = NULL;
static boost::thread_group* rpc_worker_group = NULL;
qt: allow `walletpassphrase` in debug console without -server Currently it is only possible to use `walletpassphrase` to unlock the wallet when bitcoin is started in server mode. Almost everything that manipulates the wallet in the RPC console needs the wallet to be unlocked and is thus unusable without -server. This is pretty unintuitive to me, and I'm sure it's even more confusing to users. Solve this with a very minimal change: by making the GUI start a dummy RPC thread just to handle timeouts.
2014-01-17 16:32:35 +01:00
static boost::asio::io_service::work *rpc_dummy_work = NULL;
rpc: Use netmasks instead of wildcards for IP address matching `-rpcallowip` currently has a wacky wildcard-based format. After this commit it will accept the more standard format, for example: - Ranges with netmask 127.0.0.0/255.255.255.0, ::/0 - Ranges with cidr 12.3.4.5/24, 12:34:56:78:9a:bc:de:00/112 - Loose IPs ::1, 127.0.0.1 Trying to use the old *?-based format will result in an error message at launch.
2014-04-28 13:48:26 +02:00
static std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
static std::vector< boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
void RPCTypeCheck(const Array& params,
Allow signrawtransaction '...' null null 'hashtype' Allows the user to pass null as the second or third parameter to signrawtransaction, in case you need to (for example) fetch private keys from the wallet but want to specify the hash type.
2012-08-20 22:18:17 +02:00
const list<Value_type>& typesExpected,
bool fAllowNull)
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
{
Use unsigned ints to fix signed/unsigned warnings
2012-07-05 19:25:52 +02:00
unsigned int i = 0;
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
BOOST_FOREACH(Value_type t, typesExpected)
{
if (params.size() <= i)
break;
Allow signrawtransaction '...' null null 'hashtype' Allows the user to pass null as the second or third parameter to signrawtransaction, in case you need to (for example) fetch private keys from the wallet but want to specify the hash type.
2012-08-20 22:18:17 +02:00
const Value& v = params[i];
if (!((v.type() == t) || (fAllowNull && (v.type() == null_type))))
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
{
string err = strprintf("Expected type %s, got %s",
Value_type_name[t], Value_type_name[v.type()]);
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_TYPE_ERROR, err);
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
}
i++;
}
}
void RPCTypeCheck(const Object& o,
Allow signrawtransaction '...' null null 'hashtype' Allows the user to pass null as the second or third parameter to signrawtransaction, in case you need to (for example) fetch private keys from the wallet but want to specify the hash type.
2012-08-20 22:18:17 +02:00
const map<string, Value_type>& typesExpected,
bool fAllowNull)
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
{
BOOST_FOREACH(const PAIRTYPE(string, Value_type)& t, typesExpected)
{
const Value& v = find_value(o, t.first);
Allow signrawtransaction '...' null null 'hashtype' Allows the user to pass null as the second or third parameter to signrawtransaction, in case you need to (for example) fetch private keys from the wallet but want to specify the hash type.
2012-08-20 22:18:17 +02:00
if (!fAllowNull && v.type() == null_type)
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));
Allow signrawtransaction '...' null null 'hashtype' Allows the user to pass null as the second or third parameter to signrawtransaction, in case you need to (for example) fetch private keys from the wallet but want to specify the hash type.
2012-08-20 22:18:17 +02:00
if (!((v.type() == t.second) || (fAllowNull && (v.type() == null_type))))
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
{
string err = strprintf("Expected type %s for %s, got %s",
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
Value_type_name[t.second], t.first, Value_type_name[v.type()]);
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_TYPE_ERROR, err);
RPCTypeCheck method to make type-checking JSON Arrays easier.
2012-06-23 00:36:42 +02:00
}
}
}
Split up util.cpp/h Split up util.cpp/h into: - string utilities (hex, base32, base64): no internal dependencies, no dependency on boost (apart from foreach) - money utilities (parsesmoney, formatmoney) - time utilities (gettime*, sleep, format date): - and the rest (logging, argument parsing, config file parsing) The latter is basically the environment and OS handling, and is stripped of all utility functions, so we may want to rename it to something else than util.cpp/h for clarity (Matt suggested osinterface). Breaks dependency of sha256.cpp on all the things pulled in by util.
2014-08-21 16:11:09 +02:00
static inline int64_t roundint64(double d)
{
return (int64_t)(d > 0 ? d + 0.5 : d - 0.5);
}
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
int64_t AmountFromValue(const Value& value)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
double dAmount = value.get_real();
if (dAmount <= 0.0 || dAmount > 21000000.0)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
int64_t nAmount = roundint64(dAmount * COIN);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
if (!MoneyRange(nAmount))
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
integration of core bitcoin
2011-05-14 20:10:21 +02:00
return nAmount;
}
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
Value ValueFromAmount(int64_t amount)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
return (double)amount / (double)COIN;
}
Move Parse{Hash|Hex} to be usable by all RPC code
2013-07-15 08:24:33 +02:00
uint256 ParseHashV(const Value& v, string strName)
{
string strHex;
if (v.type() == str_type)
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 Object& o, string strKey)
{
return ParseHashV(find_value(o, strKey), strKey);
}
vector<unsigned char> ParseHexV(const Value& v, string strName)
{
string strHex;
if (v.type() == str_type)
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 Object& o, string strKey)
{
return ParseHexV(find_value(o, strKey), strKey);
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Second parameter to JSON-RPC getblock/gettransaction: decompositions This is an Object specifying how to decompose specific elements. Currently supported: - "tx": "no", "hash", "hex", "obj" - "script": "no", "hex", "asm"
2012-02-22 23:44:09 +01:00
integration of core bitcoin
2011-05-14 20:10:21 +02:00
///
/// Note: This interface may still be subject to change.
///
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
string CRPCTable::help(string strCommand) const
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
string strRet;
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
string category;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
set<rpcfn_type> setDone;
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
vector<pair<string, const CRPCCommand*> > vCommands;
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
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)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
const CRPCCommand *pcmd = command.second;
string strMethod = pcmd->name;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
// We already filter duplicates, but these deprecated screw up the sort order
JSON-RPC: remove 'getblocknumber' deprecated RPC RPC 'getblockcount' should be used instead.
2012-05-18 05:43:00 +02:00
if (strMethod.find("label") != string::npos)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
continue;
if (strCommand != "" && strMethod != strCommand)
continue;
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
2013-08-25 06:00:02 +02:00
if (pcmd->reqWallet && !pwalletMain)
continue;
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#endif
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
2013-08-25 06:00:02 +02:00
integration of core bitcoin
2011-05-14 20:10:21 +02:00
try
{
Array params;
Encapsulate RPC command dispatch in an array of CRPCCommand's
2012-04-15 05:55:05 +02:00
rpcfn_type pfn = pcmd->actor;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
if (setDone.insert(pfn).second)
(*pfn)(params, true);
}
catch (std::exception& e)
{
// Help text is returned in an exception
string strHelp = string(e.what());
if (strCommand == "")
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{
The string class returns string::npos, when find() fails. Noticed when sign-comparison warnings were enabled.
2012-04-15 22:47:24 +02:00
if (strHelp.find('\n') != string::npos)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
strHelp = strHelp.substr(0, strHelp.find('\n'));
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
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";
}
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
strRet += strHelp + "\n";
}
}
if (strRet == "")
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
strRet = strprintf("help: unknown command: %s\n", strCommand);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
strRet = strRet.substr(0,strRet.size()-1);
return strRet;
}
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
Value help(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
throw runtime_error(
Issue #1865 - Clean up RPC help messages Based on the proposal, update the help message of rpc methods - strings arguments are in double quotes rather than square brackets - numeric arguments have no quotes (and no default value) - optional parameters are surrounded by round brackets - json arguments are strings but don't use double quotes Added 3 sections for the details - Arguments: lists each argument, it's type, required or not, a default, and a description - Result: The method result, with json format if applicable, type, and a description - Examples: examples calls using bitcoin-cli and curl for json rpc call Problems - maybe this is too verbose - lines might be too long - description are not good or complete - examples may be too much
2013-10-29 12:29:44 +01:00
"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"
);
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
string strCommand;
if (params.size() > 0)
strCommand = params[0].get_str();
return tableRPC.help(strCommand);
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Value stop(const Array& params, bool fHelp)
{
make bitcoinrpc.cpp UTF-8 conformant again - just replaces a character in a comment, which I had problems with when opening the file in Qt Creator IDE
2013-01-20 18:50:30 +01:00
// Accept the deprecated and ignored 'detach' boolean argument
Adds a stopdetach <detach> RPC command. <detach> defaults to true. Works just like stop, but overrides the commandline/config file -detachdb option. Useful for upgrading, for example. Lets you use fast stops usually, but force a detach when needed. Also, allows you to do a fast stop in a system normally configured for fast stops.
2012-09-19 04:54:43 +02:00
if (fHelp || params.size() > 1)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
throw runtime_error(
Remove -detachdb and stop's detach argument. As the only BDB database left is the wallet, and it is always detached. Also remove IsChainFile() predicate and related chainfile-specific logic.
2012-11-04 12:48:45 +01:00
"stop\n"
Issue #1865 - Clean up RPC help messages Based on the proposal, update the help message of rpc methods - strings arguments are in double quotes rather than square brackets - numeric arguments have no quotes (and no default value) - optional parameters are surrounded by round brackets - json arguments are strings but don't use double quotes Added 3 sections for the details - Arguments: lists each argument, it's type, required or not, a default, and a description - Result: The method result, with json format if applicable, type, and a description - Examples: examples calls using bitcoin-cli and curl for json rpc call Problems - maybe this is too verbose - lines might be too long - description are not good or complete - examples may be too much
2013-10-29 12:29:44 +01:00
"\nStop Bitcoin server.");
integration of core bitcoin
2011-05-14 20:10:21 +02:00
// Shutdown will take long enough that the response should get back
introduce a new StartShutdown() function, which starts a thread with Shutdown() if no GUI is used and calls uiInterface.QueueShutdown() if a GUI is used / all direct uiInterface.QueueShutdown() calls are replaced with Shutdown() - this ensures a clean GUI shutdown, even when catching a SIGTERM and allows the BitcoinGUI destructor to get called (which fixes a tray-icon issue and keeps the tray-icon until Bitcoin-Qt exits)
2012-06-11 07:40:14 +02:00
StartShutdown();
change strings to Bitcoin (uppercase), where it is used as a noun and update strings to use "Qt" (and not qt or QT) / update initialisation of notificator to use qApp->applicationName() instead of a static string
2012-05-13 16:09:14 +02:00
return "Bitcoin server stopping";
integration of core bitcoin
2011-05-14 20:10:21 +02:00
}
//
// Call Table
//
Encapsulate RPC command dispatch in an array of CRPCCommand's
2012-04-15 05:55:05 +02:00
Expose CRPCTable via bitcoinrpc.h for testing
2012-04-21 01:37:34 +02:00
static const CRPCCommand vRPCCommands[] =
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ // category name actor (function) okSafeMode threadSafe reqWallet
// --------------------- ------------------------ ----------------------- ---------- ---------- ---------
Organize RPCCommands table Use sensible categories (overall control, P2P, blockchain/UTXO and mining, wallet, wallet-enabled mining) and sort within each. Also remove unnecessary #ifdef ENABLE_WALLET from `rpcnet.cpp`. Functionality-neutral change.
2014-03-26 12:26:43 +01:00
/* Overall control/query calls */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "control", "getinfo", &getinfo, true, false, false }, /* uses wallet if enabled */
{ "control", "help", &help, true, true, false },
{ "control", "stop", &stop, true, true, false },
Organize RPCCommands table Use sensible categories (overall control, P2P, blockchain/UTXO and mining, wallet, wallet-enabled mining) and sort within each. Also remove unnecessary #ifdef ENABLE_WALLET from `rpcnet.cpp`. Functionality-neutral change.
2014-03-26 12:26:43 +01:00
/* P2P networking */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "network", "getnetworkinfo", &getnetworkinfo, true, false, false },
{ "network", "addnode", &addnode, true, true, false },
{ "network", "getaddednodeinfo", &getaddednodeinfo, true, true, false },
{ "network", "getconnectioncount", &getconnectioncount, true, false, false },
{ "network", "getnettotals", &getnettotals, true, true, false },
{ "network", "getpeerinfo", &getpeerinfo, true, false, false },
{ "network", "ping", &ping, true, false, false },
Organize RPCCommands table Use sensible categories (overall control, P2P, blockchain/UTXO and mining, wallet, wallet-enabled mining) and sort within each. Also remove unnecessary #ifdef ENABLE_WALLET from `rpcnet.cpp`. Functionality-neutral change.
2014-03-26 12:26:43 +01:00
/* Block chain and UTXO */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "blockchain", "getblockchaininfo", &getblockchaininfo, true, false, false },
{ "blockchain", "getbestblockhash", &getbestblockhash, true, false, false },
{ "blockchain", "getblockcount", &getblockcount, true, false, false },
{ "blockchain", "getblock", &getblock, true, false, false },
{ "blockchain", "getblockhash", &getblockhash, true, false, false },
{ "blockchain", "getchaintips", &getchaintips, true, false, false },
{ "blockchain", "getdifficulty", &getdifficulty, true, false, false },
Closely track mempool byte total. Add "getmempoolinfo" RPC. Goal: Gain live insight into the mempool. Groundwork for future work that caps mempool size.
2014-08-07 05:58:19 +02:00
{ "blockchain", "getmempoolinfo", &getmempoolinfo, true, true, false },
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "blockchain", "getrawmempool", &getrawmempool, true, false, false },
{ "blockchain", "gettxout", &gettxout, true, false, false },
{ "blockchain", "gettxoutsetinfo", &gettxoutsetinfo, true, false, false },
{ "blockchain", "verifychain", &verifychain, true, false, false },
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
Allow mining RPCs with --disable-wallet The following mining-related RPC calls don't use the wallet: - getnetworkhashps - getmininginfo - getblocktemplate - submitblock Enable them when compiling with --disable-wallet.
2013-12-08 15:26:08 +01:00
/* Mining */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "mining", "getblocktemplate", &getblocktemplate, true, false, false },
{ "mining", "getmininginfo", &getmininginfo, true, false, false },
{ "mining", "getnetworkhashps", &getnetworkhashps, true, false, false },
{ "mining", "prioritisetransaction", &prioritisetransaction, true, false, false },
{ "mining", "submitblock", &submitblock, true, true, false },
#ifdef ENABLE_WALLET
/* Coin generation */
{ "generating", "getgenerate", &getgenerate, true, false, false },
{ "generating", "gethashespersec", &gethashespersec, true, false, false },
{ "generating", "setgenerate", &setgenerate, true, true, false },
#endif
Organize RPCCommands table Use sensible categories (overall control, P2P, blockchain/UTXO and mining, wallet, wallet-enabled mining) and sort within each. Also remove unnecessary #ifdef ENABLE_WALLET from `rpcnet.cpp`. Functionality-neutral change.
2014-03-26 12:26:43 +01:00
/* Raw transactions */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "rawtransactions", "createrawtransaction", &createrawtransaction, true, false, false },
{ "rawtransactions", "decoderawtransaction", &decoderawtransaction, true, false, false },
{ "rawtransactions", "decodescript", &decodescript, true, false, false },
{ "rawtransactions", "getrawtransaction", &getrawtransaction, true, false, false },
{ "rawtransactions", "sendrawtransaction", &sendrawtransaction, false, false, false },
{ "rawtransactions", "signrawtransaction", &signrawtransaction, false, false, false }, /* uses wallet if enabled */
Organize RPCCommands table Use sensible categories (overall control, P2P, blockchain/UTXO and mining, wallet, wallet-enabled mining) and sort within each. Also remove unnecessary #ifdef ENABLE_WALLET from `rpcnet.cpp`. Functionality-neutral change.
2014-03-26 12:26:43 +01:00
/* Utility functions */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "util", "createmultisig", &createmultisig, true, true , false },
{ "util", "validateaddress", &validateaddress, true, false, false }, /* uses wallet if enabled */
{ "util", "verifymessage", &verifymessage, true, false, false },
{ "util", "estimatefee", &estimatefee, true, true, false },
{ "util", "estimatepriority", &estimatepriority, true, true, false },
Allow mining RPCs with --disable-wallet The following mining-related RPC calls don't use the wallet: - getnetworkhashps - getmininginfo - getblocktemplate - submitblock Enable them when compiling with --disable-wallet.
2013-12-08 15:26:08 +01:00
#ifdef ENABLE_WALLET
/* Wallet */
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
2014-07-15 21:38:52 +02:00
{ "wallet", "addmultisigaddress", &addmultisigaddress, true, false, true },
{ "wallet", "backupwallet", &backupwallet, true, false, true },
{ "wallet", "dumpprivkey", &dumpprivkey, true, false, true },
{ "wallet", "dumpwallet", &dumpwallet, true, false, true },
{ "wallet", "encryptwallet", &encryptwallet, true, false, true },
{ "wallet", "getaccountaddress", &getaccountaddress, true, false, true },
{ "wallet", "getaccount", &getaccount, true, false, true },
{ "wallet", "getaddressesbyaccount", &getaddressesbyaccount, true, false, true },
{ "wallet", "getbalance", &getbalance, false, false, true },
{ "wallet", "getnewaddress", &getnewaddress, true, false, true },
{ "wallet", "getrawchangeaddress", &getrawchangeaddress, true, false, true },
{ "wallet", "getreceivedbyaccount", &getreceivedbyaccount, false, false, true },
{ "wallet", "getreceivedbyaddress", &getreceivedbyaddress, false, false, true },
{ "wallet", "gettransaction", &gettransaction, false, false, true },
{ "wallet", "getunconfirmedbalance", &getunconfirmedbalance, false, false, true },
{ "wallet", "getwalletinfo", &getwalletinfo, false, false, true },
{ "wallet", "importprivkey", &importprivkey, true, false, true },
{ "wallet", "importwallet", &importwallet, true, false, true },
{ "wallet", "importaddress", &importaddress, true, false, true },
{ "wallet", "keypoolrefill", &keypoolrefill, true, false, true },
{ "wallet", "listaccounts", &listaccounts, false, false, true },
{ "wallet", "listaddressgroupings", &listaddressgroupings, false, false, true },
{ "wallet", "listlockunspent", &listlockunspent, false, false, true },
{ "wallet", "listreceivedbyaccount", &listreceivedbyaccount, false, false, true },
{ "wallet", "listreceivedbyaddress", &listreceivedbyaddress, false, false, true },
{ "wallet", "listsinceblock", &listsinceblock, false, false, true },
{ "wallet", "listtransactions", &listtransactions, false, false, true },
{ "wallet", "listunspent", &listunspent, false, false, true },
{ "wallet", "lockunspent", &lockunspent, true, false, true },
{ "wallet", "move", &movecmd, false, false, true },
{ "wallet", "sendfrom", &sendfrom, false, false, true },
{ "wallet", "sendmany", &sendmany, false, false, true },
{ "wallet", "sendtoaddress", &sendtoaddress, false, false, true },
{ "wallet", "setaccount", &setaccount, true, false, true },
{ "wallet", "settxfee", &settxfee, true, false, true },
{ "wallet", "signmessage", &signmessage, true, false, true },
{ "wallet", "walletlock", &walletlock, true, false, true },
{ "wallet", "walletpassphrasechange", &walletpassphrasechange, true, false, true },
{ "wallet", "walletpassphrase", &walletpassphrase, true, false, true },
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#endif // ENABLE_WALLET
integration of core bitcoin
2011-05-14 20:10:21 +02:00
};
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
CRPCTable::CRPCTable()
Encapsulate RPC command dispatch in an array of CRPCCommand's
2012-04-15 05:55:05 +02:00
{
unsigned int vcidx;
for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
{
Expose CRPCTable via bitcoinrpc.h for testing
2012-04-21 01:37:34 +02:00
const CRPCCommand *pcmd;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Encapsulate RPC command dispatch in an array of CRPCCommand's
2012-04-15 05:55:05 +02:00
pcmd = &vRPCCommands[vcidx];
mapCommands[pcmd->name] = pcmd;
}
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Encapsulate mapCommands in class CRPCTable
2012-04-18 22:42:17 +02:00
const CRPCCommand *CRPCTable::operator[](string name) const
{
map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
if (it == mapCommands.end())
return NULL;
return (*it).second;
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
bool HTTPAuthorized(map<string, string>& mapHeaders)
{
string strAuth = mapHeaders["authorization"];
if (strAuth.substr(0,6) != "Basic ")
return false;
string strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
string strUserPass = DecodeBase64(strUserPass64);
Make RPC password resistant to timing attacks Fixes issue#2838; this is a tweaked version of pull#2845 that should not leak the length of the password and is more generic, in case we run into other situations where we need timing-attack-resistant comparisons.
2013-08-08 11:58:57 +02:00
return TimingResistantEqual(strUserPass, strRPCUserColonPass);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
}
void ErrorReply(std::ostream& stream, const Object& objError, const Value& id)
{
// Send error reply from json-rpc error object
Add constants for HTTP status codes
2012-10-04 10:43:40 +02:00
int nStatus = HTTP_INTERNAL_SERVER_ERROR;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
int code = find_value(objError, "code").get_int();
Add constants for HTTP status codes
2012-10-04 10:43:40 +02:00
if (code == RPC_INVALID_REQUEST) nStatus = HTTP_BAD_REQUEST;
else if (code == RPC_METHOD_NOT_FOUND) nStatus = HTTP_NOT_FOUND;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
string strReply = JSONRPCReply(Value::null, objError, id);
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
2012-04-24 07:10:02 +02:00
stream << HTTPReply(nStatus, strReply, false) << std::flush;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
}
Add tests for BoostAsioToCNetAddr
2014-04-28 15:23:29 +02:00
CNetAddr BoostAsioToCNetAddr(boost::asio::ip::address address)
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
rpc: Use netmasks instead of wildcards for IP address matching `-rpcallowip` currently has a wacky wildcard-based format. After this commit it will accept the more standard format, for example: - Ranges with netmask 127.0.0.0/255.255.255.0, ::/0 - Ranges with cidr 12.3.4.5/24, 12:34:56:78:9a:bc:de:00/112 - Loose IPs ::1, 127.0.0.1 Trying to use the old *?-based format will result in an error message at launch.
2014-04-28 13:48:26 +02:00
CNetAddr netaddr;
Allow clients on the IPv6 loopback as well Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 14:21:43 +02:00
// Make sure that IPv4-compatible and IPv4-mapped IPv6 addresses are treated as IPv4 addresses
if (address.is_v6()
&& (address.to_v6().is_v4_compatible()
|| address.to_v6().is_v4_mapped()))
rpc: Use netmasks instead of wildcards for IP address matching `-rpcallowip` currently has a wacky wildcard-based format. After this commit it will accept the more standard format, for example: - Ranges with netmask 127.0.0.0/255.255.255.0, ::/0 - Ranges with cidr 12.3.4.5/24, 12:34:56:78:9a:bc:de:00/112 - Loose IPs ::1, 127.0.0.1 Trying to use the old *?-based format will result in an error message at launch.
2014-04-28 13:48:26 +02:00
address = address.to_v6().to_v4();
if(address.is_v4())
{
boost::asio::ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
netaddr.SetRaw(NET_IPV4, &bytes[0]);
}
else
{
boost::asio::ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
netaddr.SetRaw(NET_IPV6, &bytes[0]);
}
return netaddr;
}
bool ClientAllowed(const boost::asio::ip::address& address)
{
CNetAddr netaddr = BoostAsioToCNetAddr(address);
BOOST_FOREACH(const CSubNet &subnet, rpc_allow_subnets)
if (subnet.Match(netaddr))
integration of core bitcoin
2011-05-14 20:10:21 +02:00
return true;
return false;
}
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
template <typename Protocol>
class AcceptedConnectionImpl : public AcceptedConnection
{
public:
AcceptedConnectionImpl(
asio::io_service& io_service,
ssl::context &context,
bool fUseSSL) :
sslStream(io_service, context),
_d(sslStream, fUseSSL),
_stream(_d)
{
}
virtual std::iostream& stream()
{
return _stream;
}
virtual std::string peer_address_to_string() const
{
return peer.address().to_string();
}
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
virtual void close()
{
_stream.close();
}
typename Protocol::endpoint peer;
asio::ssl::stream<typename Protocol::socket> sslStream;
private:
SSLIOStreamDevice<Protocol> _d;
iostreams::stream< SSLIOStreamDevice<Protocol> > _stream;
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
};
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
void ServiceConnection(AcceptedConnection *conn);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
// Forward declaration required for RPCListen
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
template <typename Protocol, typename SocketAcceptorService>
static void RPCAcceptHandler(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
ssl::context& context,
bool fUseSSL,
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
boost::shared_ptr< AcceptedConnection > conn,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
const boost::system::error_code& error);
/**
* Sets up I/O resources to accept and handle a new connection.
*/
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
template <typename Protocol, typename SocketAcceptorService>
static void RPCListen(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
ssl::context& context,
const bool fUseSSL)
{
// Accept connection
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
boost::shared_ptr< AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(acceptor->get_io_service(), context, fUseSSL));
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
acceptor->async_accept(
conn->sslStream.lowest_layer(),
conn->peer,
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
boost::bind(&RPCAcceptHandler<Protocol, SocketAcceptorService>,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
acceptor,
boost::ref(context),
fUseSSL,
conn,
rpc: pass errors from async_accept According to the [boost::asio documentation](http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload2.html), the function signature of the handler must be: void handler( const boost::system::error_code& error // Result of operation. ); We were binding *all* the arguments, instead of all but the error, resulting in nullary function that never got the error. Fix this by adding an input argument substitution.
2014-05-07 09:09:13 +02:00
_1));
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
}
Split up bitcoinrpc (code movement only) Split bitcoinrpc up into - rpcserver: bitcoind RPC server - rpcclient: bitcoin-cli RPC client - rpcprotocol: shared common HTTP/JSON-RPC protocol code One step towards making bitcoin-cli independent from the rest of the code, and thus a smaller executable that doesn't have to be linked against leveldb. This commit only does code movement, there are no functional changes.
2013-11-20 14:18:57 +01:00
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
/**
* Accept and handle incoming connection.
*/
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
template <typename Protocol, typename SocketAcceptorService>
static void RPCAcceptHandler(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
ssl::context& context,
const bool fUseSSL,
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
boost::shared_ptr< AcceptedConnection > conn,
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
const boost::system::error_code& error)
{
Bugfix: Fix a variety of misspellings
2012-07-26 02:48:39 +02:00
// Immediately start accepting new connections, except when we're cancelled or our socket is closed.
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
if (error != asio::error::operation_aborted && acceptor->is_open())
Cancel outstanding listen ops for RPC when shutting down Use Boost's signal2 slot tracking mechanism to cancel any (still open) listening sockets when receiving a shutdown signal. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2012-06-24 13:20:17 +02:00
RPCListen(acceptor, context, fUseSSL);
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
AcceptedConnectionImpl<ip::tcp>* tcp_conn = dynamic_cast< AcceptedConnectionImpl<ip::tcp>* >(conn.get());
Generalise RPC connection handling code to allow more listening sockets Using this modification it should be relatively easy to, at a later time, listen on multiple addresses (even Unix domain sockets should be possible). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 15:07:46 +02:00
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
if (error)
{
rpc: pass errors from async_accept According to the [boost::asio documentation](http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload2.html), the function signature of the handler must be: void handler( const boost::system::error_code& error // Result of operation. ); We were binding *all* the arguments, instead of all but the error, resulting in nullary function that never got the error. Fix this by adding an input argument substitution.
2014-05-07 09:09:13 +02:00
// TODO: Actually handle errors
LogPrintf("%s: Error: %s\n", __func__, error.message());
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
}
// Restrict callers by IP. It is important to
// do this before starting client thread, to filter out
// certain DoS and misbehaving clients.
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
else if (tcp_conn && !ClientAllowed(tcp_conn->peer.address()))
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
{
// Only send a 403 if we're not using SSL to prevent a DoS during the SSL handshake.
if (!fUseSSL)
fix RPC error replies After pull #4288, RPC messages indicating errors have a Content-Length unrelated to their actual contents, rendering bitcoin-cli and curl unable to decode the reply. This patch sets the Content-Length field based on the actual content returned. Additionally, pull #4288 clobbered the error descriptions provided in ErrorReply, which bitcoin-cli relies upon; this patch moves #4288 http-error descriptions to an HTTPError method, allowing HTTPReply to pass content on unchanged.
2014-06-29 03:14:36 +02:00
conn->stream() << HTTPError(HTTP_FORBIDDEN, false) << std::flush;
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
conn->close();
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
}
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
else {
rpc: Make sure conn object is always cleaned up Make sure conn object always gets cleaned up by using a `boost::shared_ptr`. This makes valgrind happy - before this commit, one connection object always leaked at shutdown, as well as can avoid other leaks, when for example an exception happens. Also add an explicit Close() to the !ClientAllowed path to make it similar to the normal path (I'm not sure whether it is needed, but it can't hurt).
2014-05-07 09:24:44 +02:00
ServiceConnection(conn.get());
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
conn->close();
Use asynchronous I/O to handle RPC requests This allows more flexibility in the RPC code, e.g. making it easier to handle multiple simultaneous connections later on. Currently asynchronous I/O is only used to listen for and accept incoming connections. Asynchronous reading/writing is more involved. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 13:53:13 +02:00
}
}
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
static ip::tcp::endpoint ParseEndpoint(const std::string &strEndpoint, int defaultPort)
{
std::string addr;
int port = defaultPort;
SplitHostPort(strEndpoint, port, addr);
return ip::tcp::endpoint(asio::ip::address::from_string(addr), port);
}
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
void StartRPCThreads()
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
rpc: Use netmasks instead of wildcards for IP address matching `-rpcallowip` currently has a wacky wildcard-based format. After this commit it will accept the more standard format, for example: - Ranges with netmask 127.0.0.0/255.255.255.0, ::/0 - Ranges with cidr 12.3.4.5/24, 12:34:56:78:9a:bc:de:00/112 - Loose IPs ::1, 127.0.0.1 Trying to use the old *?-based format will result in an error message at launch.
2014-04-28 13:48:26 +02:00
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 vector<string>& vAllow = mapMultiArgs["-rpcallowip"];
BOOST_FOREACH(string strAllow, vAllow)
{
CSubNet subnet(strAllow);
if(!subnet.IsValid())
{
uiInterface.ThreadSafeMessageBox(
Clarify error message when invalid -rpcallowip Also add to HelpMessage() what specifications are valid.
2014-07-03 06:26:03 +02:00
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),
rpc: Use netmasks instead of wildcards for IP address matching `-rpcallowip` currently has a wacky wildcard-based format. After this commit it will accept the more standard format, for example: - Ranges with netmask 127.0.0.0/255.255.255.0, ::/0 - Ranges with cidr 12.3.4.5/24, 12:34:56:78:9a:bc:de:00/112 - Loose IPs ::1, 127.0.0.1 Trying to use the old *?-based format will result in an error message at launch.
2014-04-28 13:48:26 +02:00
"", CClientUIInterface::MSG_ERROR);
StartShutdown();
return;
}
rpc_allow_subnets.push_back(subnet);
}
}
std::string strAllowed;
BOOST_FOREACH(const CSubNet &subnet, rpc_allow_subnets)
strAllowed += subnet.ToString() + " ";
LogPrint("rpc", "Allowing RPC connections from: %s\n", strAllowed);
Speed up RPC authentication (reworked pull from Joel Katz)
2011-12-01 15:07:02 +01:00
strRPCUserColonPass = mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"];
Introduce a CChainParameters singleton class and regtest mode. The new class is accessed via the Params() method and holds most things that vary between main, test and regtest networks. The regtest mode has two purposes, one is to run the bitcoind/bitcoinj comparison tool which compares two separate implementations of the Bitcoin protocol looking for divergence. The other is that when run, you get a local node which can mine a single block instantly, which is highly convenient for testing apps during development as there's no need to wait 10 minutes for a block on the testnet.
2013-05-07 15:16:25 +02:00
if (((mapArgs["-rpcpassword"] == "") ||
(mapArgs["-rpcuser"] == mapArgs["-rpcpassword"])) && Params().RequireRPCPassword())
integration of core bitcoin
2011-05-14 20:10:21 +02:00
{
Have bitcoind recommend a secure RPC password. Increase invalid password delay. Help users avoid insecure configurations a bit by recommending a secure RPC password and increasing the incorrect password delay. This may open up a RPC DOS for users with exposed RPC ports and short passwords. Since users shouldn't have exposed RPC ports OR short passwords, the DOS risk is preferable to the compromise risk. Also logs the client IP address for incorrect attempts.
2012-02-05 08:30:43 +01:00
unsigned char rand_pwd[32];
add GetRandBytes() as wrapper for RAND_bytes() - add a small wrapper in util around RAND_bytes() and replace with GetRandBytes() in the code to log errors from calling RAND_bytes() - remove OpenSSL header rand.h where no longer needed
2014-06-24 14:27:32 +02:00
GetRandBytes(rand_pwd, 32);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
string strWhatAmI = "To use bitcoind";
if (mapArgs.count("-server"))
strWhatAmI = strprintf(_("To use the %s option"), "\"-server\"");
else if (mapArgs.count("-daemon"))
strWhatAmI = strprintf(_("To use the %s option"), "\"-daemon\"");
Convert UI interface to boost::signals2. - Signals now go directly from the core to WalletModel/ClientModel. - WalletModel subscribes to signals on CWallet: Prepares for multi-wallet support, by no longer assuming an implicit global wallet. - Gets rid of noui.cpp, the few lines that were left are merged into init.cpp - Rename wxXXX message flags to MF_XXX, to make them UI indifferent. - ThreadSafeMessageBox no longer returns the value `4` which was never used, converted to void.
2012-05-06 19:40:58 +02:00
uiInterface.ThreadSafeMessageBox(strprintf(
translation base files update 2013-04-02 - also includes a small change to a string in bitcoinrpc.cpp, which is not on Transifex anyway, so is safe to merge
2013-04-02 15:45:08 +02:00
_("%s, you must set a rpcpassword in the configuration file:\n"
"%s\n"
Use a messagebox to display the error when -server is provided without providing a rpc password
2012-03-31 15:08:25 +02:00
"It is recommended you use the following random password:\n"
"rpcuser=bitcoinrpc\n"
"rpcpassword=%s\n"
"(you do not need to remember this password)\n"
RPC: Forbid RPC username == RPC password Added security measure.
2012-11-05 07:41:53 +01:00
"The username and password MUST NOT be the same.\n"
Recommend alertnotify
2013-03-21 15:08:21 +01:00
"If the file does not exist, create it with owner-readable-only file permissions.\n"
"It is also recommended to set alertnotify so you are notified of problems;\n"
"for example: alertnotify=echo %%s | mail -s \"Bitcoin Alert\" admin@foo.com\n"),
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
strWhatAmI,
GetConfigFile().string(),
EncodeBase58(&rand_pwd[0],&rand_pwd[0]+32)),
update CClientUIInterface and remove orphan Wx stuff - fix ThreadSafeMessageBox always displays error icon - allow to specify MSG_ERROR / MSG_WARNING or MSG_INFORMATION without a custom caption / title - allow to specify CClientUIInterface::ICON_ERROR / ICON_WARNING and ICON_INFORMATION (which is default) as message box icon - remove CClientUIInterface::OK from ThreadSafeMessageBox-calls, as the OK button will be set as default, if none is specified - prepend "Bitcoin - " to used captions - rename BitcoinGUI::error() -> BitcoinGUI::message() and add function documentation - change all style parameters and enum flags to unsigned - update code to use that new API - update Client- and WalletModel to use new BitcoinGUI::message() and rename the classes error() method into message() - include the possibility to supply the wanted icon for messages from Client- and WalletModel via "style" parameter
2012-11-05 08:04:21 +01:00
"", CClientUIInterface::MSG_ERROR);
introduce a new StartShutdown() function, which starts a thread with Shutdown() if no GUI is used and calls uiInterface.QueueShutdown() if a GUI is used / all direct uiInterface.QueueShutdown() calls are replaced with Shutdown() - this ensures a clean GUI shutdown, even when catching a SIGTERM and allows the BitcoinGUI destructor to get called (which fixes a tray-icon issue and keeps the tray-icon until Bitcoin-Qt exits)
2012-06-11 07:40:14 +02:00
StartShutdown();
integration of core bitcoin
2011-05-14 20:10:21 +02:00
return;
}
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
assert(rpc_io_service == NULL);
rpc_io_service = new asio::io_service();
rpc_ssl_context = new ssl::context(*rpc_io_service, ssl::context::sslv23);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
remove GetBoolArg() fDefault parameter defaulting to false - explicitly set the default of all GetBoolArg() calls - rework getarg_test.cpp and util_tests.cpp to cover this change - some indentation fixes - move macdockiconhandler.h include in bitcoin.cpp to the "our headers" section
2013-04-28 17:37:50 +02:00
const bool fUseSSL = GetBoolArg("-rpcssl", false);
Use the QueueShutdown signal to stop accepting new RPC connections Signed-off-by: Giel van Schijndel <me@mortis.eu>
2012-05-20 20:27:53 +02:00
integration of core bitcoin
2011-05-14 20:10:21 +02:00
if (fUseSSL)
{
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
rpc_ssl_context->set_options(ssl::context::no_sslv2);
updated bitcoinrpc.cpp to use make_preferred() and removed double inclusion of boost/filesystem.hpp
2012-03-31 15:05:55 +02:00
filesystem::path pathCertFile(GetArg("-rpcsslcertificatechainfile", "server.cert"));
if (!pathCertFile.is_complete()) pathCertFile = filesystem::path(GetDataDir()) / pathCertFile;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
if (filesystem::exists(pathCertFile)) rpc_ssl_context->use_certificate_chain_file(pathCertFile.string());
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
else LogPrintf("ThreadRPCServer ERROR: missing server certificate file %s\n", pathCertFile.string());
updated bitcoinrpc.cpp to use make_preferred() and removed double inclusion of boost/filesystem.hpp
2012-03-31 15:05:55 +02:00
filesystem::path pathPKFile(GetArg("-rpcsslprivatekeyfile", "server.pem"));
if (!pathPKFile.is_complete()) pathPKFile = filesystem::path(GetDataDir()) / pathPKFile;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
if (filesystem::exists(pathPKFile)) rpc_ssl_context->use_private_key_file(pathPKFile.string(), ssl::context::pem);
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
else LogPrintf("ThreadRPCServer ERROR: missing server private key file %s\n", pathPKFile.string());
updated bitcoinrpc.cpp to use make_preferred() and removed double inclusion of boost/filesystem.hpp
2012-03-31 15:05:55 +02:00
update default -rpcsslciphers to include TLSv1.2 - this extends the accepted ciphersuites with TLSv1.2 ones - also removes !AH, as I could not find documentation on it and the change did not result in a changed ciphersuite list (checked via openssl ciphers -v) - closes #3096 (which also contains more details)
2013-10-17 16:11:25 +02:00
string strCiphers = GetArg("-rpcsslciphers", "TLSv1.2+HIGH:TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!3DES:@STRENGTH");
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
SSL_CTX_set_cipher_list(rpc_ssl_context->impl(), strCiphers.c_str());
integration of core bitcoin
2011-05-14 20:10:21 +02:00
}
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
std::vector<ip::tcp::endpoint> vEndpoints;
bool bBindAny = false;
Remove unnecessary dependencies for bitcoin-cli This commit removes all the unnecessary dependencies (key, core, netbase, sync, ...) from bitcoin-cli. To do this it shards the chain parameters into BaseParams, which contains just the RPC port and data directory (as used by utils and bitcoin-cli) and Params, with the rest.
2014-06-19 15:10:04 +02:00
int defaultPort = GetArg("-rpcport", BaseParams().RPCPort());
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
if (!mapArgs.count("-rpcallowip")) // Default to loopback if not allowing external IPs
{
vEndpoints.push_back(ip::tcp::endpoint(asio::ip::address_v6::loopback(), defaultPort));
vEndpoints.push_back(ip::tcp::endpoint(asio::ip::address_v4::loopback(), 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
{
BOOST_FOREACH(const std::string &addr, mapMultiArgs["-rpcbind"])
{
try {
vEndpoints.push_back(ParseEndpoint(addr, defaultPort));
}
Fixing compiler warning C4101 Github-Pull: #4856
2014-09-05 17:37:01 +02:00
catch(const boost::system::system_error &)
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
{
uiInterface.ThreadSafeMessageBox(
strprintf(_("Could not parse -rpcbind value %s as network address"), addr),
"", CClientUIInterface::MSG_ERROR);
StartShutdown();
return;
}
}
} else { // No specific bind address specified, bind to any
vEndpoints.push_back(ip::tcp::endpoint(asio::ip::address_v6::any(), defaultPort));
vEndpoints.push_back(ip::tcp::endpoint(asio::ip::address_v4::any(), defaultPort));
// Prefer making the socket dual IPv6/IPv4 instead of binding
// to both addresses seperately.
bBindAny = true;
}
Use a rpc-specific queue to tell asio connections to shutdown.
2012-06-28 18:32:32 +02:00
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
2012-09-12 16:45:01 +02:00
bool fListening = false;
std::string strerr;
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
BOOST_FOREACH(const ip::tcp::endpoint &endpoint, vEndpoints)
Add dual IPv4/IPv6 stack support to the RPC server The RPC server now listens for, and handles, incoming connections on both IPv4 as well as IPv6. If available (and usable) it uses a dual IPv4/IPv6 socket on systems that support it (e.g. Linux and BSDs) and falls back to separate IPv4/IPv6 sockets on systems that don't (e.g. Windows). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 14:17:02 +02:00
{
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
asio::ip::address bindAddress = endpoint.address();
LogPrintf("Binding RPC on address %s port %i (IPv4+IPv6 bind any: %i)\n", bindAddress.to_string(), endpoint.port(), bBindAny);
boost::system::error_code v6_only_error;
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
boost::shared_ptr<ip::tcp::acceptor> acceptor(new ip::tcp::acceptor(*rpc_io_service));
Add dual IPv4/IPv6 stack support to the RPC server The RPC server now listens for, and handles, incoming connections on both IPv4 as well as IPv6. If available (and usable) it uses a dual IPv4/IPv6 socket on systems that support it (e.g. Linux and BSDs) and falls back to separate IPv4/IPv6 sockets on systems that don't (e.g. Windows). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 14:17:02 +02:00
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
try {
Cancel outstanding listen ops for RPC when shutting down Use Boost's signal2 slot tracking mechanism to cancel any (still open) listening sockets when receiving a shutdown signal. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2012-06-24 13:20:17 +02:00
acceptor->open(endpoint.protocol());
acceptor->set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
// Try making the socket dual IPv6/IPv4 when listening on the IPv6 "any" address
acceptor->set_option(boost::asio::ip::v6_only(
!bBindAny || bindAddress != asio::ip::address_v6::any()), v6_only_error);
Cancel outstanding listen ops for RPC when shutting down Use Boost's signal2 slot tracking mechanism to cancel any (still open) listening sockets when receiving a shutdown signal. Signed-off-by: Giel van Schijndel <me@mortis.eu>
2012-06-24 13:20:17 +02:00
acceptor->bind(endpoint);
acceptor->listen(socket_base::max_connections);
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
RPCListen(acceptor, *rpc_ssl_context, fUseSSL);
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
2012-09-12 16:45:01 +02:00
fListening = true;
rpc: Add acceptors only when listening succeeded
2014-06-19 08:19:07 +02:00
rpc_acceptors.push_back(acceptor);
Add -rpcbind option to allow binding RPC port on a specific interface Add -rpcbind command option to specify binding RPC service on one or multiple specific interfaces. Functionality if -rpcbind is not specified remains the same as before: - If no -rpcallowip specified, bind on localhost - If no -rpcbind specified, bind on any interface Implements part of #3111.
2014-02-17 17:35:40 +01:00
// If dual IPv6/IPv4 bind succesful, skip binding to IPv4 separately
if(bBindAny && bindAddress == asio::ip::address_v6::any() && !v6_only_error)
break;
}
catch(boost::system::system_error &e)
{
LogPrintf("ERROR: Binding RPC on address %s port %i failed: %s\n", bindAddress.to_string(), endpoint.port(), e.what());
strerr = strprintf(_("An error occurred while setting up the RPC address %s port %u for listening: %s"), bindAddress.to_string(), endpoint.port(), e.what());
Add dual IPv4/IPv6 stack support to the RPC server The RPC server now listens for, and handles, incoming connections on both IPv4 as well as IPv6. If available (and usable) it uses a dual IPv4/IPv6 socket on systems that support it (e.g. Linux and BSDs) and falls back to separate IPv4/IPv6 sockets on systems that don't (e.g. Windows). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 14:17:02 +02:00
}
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
2012-09-12 16:45:01 +02:00
}
if (!fListening) {
update CClientUIInterface and remove orphan Wx stuff - fix ThreadSafeMessageBox always displays error icon - allow to specify MSG_ERROR / MSG_WARNING or MSG_INFORMATION without a custom caption / title - allow to specify CClientUIInterface::ICON_ERROR / ICON_WARNING and ICON_INFORMATION (which is default) as message box icon - remove CClientUIInterface::OK from ThreadSafeMessageBox-calls, as the OK button will be set as default, if none is specified - prepend "Bitcoin - " to used captions - rename BitcoinGUI::error() -> BitcoinGUI::message() and add function documentation - change all style parameters and enum flags to unsigned - update code to use that new API - update Client- and WalletModel to use new BitcoinGUI::message() and rename the classes error() method into message() - include the possibility to supply the wanted icon for messages from Client- and WalletModel via "style" parameter
2012-11-05 08:04:21 +01:00
uiInterface.ThreadSafeMessageBox(strerr, "", CClientUIInterface::MSG_ERROR);
Merge branch 'master' into async-ipv6-rpc Conflicts: src/bitcoinrpc.cpp Signed-off-by: Giel van Schijndel <me@mortis.eu>
2012-06-17 14:30:37 +02:00
StartShutdown();
Add dual IPv4/IPv6 stack support to the RPC server The RPC server now listens for, and handles, incoming connections on both IPv4 as well as IPv6. If available (and usable) it uses a dual IPv4/IPv6 socket on systems that support it (e.g. Linux and BSDs) and falls back to separate IPv4/IPv6 sockets on systems that don't (e.g. Windows). Signed-off-by: Giel van Schijndel <me@mortis.eu>
2011-08-10 14:17:02 +02:00
return;
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
rpc_worker_group = new boost::thread_group();
for (int i = 0; i < GetArg("-rpcthreads", 4); i++)
rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
fRPCRunning = true;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
}
qt: allow `walletpassphrase` in debug console without -server Currently it is only possible to use `walletpassphrase` to unlock the wallet when bitcoin is started in server mode. Almost everything that manipulates the wallet in the RPC console needs the wallet to be unlocked and is thus unusable without -server. This is pretty unintuitive to me, and I'm sure it's even more confusing to users. Solve this with a very minimal change: by making the GUI start a dummy RPC thread just to handle timeouts.
2014-01-17 16:32:35 +01:00
void StartDummyRPCThread()
{
if(rpc_io_service == NULL)
{
rpc_io_service = new asio::io_service();
/* Create dummy "work" to keep the thread from exiting when no timeouts active,
* see http://www.boost.org/doc/libs/1_51_0/doc/html/boost_asio/reference/io_service.html#boost_asio.reference.io_service.stopping_the_io_service_from_running_out_of_work */
rpc_dummy_work = new asio::io_service::work(*rpc_io_service);
rpc_worker_group = new boost::thread_group();
rpc_worker_group->create_thread(boost::bind(&asio::io_service::run, rpc_io_service));
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
fRPCRunning = true;
qt: allow `walletpassphrase` in debug console without -server Currently it is only possible to use `walletpassphrase` to unlock the wallet when bitcoin is started in server mode. Almost everything that manipulates the wallet in the RPC console needs the wallet to be unlocked and is thus unusable without -server. This is pretty unintuitive to me, and I'm sure it's even more confusing to users. Solve this with a very minimal change: by making the GUI start a dummy RPC thread just to handle timeouts.
2014-01-17 16:32:35 +01:00
}
}
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
void StopRPCThreads()
{
if (rpc_io_service == NULL) return;
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
// Set this to false first, so that longpolling loops will exit when woken up
fRPCRunning = false;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
// First, cancel all timers and acceptors
// This is not done automatically by ->stop(), and in some cases the destructor of
// asio::io_service can hang if this is skipped.
rpc: Ignore and log errors during cancel Cancelling the RPC acceptors can sometimes result in an error about a bad file descriptor. As this is the shutdown sequence we need to continue nevertheless, ignore these errors, log a warning and proceed. Fixes #4352.
2014-06-17 09:09:12 +02:00
boost::system::error_code ec;
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
BOOST_FOREACH(const boost::shared_ptr<ip::tcp::acceptor> &acceptor, rpc_acceptors)
rpc: Ignore and log errors during cancel Cancelling the RPC acceptors can sometimes result in an error about a bad file descriptor. As this is the shutdown sequence we need to continue nevertheless, ignore these errors, log a warning and proceed. Fixes #4352.
2014-06-17 09:09:12 +02:00
{
acceptor->cancel(ec);
if (ec)
LogPrintf("%s: Warning: %s when cancelling acceptor", __func__, ec.message());
}
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
rpc_acceptors.clear();
BOOST_FOREACH(const PAIRTYPE(std::string, boost::shared_ptr<deadline_timer>) &timer, deadlineTimers)
rpc: Ignore and log errors during cancel Cancelling the RPC acceptors can sometimes result in an error about a bad file descriptor. As this is the shutdown sequence we need to continue nevertheless, ignore these errors, log a warning and proceed. Fixes #4352.
2014-06-17 09:09:12 +02:00
{
timer.second->cancel(ec);
if (ec)
LogPrintf("%s: Warning: %s when cancelling timer", __func__, ec.message());
}
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
deadlineTimers.clear();
rpc: keep track of acceptors, and cancel them in StopRPCThreads Fixes #4156. The problem is that the boost::asio::io_service destructor waits for the acceptors to finish (on windows, and boost 1.55). Fix this by keeping track of the acceptors and cancelling them before stopping the event loops.
2014-05-09 10:01:50 +02:00
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
rpc_io_service->stop();
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
cvBlockChange.notify_all();
Avoid core dump if rpc port is in use. The cleanup code needs to check for NULL rpcworkers thread group.
2013-10-15 07:30:20 +02:00
if (rpc_worker_group != NULL)
rpc_worker_group->join_all();
qt: allow `walletpassphrase` in debug console without -server Currently it is only possible to use `walletpassphrase` to unlock the wallet when bitcoin is started in server mode. Almost everything that manipulates the wallet in the RPC console needs the wallet to be unlocked and is thus unusable without -server. This is pretty unintuitive to me, and I'm sure it's even more confusing to users. Solve this with a very minimal change: by making the GUI start a dummy RPC thread just to handle timeouts.
2014-01-17 16:32:35 +01:00
delete rpc_dummy_work; rpc_dummy_work = NULL;
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
delete rpc_worker_group; rpc_worker_group = NULL;
delete rpc_ssl_context; rpc_ssl_context = NULL;
delete rpc_io_service; rpc_io_service = NULL;
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
}
getblocktemplate: longpolling support
2012-05-13 06:43:24 +02:00
bool IsRPCRunning()
{
return fRPCRunning;
}
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
void RPCRunHandler(const boost::system::error_code& err, boost::function<void(void)> func)
{
if (!err)
func();
}
Cleanup code using forward declarations. Use misc methods of avoiding unnecesary header includes. Replace int typedefs with int##_t from stdint.h. Replace PRI64[xdu] with PRI[xdu]64 from inttypes.h. Normalize QT_VERSION ifs where possible. Resolve some indirect dependencies as direct ones. Remove extern declarations from .cpp files.
2013-04-13 07:13:08 +02:00
void RPCRunLater(const std::string& name, boost::function<void(void)> func, int64_t nSeconds)
Use boost::asio::deadline_timer for walletpassphrase timeout New method in bitcoinrpc: RunLater, that uses a map of deadline timers to run a function later. Behavior of walletpassphrase is changed; before, calling walletpassphrase again before the lock timeout passed would result in: Error: Wallet is already unlocked. You would have to call lockwallet before walletpassphrase. Now: the last walletpassphrase with correct password wins, and overrides any previous timeout. Fixes issue# 1961 which was caused by spawning too many threads. Test plan: Start with encrypted wallet, password 'foo' NOTE: python -c 'import time; print("%d"%time.time())' ... will tell you current unix timestamp. Try: walletpassphrase foo 600 getinfo EXPECT: unlocked_until is about 10 minutes in the future walletpassphrase foo 1 sleep 2 sendtoaddress mun74Bvba3B1PF2YkrF4NsgcJwHXXh12LF 11 EXPECT: Error: Please enter the wallet passphrase with walletpassphrase first. walletpassphrase foo 600 walletpassphrase foo 0 getinfo EXPECT: wallet is locked (unlocked_until is 0) walletpassphrase foo 10 walletpassphrase foo 600 getinfo EXPECT: wallet is unlocked until 10 minutes in future walletpassphrase foo 60 walletpassphrase bar 600 EXPECT: Error, incorrect passphrase getinfo EXPECT: wallet still scheduled to lock 60 seconds from first (successful) walletpassphrase
2013-05-07 16:47:00 +02:00
{
assert(rpc_io_service != NULL);
if (deadlineTimers.count(name) == 0)
{
deadlineTimers.insert(make_pair(name,
boost::shared_ptr<deadline_timer>(new deadline_timer(*rpc_io_service))));
}
deadlineTimers[name]->expires_from_now(posix_time::seconds(nSeconds));
deadlineTimers[name]->async_wait(boost::bind(RPCRunHandler, _1, func));
}
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
class JSONRequest
{
public:
Value id;
string strMethod;
Array params;
JSONRequest() { id = Value::null; }
void parse(const Value& valRequest);
};
void JSONRequest::parse(const Value& valRequest)
{
// Parse request
if (valRequest.type() != obj_type)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
const Object& request = valRequest.get_obj();
// Parse id now so errors from here on will have the id
id = find_value(request, "id");
// Parse method
Value valMethod = find_value(request, "method");
if (valMethod.type() == null_type)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
if (valMethod.type() != str_type)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
strMethod = valMethod.get_str();
Remove getwork() RPC call
2014-04-28 12:52:32 +02:00
if (strMethod != "getblocktemplate")
Remove redundant .c_str()s After the tinyformat switch sprintf() family functions support passing actual std::string objects. Remove unnecessary c_str calls (236 of them) in logging and formatting.
2014-01-16 16:15:27 +01:00
LogPrint("rpc", "ThreadRPCServer method=%s\n", strMethod);
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
// Parse params
Value valParams = find_value(request, "params");
if (valParams.type() == array_type)
params = valParams.get_array();
else if (valParams.type() == null_type)
params = Array();
else
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array");
RPC: break out high level JSON-RPC req/resp into their own functions This prepares for JSON-RPC 2.0 batches.
2012-06-27 19:47:02 +02:00
}
Split up bitcoinrpc (code movement only) Split bitcoinrpc up into - rpcserver: bitcoind RPC server - rpcclient: bitcoin-cli RPC client - rpcprotocol: shared common HTTP/JSON-RPC protocol code One step towards making bitcoin-cli independent from the rest of the code, and thus a smaller executable that doesn't have to be linked against leveldb. This commit only does code movement, there are no functional changes.
2013-11-20 14:18:57 +01:00
RPC: add support for JSON-RPC 2.0-style request batching If the top-level object is an array, it is assumed to be an array of JSON-RPC requests. An array is returned, containing one response (error or not) per request, in the order submitted. In a slight change in semantics, batched requests -always- return an HTTP 200 OK status, even ones full of invalid or incorrect requests.
2012-06-24 08:01:28 +02:00
static Object JSONRPCExecOne(const Value& req)
{
Object rpc_result;
JSONRequest jreq;
try {
jreq.parse(req);
Value result = tableRPC.execute(jreq.strMethod, jreq.params);
rpc_result = JSONRPCReplyObj(result, Value::null, jreq.id);
}
catch (Object& objError)
{
rpc_result = JSONRPCReplyObj(Value::null, objError, jreq.id);
}
catch (std::exception& e)
{
rpc_result = JSONRPCReplyObj(Value::null,
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
RPC: add support for JSON-RPC 2.0-style request batching If the top-level object is an array, it is assumed to be an array of JSON-RPC requests. An array is returned, containing one response (error or not) per request, in the order submitted. In a slight change in semantics, batched requests -always- return an HTTP 200 OK status, even ones full of invalid or incorrect requests.
2012-06-24 08:01:28 +02:00
}
return rpc_result;
}
static string JSONRPCExecBatch(const Array& vReq)
{
Array ret;
for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
Revert "Switch to using raw_utf8" This reverts commit 2ecb7555a9df1e843fd25f588819e4ca1d94b266.
2013-10-22 11:43:38 +02:00
return write_string(Value(ret), false) + "\n";
RPC: add support for JSON-RPC 2.0-style request batching If the top-level object is an array, it is assumed to be an array of JSON-RPC requests. An array is returned, containing one response (error or not) per request, in the order submitted. In a slight change in semantics, batched requests -always- return an HTTP 200 OK status, even ones full of invalid or incorrect requests.
2012-06-24 08:01:28 +02:00
}
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
static bool HTTPReq_JSONRPC(AcceptedConnection *conn,
string& strRequest,
map<string, string>& mapHeaders,
bool fRun)
{
// Check authorization
if (mapHeaders.count("authorization") == 0)
{
fix RPC error replies After pull #4288, RPC messages indicating errors have a Content-Length unrelated to their actual contents, rendering bitcoin-cli and curl unable to decode the reply. This patch sets the Content-Length field based on the actual content returned. Additionally, pull #4288 clobbered the error descriptions provided in ErrorReply, which bitcoin-cli relies upon; this patch moves #4288 http-error descriptions to an HTTPError method, allowing HTTPReply to pass content on unchanged.
2014-06-29 03:14:36 +02:00
conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
return false;
}
if (!HTTPAuthorized(mapHeaders))
{
LogPrintf("ThreadRPCServer incorrect password attempt from %s\n", conn->peer_address_to_string());
Don't reveal whether password is <20 or >20 characters in RPC As discussed on IRC. It seems bad to base a decision to delay based on the password length, as it leaks a small amount of information.
2014-08-19 14:40:11 +02:00
/* Deter brute-forcing
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
If this results in a DoS the user really
shouldn't have their RPC port exposed. */
Don't reveal whether password is <20 or >20 characters in RPC As discussed on IRC. It seems bad to base a decision to delay based on the password length, as it leaks a small amount of information.
2014-08-19 14:40:11 +02:00
MilliSleep(250);
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
fix RPC error replies After pull #4288, RPC messages indicating errors have a Content-Length unrelated to their actual contents, rendering bitcoin-cli and curl unable to decode the reply. This patch sets the Content-Length field based on the actual content returned. Additionally, pull #4288 clobbered the error descriptions provided in ErrorReply, which bitcoin-cli relies upon; this patch moves #4288 http-error descriptions to an HTTPError method, allowing HTTPReply to pass content on unchanged.
2014-06-29 03:14:36 +02:00
conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
return false;
}
JSONRequest jreq;
try
{
// Parse request
Value valRequest;
if (!read_string(strRequest, valRequest))
throw JSONRPCError(RPC_PARSE_ERROR, "Parse error");
string strReply;
// singleton request
if (valRequest.type() == obj_type) {
jreq.parse(valRequest);
Value result = tableRPC.execute(jreq.strMethod, jreq.params);
// Send reply
strReply = JSONRPCReply(result, Value::null, jreq.id);
// array of requests
} else if (valRequest.type() == array_type)
strReply = JSONRPCExecBatch(valRequest.get_array());
else
throw JSONRPCError(RPC_PARSE_ERROR, "Top-level object parse error");
Avoid a copy in RPC output Split up HTTPReply into HTTPReply and HTTPReplyHeader, so that the message data can be streamed directly. Also removes a c_str(), which would have prevented binary output with NUL characters in it.
2014-08-06 13:01:49 +02:00
conn->stream() << HTTPReplyHeader(HTTP_OK, fRun, strReply.size()) << strReply << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
}
catch (Object& objError)
{
ErrorReply(conn->stream(), objError, jreq.id);
return false;
}
catch (std::exception& e)
{
ErrorReply(conn->stream(), JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
return false;
}
return true;
}
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
void ServiceConnection(AcceptedConnection *conn)
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
{
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
2012-04-24 07:10:02 +02:00
bool fRun = true;
Fix regression tests Taught bitcoind to close the HTTP connection after it gets a 'stop' command, to make it easier for the regression tests to cleanly stop. Move bitcoinrpc files to correct location. Tidied up the python-based regression tests.
2014-03-13 22:51:05 +01:00
while (fRun && !ShutdownRequested())
Port Thread* methods to boost::thread_group
2013-03-07 04:31:26 +01:00
{
RPC, cosmetic: push down ReadHTTPStatus() calls into ReadHTTP() callers ReadHTTPStatus() is currently overloaded: In client mode, it properly parses and receives an HTTP status line. In server mode, it incorrectly parses the HTTP request line as an HTTP status line. This server mode bug has never mattered, because the RPC server never cared about the URI (path) provided in the HTTP request. That will change in the future, so go ahead and begin fixing the problem. This patch is cosmetic, and should result in NO behavior changes. Further renames: ReadHTTPHeader -> ReadHTTPHeaders ReadHTTP -> ReadHTTPMessage
2012-11-04 22:06:38 +01:00
int nProto = 0;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
map<string, string> mapHeaders;
RPC: HTTP server uses its own ReadHTTPRequestLine() rather than reusing ReadHTTPStatus() from the client mode. The following additional HTTP request validations are added, both in line with existing HTTP client practice: 1) HTTP method must be GET or POST. Most clients use POST, some use GET. Either way, this continues to work. 2) HTTP URI must start with "/" character. Normal URI is "/" (a 1-char string), so this is fine.
2012-11-04 23:16:46 +01:00
string strRequest, strMethod, strURI;
// Read HTTP request line
if (!ReadHTTPRequestLine(conn->stream(), nProto, strMethod, strURI))
break;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
RPC, cosmetic: push down ReadHTTPStatus() calls into ReadHTTP() callers ReadHTTPStatus() is currently overloaded: In client mode, it properly parses and receives an HTTP status line. In server mode, it incorrectly parses the HTTP request line as an HTTP status line. This server mode bug has never mattered, because the RPC server never cared about the URI (path) provided in the HTTP request. That will change in the future, so go ahead and begin fixing the problem. This patch is cosmetic, and should result in NO behavior changes. Further renames: ReadHTTPHeader -> ReadHTTPHeaders ReadHTTP -> ReadHTTPMessage
2012-11-04 22:06:38 +01:00
// Read HTTP message headers and body
Remove size limit in RPC client, keep it in server The size limit makes a lot of sense for the server, as it never has to accept very large data. The client, however, can request arbitrary amounts of data with `listtransactions` on a large wallet. Fixes #4604.
2014-08-06 13:03:58 +02:00
ReadHTTPMessage(conn->stream(), mapHeaders, strRequest, nProto, MAX_SIZE);
integration of core bitcoin
2011-05-14 20:10:21 +02:00
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
// HTTP Keep-Alive is false; close connection immediately
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
2012-04-24 07:10:02 +02:00
if (mapHeaders["connection"] == "close")
fRun = false;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
2014-06-04 17:38:33 +02:00
if (strURI == "/") {
if (!HTTPReq_JSONRPC(conn, strRequest, mapHeaders, fRun))
break;
minor code format fix in rpc-related files
2014-06-27 11:13:25 +02:00
} else {
fix RPC error replies After pull #4288, RPC messages indicating errors have a Content-Length unrelated to their actual contents, rendering bitcoin-cli and curl unable to decode the reply. This patch sets the Content-Length field based on the actual content returned. Additionally, pull #4288 clobbered the error descriptions provided in ErrorReply, which bitcoin-cli relies upon; this patch moves #4288 http-error descriptions to an HTTPError method, allowing HTTPReply to pass content on unchanged.
2014-06-29 03:14:36 +02:00
conn->stream() << HTTPError(HTTP_NOT_FOUND, false) << std::flush;
Support multi-threaded JSON-RPC Change internal HTTP JSON-RPC server from single-threaded to thread-per-connection model. The IP filter list is applied prior to starting the thread, which then processes the RPC. A mutex covers the entire RPC operation, because not all RPC operations are thread-safe. [minor modifications by jgarzik, to make change upstream-ready]
2012-04-15 02:35:58 +02:00
break;
integration of core bitcoin
2011-05-14 20:10:21 +02:00
}
}
}
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
json_spirit::Value CRPCTable::execute(const std::string &strMethod, const json_spirit::Array &params) const
{
// Find method
const CRPCCommand *pcmd = tableRPC[strMethod];
if (!pcmd)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
2013-08-25 06:00:02 +02:00
if (pcmd->reqWallet && !pwalletMain)
throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found (disabled)");
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#endif
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
// Observe safe mode
string strWarning = GetWarnings("rpc");
remove GetBoolArg() fDefault parameter defaulting to false - explicitly set the default of all GetBoolArg() calls - rework getarg_test.cpp and util_tests.cpp to cover this change - some indentation fixes - move macdockiconhandler.h include in bitcoin.cpp to the "our headers" section
2013-04-28 17:37:50 +02:00
if (strWarning != "" && !GetBoolArg("-disablesafemode", false) &&
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
!pcmd->okSafeMode)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, string("Safe mode: ") + strWarning);
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
try
{
// Execute
Value result;
{
CRPCCommand.unlocked -> CRPCCommand.threadSafe unlocked could be confused with wallet encryption
2013-03-07 12:18:55 +01:00
if (pcmd->threadSafe)
RPC: add facility to enable RPCs to run outside cs_main, wallet locks Use with 'stop' and 'help' RPCs. This provides a facility to individually evaluate the locking for an RPC, and potentially make it more parallel.
2012-08-21 18:03:52 +02:00
result = pcmd->actor(params, false);
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
2013-08-25 06:00:02 +02:00
else if (!pwalletMain) {
LOCK(cs_main);
result = pcmd->actor(params, false);
} else {
RPC: add facility to enable RPCs to run outside cs_main, wallet locks Use with 'stop' and 'help' RPCs. This provides a facility to individually evaluate the locking for an RPC, and potentially make it more parallel.
2012-08-21 18:03:52 +02:00
LOCK2(cs_main, pwalletMain->cs_wallet);
result = pcmd->actor(params, false);
}
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
2013-11-29 16:04:29 +01:00
#else // ENABLE_WALLET
else {
LOCK(cs_main);
result = pcmd->actor(params, false);
}
#endif // !ENABLE_WALLET
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
}
return result;
}
catch (std::exception& e)
{
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
2012-10-04 09:34:44 +02:00
throw JSONRPCError(RPC_MISC_ERROR, e.what());
Add UI RPC console / debug window
2012-04-09 21:07:25 +02:00
}
}
integration of core bitcoin
2011-05-14 20:10:21 +02:00
Move HelpExample* from rpcwallet to rpcserver General functions used throughout the RPC framework don't belong in rpcwallet.
2013-11-29 15:48:07 +01:00
std::string HelpExampleCli(string methodname, string args){
return "> bitcoin-cli " + methodname + " " + args + "\n";
}
std::string HelpExampleRpc(string methodname, 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";
}
Expose CRPCTable via bitcoinrpc.h for testing
2012-04-21 01:37:34 +02:00
const CRPCTable tableRPC;
Reference in a new issue Copy permalink