kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Kevacoin source tree
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7483 Commits
29 Branches
232 Tags
129 MiB
Tree: 4d2ecc4f94
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4d2ecc4f94'
${ noResults }
kevacoin/src/rpcserver.cpp

1032 lines
40 KiB
Raw Normal View History Unescape

integration of core bitcoin
14 years ago
// 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.
11 years ago
// Copyright (c) 2009-2014 The Bitcoin developers
Update comments in rpcserver to be doxygen compatible
10 years ago
// Distributed under the MIT 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.
13 years ago
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
integration of core bitcoin
14 years ago
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.
11 years ago
#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.
12 years ago
#include "base58.h"
update bitcoin core from git (eeac8727bc0a951631bd)
14 years ago
#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.
12 years ago
#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.
11 years ago
#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.
11 years ago
#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.
11 years ago
#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.
12 years ago
#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.
11 years ago
#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.
12 years ago
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
12 years ago
#include <boost/algorithm/string.hpp>
integration of core bitcoin
14 years ago
#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
12 years ago
#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>
14 years ago
#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
14 years ago
#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>
14 years ago
#include <boost/foreach.hpp>
integration of core bitcoin
14 years ago
#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>
14 years ago
#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.
10 years ago
#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.
12 years ago
#include "json/json_spirit_writer_template.h"
Remove USE_SSL #define
13 years ago
integration of core bitcoin
14 years ago
using namespace boost;
using namespace boost::asio;
using namespace json_spirit;
minor code format fix in rpc-related files
11 years ago
using namespace std;
integration of core bitcoin
14 years ago
Speed up RPC authentication (reworked pull from Joel Katz)
13 years ago
static std::string strRPCUserColonPass;
getblocktemplate: longpolling support
13 years ago
static bool fRPCRunning = false;
Add "warmup mode" for RPC server. Start the RPC server before doing all the (expensive) startup initialisations like loading the block index. Until the node is ready, return all calls immediately with a new error signalling "in warmup" with an appropriate status message (similar to the init message). This is useful for RPC clients to know that the server is there (e. g., they don't have to start it) but not yet available. It is used in Namecoin and Huntercoin already for some time, and there exists a UI hooked onto the RPC interface that actively uses this to its advantage.
10 years ago
static bool fRPCInWarmup = true;
static std::string rpcWarmupStatus("RPC server started");
static CCriticalSection cs_rpcWarmup;
Update comments in rpcserver to be doxygen compatible
10 years ago
//! These are created by StartRPCThreads, destroyed in StopRPCThreads
Port Thread* methods to boost::thread_group
12 years ago
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
12 years ago
static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
Port Thread* methods to boost::thread_group
12 years ago
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.
11 years ago
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.
11 years ago
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.
11 years ago
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]
13 years ago
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
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.
12 years ago
const list<Value_type>& typesExpected,
bool fAllowNull)
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
{
Use unsigned ints to fix signed/unsigned warnings
13 years ago
unsigned int i = 0;
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
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.
12 years ago
const Value& v = params[i];
if (!((v.type() == t) || (fAllowNull && (v.type() == null_type))))
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
{
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.
12 years ago
throw JSONRPCError(RPC_TYPE_ERROR, err);
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
}
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.
12 years ago
const map<string, Value_type>& typesExpected,
bool fAllowNull)
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
{
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.
12 years ago
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.
11 years ago
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.
12 years ago
if (!((v.type() == t.second) || (fAllowNull && (v.type() == null_type))))
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
{
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.
11 years ago
Value_type_name[t.second], t.first, Value_type_name[v.type()]);
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
throw JSONRPCError(RPC_TYPE_ERROR, err);
RPCTypeCheck method to make type-checking JSON Arrays easier.
13 years ago
}
}
}
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.
10 years ago
static inline int64_t roundint64(double d)
{
return (int64_t)(d > 0 ? d + 0.5 : d - 0.5);
}
Use a typedef for monetary values
11 years ago
CAmount AmountFromValue(const Value& value)
integration of core bitcoin
14 years ago
{
double dAmount = value.get_real();
if (dAmount <= 0.0 || dAmount > 21000000.0)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
Use a typedef for monetary values
11 years ago
CAmount nAmount = roundint64(dAmount * COIN);
integration of core bitcoin
14 years ago
if (!MoneyRange(nAmount))
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
integration of core bitcoin
14 years ago
return nAmount;
}
Use a typedef for monetary values
11 years ago
Value ValueFromAmount(const CAmount& amount)
integration of core bitcoin
14 years ago
{
return (double)amount / (double)COIN;
}
Move Parse{Hash|Hex} to be usable by all RPC code
12 years ago
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
14 years ago
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"
13 years ago
Update comments in rpcserver to be doxygen compatible
10 years ago
/**
* Note: This interface may still be subject to change.
*/
integration of core bitcoin
14 years ago
Encapsulate mapCommands in class CRPCTable
13 years ago
string CRPCTable::help(string strCommand) const
integration of core bitcoin
14 years ago
{
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
11 years ago
string category;
integration of core bitcoin
14 years ago
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
11 years ago
vector<pair<string, const CRPCCommand*> > vCommands;
Encapsulate mapCommands in class CRPCTable
13 years ago
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
11 years ago
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
14 years ago
{
Categorize rpc help overview Conflicts: src/rpcserver.cpp Github-Pull: #4539 Rebased-By: Wladimir J. van der Laan <laanwj@gmail.com> Rebased-From: df3d321
11 years ago
const CRPCCommand *pcmd = command.second;
string strMethod = pcmd->name;
integration of core bitcoin
14 years ago
// We already filter duplicates, but these deprecated screw up the sort order
JSON-RPC: remove 'getblocknumber' deprecated RPC RPC 'getblockcount' should be used instead.
13 years ago
if (strMethod.find("label") != string::npos)
integration of core bitcoin
14 years ago
continue;
Introduce a hidden category
10 years ago
if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
integration of core bitcoin
14 years ago
continue;
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
11 years ago
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
11 years ago
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.
11 years ago
#endif
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
11 years ago
integration of core bitcoin
14 years ago
try
{
Array params;
Encapsulate RPC command dispatch in an array of CRPCCommand's
13 years ago
rpcfn_type pfn = pcmd->actor;
integration of core bitcoin
14 years ago
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
11 years ago
{
The string class returns string::npos, when find() fails. Noticed when sign-comparison warnings were enabled.
13 years ago
if (strHelp.find('\n') != string::npos)
integration of core bitcoin
14 years ago
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
11 years ago
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
14 years ago
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.
11 years ago
strRet = strprintf("help: unknown command: %s\n", strCommand);
integration of core bitcoin
14 years ago
strRet = strRet.substr(0,strRet.size()-1);
return strRet;
}
Encapsulate mapCommands in class CRPCTable
13 years ago
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
11 years ago
"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
13 years ago
string strCommand;
if (params.size() > 0)
strCommand = params[0].get_str();
return tableRPC.help(strCommand);
}
integration of core bitcoin
14 years ago
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
12 years ago
// 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.
12 years ago
if (fHelp || params.size() > 1)
integration of core bitcoin
14 years ago
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.
12 years ago
"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
11 years ago
"\nStop Bitcoin server.");
integration of core bitcoin
14 years ago
// 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)
13 years ago
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
13 years ago
return "Bitcoin server stopping";
integration of core bitcoin
14 years ago
}
Update comments in rpcserver to be doxygen compatible
10 years ago
/**
* Call Table
*/
Expose CRPCTable via bitcoinrpc.h for testing
13 years ago
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
11 years ago
{ // 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.
11 years ago
/* 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
11 years ago
{ "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.
11 years ago
/* 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
11 years ago
{ "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.
11 years ago
/* 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
11 years ago
{ "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.
10 years ago
{ "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
11 years ago
{ "blockchain", "getrawmempool", &getrawmempool, true, false, false },
{ "blockchain", "gettxout", &gettxout, true, false, false },
{ "blockchain", "gettxoutsetinfo", &gettxoutsetinfo, true, false, false },
{ "blockchain", "verifychain", &verifychain, true, false, false },
Add 'invalidateblock' and 'reconsiderblock' RPC commands. These can be used for testing reorganizations or for manual intervention in case of chain forks.
10 years ago
{ "blockchain", "invalidateblock", &invalidateblock, true, true, false },
{ "blockchain", "reconsiderblock", &reconsiderblock, true, true, false },
Delimit code with #ifdef ENABLE_WALLET Delimit all code that uses the wallet functions in implementation files that conditionally use the wallet.
11 years ago
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.
11 years ago
/* 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
11 years ago
{ "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.
11 years ago
/* 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
11 years ago
{ "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.
11 years ago
/* 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
11 years ago
{ "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.
11 years ago
Introduce a hidden category
10 years ago
/* Not shown in help */
{ "hidden", "invalidateblock", &invalidateblock, true, true, false },
{ "hidden", "reconsiderblock", &reconsiderblock, true, true, false },
Move `setmocktime` to hidden category Another testing-only potential footgun command.
10 years ago
{ "hidden", "setmocktime", &setmocktime, true, false, false },
Introduce a hidden category
10 years ago
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.
11 years ago
#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
11 years ago
{ "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.
11 years ago
#endif // ENABLE_WALLET
integration of core bitcoin
14 years ago
};
Encapsulate mapCommands in class CRPCTable
13 years ago
CRPCTable::CRPCTable()
Encapsulate RPC command dispatch in an array of CRPCCommand's
13 years ago
{
unsigned int vcidx;
for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
{
Expose CRPCTable via bitcoinrpc.h for testing
13 years ago
const CRPCCommand *pcmd;
integration of core bitcoin
14 years ago
Encapsulate RPC command dispatch in an array of CRPCCommand's
13 years ago
pcmd = &vRPCCommands[vcidx];
mapCommands[pcmd->name] = pcmd;
}
}
integration of core bitcoin
14 years ago
Encapsulate mapCommands in class CRPCTable
13 years ago
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
14 years ago
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.
12 years ago
return TimingResistantEqual(strUserPass, strRPCUserColonPass);
integration of core bitcoin
14 years ago
}
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
12 years ago
int nStatus = HTTP_INTERNAL_SERVER_ERROR;
integration of core bitcoin
14 years ago
int code = find_value(objError, "code").get_int();
Add constants for HTTP status codes
12 years ago
if (code == RPC_INVALID_REQUEST) nStatus = HTTP_BAD_REQUEST;
else if (code == RPC_METHOD_NOT_FOUND) nStatus = HTTP_NOT_FOUND;
integration of core bitcoin
14 years ago
string strReply = JSONRPCReply(Value::null, objError, id);
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
13 years ago
stream << HTTPReply(nStatus, strReply, false) << std::flush;
integration of core bitcoin
14 years ago
}
Add tests for BoostAsioToCNetAddr
11 years ago
CNetAddr BoostAsioToCNetAddr(boost::asio::ip::address address)
integration of core bitcoin
14 years ago
{
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.
11 years ago
CNetAddr netaddr;
Allow clients on the IPv6 loopback as well Signed-off-by: Giel van Schijndel <me@mortis.eu>
14 years ago
// 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.
11 years ago
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
14 years ago
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>
14 years ago
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]
13 years ago
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>
14 years ago
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]
13 years ago
};
Port Thread* methods to boost::thread_group
12 years ago
void ServiceConnection(AcceptedConnection *conn);
integration of core bitcoin
14 years ago
Update comments in rpcserver to be doxygen compatible
10 years ago
//! 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>
14 years ago
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>
14 years ago
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).
11 years ago
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>
14 years ago
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>
14 years ago
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>
14 years ago
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).
11 years ago
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>
14 years ago
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>
14 years ago
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>
14 years ago
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.
11 years ago
_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>
14 years ago
}
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.
11 years ago
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>
14 years ago
/**
* 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>
14 years ago
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>
14 years ago
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).
11 years ago
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>
14 years ago
const boost::system::error_code& error)
{
Bugfix: Fix a variety of misspellings
13 years ago
// Immediately start accepting new connections, except when we're cancelled or our socket is closed.
Port Thread* methods to boost::thread_group
12 years ago
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>
13 years ago
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>
14 years ago
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).
11 years ago
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>
14 years ago
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>
14 years ago
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.
11 years ago
// 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>
14 years ago
}
// 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
12 years ago
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>
14 years ago
{
// 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.
11 years ago
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).
11 years ago
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>
14 years ago
}
Port Thread* methods to boost::thread_group
12 years ago
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).
11 years ago
ServiceConnection(conn.get());
Port Thread* methods to boost::thread_group
12 years ago
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>
14 years ago
}
}
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.
11 years ago
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
12 years ago
void StartRPCThreads()
integration of core bitcoin
14 years ago
{
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.
11 years ago
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.
11 years ago
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.
11 years ago
"", 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)
13 years ago
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.
12 years ago
if (((mapArgs["-rpcpassword"] == "") ||
(mapArgs["-rpcuser"] == mapArgs["-rpcpassword"])) && Params().RequireRPCPassword())
integration of core bitcoin
14 years ago
{
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.
13 years ago
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
11 years ago
GetRandBytes(rand_pwd, 32);
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.
13 years ago
uiInterface.ThreadSafeMessageBox(strprintf(
Truthier error message when rpcpassword is missing
10 years ago
_("To use bitcoind, or the -server option to bitcoin-qt, you must set an rpcpassword in the configuration file:\n"
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
12 years ago
"%s\n"
Use a messagebox to display the error when -server is provided without providing a rpc password
13 years ago
"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.
12 years ago
"The username and password MUST NOT be the same.\n"
Recommend alertnotify
12 years ago
"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.
11 years ago
GetConfigFile().string(),
EncodeBase58(&rand_pwd[0],&rand_pwd[0]+32)),
Add a SECURE style flag for ThreadSafeMessageBox, which indicates that the message contains sensitive information. This keeps the message from being output to the debug log by bitcoind. Fixes a possible security risk when starting bitcoind in server mode without the 'rpcpassword' option configured, resulting in the "suggested" password being output to the debug log.
10 years ago
"", CClientUIInterface::MSG_ERROR | CClientUIInterface::SECURE);
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)
13 years ago
StartShutdown();
integration of core bitcoin
14 years ago
return;
}
Port Thread* methods to boost::thread_group
12 years ago
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
14 years ago
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
12 years ago
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>
13 years ago
integration of core bitcoin
14 years ago
if (fUseSSL)
{
Port Thread* methods to boost::thread_group
12 years ago
rpc_ssl_context->set_options(ssl::context::no_sslv2);
updated bitcoinrpc.cpp to use make_preferred() and removed double inclusion of boost/filesystem.hpp
13 years ago
filesystem::path pathCertFile(GetArg("-rpcsslcertificatechainfile", "server.cert"));
if (!pathCertFile.is_complete()) pathCertFile = filesystem::path(GetDataDir()) / pathCertFile;
Port Thread* methods to boost::thread_group
12 years ago
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.
11 years ago
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
13 years ago
filesystem::path pathPKFile(GetArg("-rpcsslprivatekeyfile", "server.pem"));
if (!pathPKFile.is_complete()) pathPKFile = filesystem::path(GetDataDir()) / pathPKFile;
Port Thread* methods to boost::thread_group
12 years ago
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.
11 years ago
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
13 years ago
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)
11 years ago
string strCiphers = GetArg("-rpcsslciphers", "TLSv1.2+HIGH:TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!3DES:@STRENGTH");
Port Thread* methods to boost::thread_group
12 years ago
SSL_CTX_set_cipher_list(rpc_ssl_context->impl(), strCiphers.c_str());
integration of core bitcoin
14 years ago
}
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.
11 years ago
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.
11 years ago
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.
11 years ago
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
10 years ago
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.
11 years ago
{
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.
13 years ago
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
12 years ago
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.
11 years ago
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>
14 years ago
{
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.
11 years ago
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.
11 years ago
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>
14 years ago
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.
11 years ago
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>
13 years ago
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.
11 years ago
// 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>
13 years ago
acceptor->bind(endpoint);
acceptor->listen(socket_base::max_connections);
Port Thread* methods to boost::thread_group
12 years ago
RPCListen(acceptor, *rpc_ssl_context, fUseSSL);
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
12 years ago
fListening = true;
rpc: Add acceptors only when listening succeeded
11 years ago
rpc_acceptors.push_back(acceptor);
Update comments in rpcserver to be doxygen compatible
10 years ago
// If dual IPv6/IPv4 bind successful, skip binding to IPv4 separately
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.
11 years ago
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>
14 years ago
}
Do not abort if RPC listening for IPv6 fails Instead, fall back to IPv4 listening.
12 years ago
}
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
12 years ago
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>
13 years ago
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>
14 years ago
return;
}
integration of core bitcoin
14 years ago
Port Thread* methods to boost::thread_group
12 years ago
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
13 years ago
fRPCRunning = true;
Port Thread* methods to boost::thread_group
12 years ago
}
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.
11 years ago
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
13 years ago
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.
11 years ago
}
}
Port Thread* methods to boost::thread_group
12 years ago
void StopRPCThreads()
{
if (rpc_io_service == NULL) return;
getblocktemplate: longpolling support
13 years ago
// Set this to false first, so that longpolling loops will exit when woken up
fRPCRunning = false;
Port Thread* methods to boost::thread_group
12 years ago
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.
11 years ago
// 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.
11 years ago
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.
11 years ago
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.
11 years ago
{
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.
11 years ago
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.
11 years ago
{
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
12 years ago
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.
11 years ago
Port Thread* methods to boost::thread_group
12 years ago
rpc_io_service->stop();
getblocktemplate: longpolling support
13 years ago
cvBlockChange.notify_all();
Avoid core dump if rpc port is in use. The cleanup code needs to check for NULL rpcworkers thread group.
11 years ago
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.
11 years ago
delete rpc_dummy_work; rpc_dummy_work = NULL;
Port Thread* methods to boost::thread_group
12 years ago
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]
13 years ago
}
getblocktemplate: longpolling support
13 years ago
bool IsRPCRunning()
{
return fRPCRunning;
}
Add "warmup mode" for RPC server. Start the RPC server before doing all the (expensive) startup initialisations like loading the block index. Until the node is ready, return all calls immediately with a new error signalling "in warmup" with an appropriate status message (similar to the init message). This is useful for RPC clients to know that the server is there (e. g., they don't have to start it) but not yet available. It is used in Namecoin and Huntercoin already for some time, and there exists a UI hooked onto the RPC interface that actively uses this to its advantage.
10 years ago
void SetRPCWarmupStatus(const std::string& newStatus)
{
LOCK(cs_rpcWarmup);
rpcWarmupStatus = newStatus;
}
void SetRPCWarmupFinished()
{
LOCK(cs_rpcWarmup);
assert(fRPCInWarmup);
fRPCInWarmup = false;
}
[REST] give an appropriate response in warmup phase
10 years ago
bool RPCIsInWarmup(std::string *outStatus)
{
LOCK(cs_rpcWarmup);
if (outStatus)
*outStatus = rpcWarmupStatus;
return fRPCInWarmup;
}
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
12 years ago
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.
12 years ago
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
12 years ago
{
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.
13 years ago
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.
12 years ago
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.
13 years ago
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.
12 years ago
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.
13 years ago
if (valMethod.type() != str_type)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
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.
13 years ago
strMethod = valMethod.get_str();
Remove getwork() RPC call
11 years ago
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.
11 years ago
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.
13 years ago
// 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.
12 years ago
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.
13 years ago
}
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.
11 years ago
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.
13 years ago
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.
12 years ago
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.
13 years ago
}
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.
11 years ago
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.
13 years ago
}
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
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.
11 years ago
conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
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.
10 years ago
/* Deter brute-forcing
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
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.
10 years ago
MilliSleep(250);
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
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.
11 years ago
conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
return false;
}
JSONRequest jreq;
try
{
// Parse request
Value valRequest;
if (!read_string(strRequest, valRequest))
throw JSONRPCError(RPC_PARSE_ERROR, "Parse error");
Add "warmup mode" for RPC server. Start the RPC server before doing all the (expensive) startup initialisations like loading the block index. Until the node is ready, return all calls immediately with a new error signalling "in warmup" with an appropriate status message (similar to the init message). This is useful for RPC clients to know that the server is there (e. g., they don't have to start it) but not yet available. It is used in Namecoin and Huntercoin already for some time, and there exists a UI hooked onto the RPC interface that actively uses this to its advantage.
10 years ago
// Return immediately if in warmup
{
LOCK(cs_rpcWarmup);
if (fRPCInWarmup)
throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
}
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
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.
10 years ago
conn->stream() << HTTPReplyHeader(HTTP_OK, fRun, strReply.size()) << strReply << std::flush;
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
}
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
12 years ago
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]
13 years ago
{
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
13 years ago
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.
11 years ago
while (fRun && !ShutdownRequested())
Port Thread* methods to boost::thread_group
12 years ago
{
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
12 years ago
int nProto = 0;
integration of core bitcoin
14 years ago
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.
12 years ago
string strRequest, strMethod, strURI;
// Read HTTP request line
if (!ReadHTTPRequestLine(conn->stream(), nProto, strMethod, strURI))
break;
integration of core bitcoin
14 years ago
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
12 years ago
// 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.
10 years ago
ReadHTTPMessage(conn->stream(), mapHeaders, strRequest, nProto, MAX_SIZE);
integration of core bitcoin
14 years ago
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
// HTTP Keep-Alive is false; close connection immediately
RPC: Support HTTP/1.0 and HTTP/1.1, including the proper use of keep-alives
13 years ago
if (mapHeaders["connection"] == "close")
fRun = false;
integration of core bitcoin
14 years ago
Add unauthenticated HTTP REST interface to public blockchain data.
10 years ago
// Process via JSON-RPC API
RPC code movement: separate out JSON-RPC execution logic from HTTP server logic
11 years ago
if (strURI == "/") {
if (!HTTPReq_JSONRPC(conn, strRequest, mapHeaders, fRun))
break;
Add unauthenticated HTTP REST interface to public blockchain data.
10 years ago
// Process via HTTP REST API
[REST] set REST API behind "-rest" option
10 years ago
} else if (strURI.substr(0, 6) == "/rest/" && GetBoolArg("-rest", false)) {
Add unauthenticated HTTP REST interface to public blockchain data.
10 years ago
if (!HTTPReq_REST(conn, strURI, mapHeaders, fRun))
break;
minor code format fix in rpc-related files
11 years ago
} else {
HTTP REST: minor fixes 1) const-ify internal helper ParseHashStr() 2) use HTTPError() helper when returning HTTP_NOT_FOUND
10 years ago
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]
13 years ago
break;
integration of core bitcoin
14 years ago
}
}
}
Add UI RPC console / debug window
13 years ago
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.
12 years ago
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.
11 years ago
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
11 years ago
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.
11 years ago
#endif
integration of core bitcoin
14 years ago
Add UI RPC console / debug window
13 years ago
// 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
12 years ago
if (strWarning != "" && !GetBoolArg("-disablesafemode", false) &&
Add UI RPC console / debug window
13 years ago
!pcmd->okSafeMode)
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, string("Safe mode: ") + strWarning);
Add UI RPC console / debug window
13 years ago
try
{
// Execute
Value result;
{
CRPCCommand.unlocked -> CRPCCommand.threadSafe unlocked could be confused with wallet encryption
12 years ago
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.
12 years ago
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.
11 years ago
#ifdef ENABLE_WALLET
Support absence of wallet (pwalletMain==NULL) in several locations, notably RPC.
11 years ago
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.
12 years ago
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.
11 years ago
#else // ENABLE_WALLET
else {
LOCK(cs_main);
result = pcmd->actor(params, false);
}
#endif // !ENABLE_WALLET
Add UI RPC console / debug window
13 years ago
}
return result;
}
catch (std::exception& e)
{
Document RPC error codes Replace all "magic values" in RPCError(...) by constants.
12 years ago
throw JSONRPCError(RPC_MISC_ERROR, e.what());
Add UI RPC console / debug window
13 years ago
}
}
integration of core bitcoin
14 years ago
Move HelpExample* from rpcwallet to rpcserver General functions used throughout the RPC framework don't belong in rpcwallet.
11 years ago
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
13 years ago
const CRPCTable tableRPC;