2011-05-14 11:10:21 -07:00
// Copyright (c) 2010 Satoshi Nakamoto
2014-02-08 13:50:24 -08:00
// Copyright (c) 2009-2014 The Bitcoin developers
2011-05-14 11:10:21 -07:00
// Distributed under the MIT/X11 software license, see the accompanying
2012-05-18 07:02:28 -07:00
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
2011-05-14 11:10:21 -07:00
2013-11-20 05:18:57 -08:00
# include "rpcserver.h"
2013-04-12 22:13:08 -07:00
# include "base58.h"
2011-06-18 09:46:01 -07:00
# include "init.h"
2013-04-12 22:13:08 -07:00
# include "main.h"
2013-11-29 07:04:29 -08:00
# include "ui_interface.h"
2014-01-11 09:14:29 -08:00
# include "util.h"
2013-11-29 07:04:29 -08:00
# ifdef ENABLE_WALLET
2013-04-12 22:13:08 -07:00
# include "wallet.h"
2013-11-29 07:04:29 -08:00
# endif
2013-04-12 22:13:08 -07:00
2013-05-07 07:47:00 -07:00
# include <boost/algorithm/string.hpp>
2011-05-14 11:10:21 -07:00
# include <boost/asio.hpp>
2013-05-07 07:47:00 -07:00
# include <boost/asio/ssl.hpp>
2011-08-10 04:53:13 -07:00
# include <boost/bind.hpp>
2011-07-13 02:56:38 -07:00
# include <boost/filesystem.hpp>
2011-08-10 06:07:46 -07:00
# include <boost/foreach.hpp>
2011-05-14 11:10:21 -07:00
# include <boost/iostreams/concepts.hpp>
# include <boost/iostreams/stream.hpp>
2011-08-10 04:53:13 -07:00
# include <boost/shared_ptr.hpp>
2013-04-12 22:13:08 -07:00
# include "json/json_spirit_writer_template.h"
2012-04-04 18:19:27 -07:00
2011-05-14 11:10:21 -07:00
using namespace std ;
using namespace boost ;
using namespace boost : : asio ;
using namespace json_spirit ;
2011-12-01 06:07:02 -08:00
static std : : string strRPCUserColonPass ;
2013-03-06 19:31:26 -08:00
// These are created by StartRPCThreads, destroyed in StopRPCThreads
static asio : : io_service * rpc_io_service = NULL ;
2013-05-07 07:47:00 -07:00
static map < string , boost : : shared_ptr < deadline_timer > > deadlineTimers ;
2013-03-06 19:31:26 -08:00
static ssl : : context * rpc_ssl_context = NULL ;
static boost : : thread_group * rpc_worker_group = NULL ;
2014-01-17 07:32:35 -08:00
static boost : : asio : : io_service : : work * rpc_dummy_work = NULL ;
2014-04-28 04:48:26 -07:00
static std : : vector < CSubNet > rpc_allow_subnets ; //!< List of subnets to allow RPC connections from
2014-05-09 01:01:50 -07:00
static std : : vector < boost : : shared_ptr < ip : : tcp : : acceptor > > rpc_acceptors ;
2012-04-14 17:35:58 -07:00
2012-06-22 15:36:42 -07:00
void RPCTypeCheck ( const Array & params ,
2012-08-20 13:18:17 -07:00
const list < Value_type > & typesExpected ,
bool fAllowNull )
2012-06-22 15:36:42 -07:00
{
2012-07-05 10:25:52 -07:00
unsigned int i = 0 ;
2012-06-22 15:36:42 -07:00
BOOST_FOREACH ( Value_type t , typesExpected )
{
if ( params . size ( ) < = i )
break ;
2012-08-20 13:18:17 -07:00
const Value & v = params [ i ] ;
if ( ! ( ( v . type ( ) = = t ) | | ( fAllowNull & & ( v . type ( ) = = null_type ) ) ) )
2012-06-22 15:36:42 -07:00
{
string err = strprintf ( " Expected type %s, got %s " ,
Value_type_name [ t ] , Value_type_name [ v . type ( ) ] ) ;
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_TYPE_ERROR , err ) ;
2012-06-22 15:36:42 -07:00
}
i + + ;
}
}
void RPCTypeCheck ( const Object & o ,
2012-08-20 13:18:17 -07:00
const map < string , Value_type > & typesExpected ,
bool fAllowNull )
2012-06-22 15:36:42 -07:00
{
BOOST_FOREACH ( const PAIRTYPE ( string , Value_type ) & t , typesExpected )
{
const Value & v = find_value ( o , t . first ) ;
2012-08-20 13:18:17 -07:00
if ( ! fAllowNull & & v . type ( ) = = null_type )
2014-01-16 07:15:27 -08:00
throw JSONRPCError ( RPC_TYPE_ERROR , strprintf ( " Missing %s " , t . first ) ) ;
2012-08-20 13:18:17 -07:00
if ( ! ( ( v . type ( ) = = t . second ) | | ( fAllowNull & & ( v . type ( ) = = null_type ) ) ) )
2012-06-22 15:36:42 -07:00
{
string err = strprintf ( " Expected type %s for %s, got %s " ,
2014-01-16 07:15:27 -08:00
Value_type_name [ t . second ] , t . first , Value_type_name [ v . type ( ) ] ) ;
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_TYPE_ERROR , err ) ;
2012-06-22 15:36:42 -07:00
}
}
}
2013-04-12 22:13:08 -07:00
int64_t AmountFromValue ( const Value & value )
2011-05-14 11:10:21 -07:00
{
double dAmount = value . get_real ( ) ;
if ( dAmount < = 0.0 | | dAmount > 21000000.0 )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_TYPE_ERROR , " Invalid amount " ) ;
2013-04-12 22:13:08 -07:00
int64_t nAmount = roundint64 ( dAmount * COIN ) ;
2011-05-14 11:10:21 -07:00
if ( ! MoneyRange ( nAmount ) )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_TYPE_ERROR , " Invalid amount " ) ;
2011-05-14 11:10:21 -07:00
return nAmount ;
}
2013-04-12 22:13:08 -07:00
Value ValueFromAmount ( int64_t amount )
2011-05-14 11:10:21 -07:00
{
return ( double ) amount / ( double ) COIN ;
}
2012-08-23 23:44:51 -07:00
std : : string HexBits ( unsigned int nBits )
2012-02-22 09:12:28 -08:00
{
union {
int32_t nBits ;
char cBits [ 4 ] ;
} uBits ;
uBits . nBits = htonl ( ( int32_t ) nBits ) ;
return HexStr ( BEGIN ( uBits . cBits ) , END ( uBits . cBits ) ) ;
}
2013-07-14 23:24:33 -07:00
uint256 ParseHashV ( const Value & v , string strName )
{
string strHex ;
if ( v . type ( ) = = str_type )
strHex = v . get_str ( ) ;
if ( ! IsHex ( strHex ) ) // Note: IsHex("") is false
throw JSONRPCError ( RPC_INVALID_PARAMETER , strName + " must be hexadecimal string (not ' " + strHex + " ') " ) ;
uint256 result ;
result . SetHex ( strHex ) ;
return result ;
}
uint256 ParseHashO ( const Object & o , string strKey )
{
return ParseHashV ( find_value ( o , strKey ) , strKey ) ;
}
vector < unsigned char > ParseHexV ( const Value & v , string strName )
{
string strHex ;
if ( v . type ( ) = = str_type )
strHex = v . get_str ( ) ;
if ( ! IsHex ( strHex ) )
throw JSONRPCError ( RPC_INVALID_PARAMETER , strName + " must be hexadecimal string (not ' " + strHex + " ') " ) ;
return ParseHex ( strHex ) ;
}
vector < unsigned char > ParseHexO ( const Object & o , string strKey )
{
return ParseHexV ( find_value ( o , strKey ) , strKey ) ;
}
2011-05-14 11:10:21 -07:00
2012-02-22 14:44:09 -08:00
2011-05-14 11:10:21 -07:00
///
/// Note: This interface may still be subject to change.
///
2012-04-18 13:42:17 -07:00
string CRPCTable : : help ( string strCommand ) const
2011-05-14 11:10:21 -07:00
{
string strRet ;
set < rpcfn_type > setDone ;
2012-04-18 13:42:17 -07:00
for ( map < string , const CRPCCommand * > : : const_iterator mi = mapCommands . begin ( ) ; mi ! = mapCommands . end ( ) ; + + mi )
2011-05-14 11:10:21 -07:00
{
2012-04-18 13:42:17 -07:00
const CRPCCommand * pcmd = mi - > second ;
2012-04-14 20:55:05 -07:00
string strMethod = mi - > first ;
2011-05-14 11:10:21 -07:00
// We already filter duplicates, but these deprecated screw up the sort order
2012-05-17 20:43:00 -07:00
if ( strMethod . find ( " label " ) ! = string : : npos )
2011-05-14 11:10:21 -07:00
continue ;
if ( strCommand ! = " " & & strMethod ! = strCommand )
continue ;
2013-11-29 07:04:29 -08:00
# ifdef ENABLE_WALLET
2013-08-24 21:00:02 -07:00
if ( pcmd - > reqWallet & & ! pwalletMain )
continue ;
2013-11-29 07:04:29 -08:00
# endif
2013-08-24 21:00:02 -07:00
2011-05-14 11:10:21 -07:00
try
{
Array params ;
2012-04-14 20:55:05 -07:00
rpcfn_type pfn = pcmd - > actor ;
2011-05-14 11:10:21 -07:00
if ( setDone . insert ( pfn ) . second )
( * pfn ) ( params , true ) ;
}
catch ( std : : exception & e )
{
// Help text is returned in an exception
string strHelp = string ( e . what ( ) ) ;
if ( strCommand = = " " )
2012-04-15 13:47:24 -07:00
if ( strHelp . find ( ' \n ' ) ! = string : : npos )
2011-05-14 11:10:21 -07:00
strHelp = strHelp . substr ( 0 , strHelp . find ( ' \n ' ) ) ;
strRet + = strHelp + " \n " ;
}
}
if ( strRet = = " " )
2014-01-16 07:15:27 -08:00
strRet = strprintf ( " help: unknown command: %s \n " , strCommand ) ;
2011-05-14 11:10:21 -07:00
strRet = strRet . substr ( 0 , strRet . size ( ) - 1 ) ;
return strRet ;
}
2012-04-18 13:42:17 -07:00
Value help ( const Array & params , bool fHelp )
{
if ( fHelp | | params . size ( ) > 1 )
throw runtime_error (
2013-10-29 04:29:44 -07:00
" help ( \" command \" ) \n "
" \n List all commands, or get help for a specified command. \n "
" \n Arguments: \n "
" 1. \" command \" (string, optional) The command to get help on \n "
" \n Result: \n "
" \" text \" (string) The help text \n "
) ;
2012-04-18 13:42:17 -07:00
string strCommand ;
if ( params . size ( ) > 0 )
strCommand = params [ 0 ] . get_str ( ) ;
return tableRPC . help ( strCommand ) ;
}
2011-05-14 11:10:21 -07:00
Value stop ( const Array & params , bool fHelp )
{
2013-01-20 09:50:30 -08:00
// Accept the deprecated and ignored 'detach' boolean argument
2012-09-18 19:54:43 -07:00
if ( fHelp | | params . size ( ) > 1 )
2011-05-14 11:10:21 -07:00
throw runtime_error (
2012-11-04 03:48:45 -08:00
" stop \n "
2013-10-29 04:29:44 -07:00
" \n Stop Bitcoin server. " ) ;
2011-05-14 11:10:21 -07:00
// Shutdown will take long enough that the response should get back
2012-06-10 22:40:14 -07:00
StartShutdown ( ) ;
2012-05-13 07:09:14 -07:00
return " Bitcoin server stopping " ;
2011-05-14 11:10:21 -07:00
}
//
// Call Table
//
2012-04-14 20:55:05 -07:00
2012-04-20 16:37:34 -07:00
static const CRPCCommand vRPCCommands [ ] =
2013-08-24 21:00:02 -07:00
{ // name actor (function) okSafeMode threadSafe reqWallet
// ------------------------ ----------------------- ---------- ---------- ---------
2014-03-26 04:26:43 -07:00
/* Overall control/query calls */
{ " getinfo " , & getinfo , true , false , false } , /* uses wallet if enabled */
2013-08-24 21:00:02 -07:00
{ " help " , & help , true , true , false } ,
{ " stop " , & stop , true , true , false } ,
2014-03-26 04:26:43 -07:00
/* P2P networking */
2014-05-05 04:22:28 -07:00
{ " getnetworkinfo " , & getnetworkinfo , true , false , false } ,
2013-08-24 21:00:02 -07:00
{ " addnode " , & addnode , true , true , false } ,
{ " getaddednodeinfo " , & getaddednodeinfo , true , true , false } ,
2014-03-26 04:26:43 -07:00
{ " getconnectioncount " , & getconnectioncount , true , false , false } ,
2013-08-22 09:09:32 -07:00
{ " getnettotals " , & getnettotals , true , true , false } ,
2014-03-26 04:26:43 -07:00
{ " getpeerinfo " , & getpeerinfo , true , false , false } ,
{ " ping " , & ping , true , false , false } ,
/* Block chain and UTXO */
2014-05-05 04:22:28 -07:00
{ " getblockchaininfo " , & getblockchaininfo , true , false , false } ,
2014-03-26 04:26:43 -07:00
{ " getbestblockhash " , & getbestblockhash , true , false , false } ,
{ " getblockcount " , & getblockcount , true , false , false } ,
2013-11-29 07:04:29 -08:00
{ " getblock " , & getblock , false , false , false } ,
{ " getblockhash " , & getblockhash , false , false , false } ,
2014-03-26 04:26:43 -07:00
{ " getdifficulty " , & getdifficulty , true , false , false } ,
{ " getrawmempool " , & getrawmempool , true , false , false } ,
2013-11-29 07:04:29 -08:00
{ " gettxout " , & gettxout , true , false , false } ,
2014-03-26 04:26:43 -07:00
{ " gettxoutsetinfo " , & gettxoutsetinfo , true , false , false } ,
2013-11-29 07:04:29 -08:00
{ " verifychain " , & verifychain , true , false , false } ,
2013-12-08 06:26:08 -08:00
/* Mining */
{ " getblocktemplate " , & getblocktemplate , true , false , false } ,
2014-03-26 04:26:43 -07:00
{ " getmininginfo " , & getmininginfo , true , false , false } ,
{ " getnetworkhashps " , & getnetworkhashps , true , false , false } ,
2013-12-08 06:26:08 -08:00
{ " submitblock " , & submitblock , false , false , false } ,
2014-03-26 04:26:43 -07:00
/* Raw transactions */
{ " createrawtransaction " , & createrawtransaction , false , false , false } ,
{ " decoderawtransaction " , & decoderawtransaction , false , false , false } ,
{ " decodescript " , & decodescript , false , false , false } ,
{ " getrawtransaction " , & getrawtransaction , false , false , false } ,
{ " sendrawtransaction " , & sendrawtransaction , false , false , false } ,
{ " signrawtransaction " , & signrawtransaction , false , false , false } , /* uses wallet if enabled */
/* Utility functions */
2013-12-13 07:21:38 -08:00
{ " createmultisig " , & createmultisig , true , true , false } ,
2014-03-26 04:26:43 -07:00
{ " validateaddress " , & validateaddress , true , false , false } , /* uses wallet if enabled */
2013-12-13 07:23:39 -08:00
{ " verifymessage " , & verifymessage , false , false , false } ,
2013-12-08 06:26:08 -08:00
# ifdef ENABLE_WALLET
/* Wallet */
2014-03-26 04:26:43 -07:00
{ " addmultisigaddress " , & addmultisigaddress , false , false , true } ,
{ " backupwallet " , & backupwallet , true , false , true } ,
{ " dumpprivkey " , & dumpprivkey , true , false , true } ,
{ " dumpwallet " , & dumpwallet , true , false , true } ,
{ " encryptwallet " , & encryptwallet , false , false , true } ,
2013-08-24 21:00:02 -07:00
{ " getaccountaddress " , & getaccountaddress , true , false , true } ,
{ " getaccount " , & getaccount , false , false , true } ,
{ " getaddressesbyaccount " , & getaddressesbyaccount , true , false , true } ,
{ " getbalance " , & getbalance , false , false , true } ,
2014-03-26 04:26:43 -07:00
{ " getnewaddress " , & getnewaddress , true , false , true } ,
{ " getrawchangeaddress " , & getrawchangeaddress , true , false , true } ,
{ " getreceivedbyaccount " , & getreceivedbyaccount , false , false , true } ,
{ " getreceivedbyaddress " , & getreceivedbyaddress , false , false , true } ,
2013-08-24 21:00:02 -07:00
{ " gettransaction " , & gettransaction , false , false , true } ,
2014-03-26 04:26:43 -07:00
{ " getunconfirmedbalance " , & getunconfirmedbalance , false , false , true } ,
{ " getwalletinfo " , & getwalletinfo , true , false , true } ,
2013-08-24 21:00:02 -07:00
{ " importprivkey " , & importprivkey , false , false , true } ,
{ " importwallet " , & importwallet , false , false , true } ,
2014-03-26 04:26:43 -07:00
{ " keypoolrefill " , & keypoolrefill , true , false , true } ,
{ " listaccounts " , & listaccounts , false , false , true } ,
{ " listaddressgroupings " , & listaddressgroupings , false , false , true } ,
{ " listlockunspent " , & listlockunspent , false , false , true } ,
{ " listreceivedbyaccount " , & listreceivedbyaccount , false , false , true } ,
{ " listreceivedbyaddress " , & listreceivedbyaddress , false , false , true } ,
{ " listsinceblock " , & listsinceblock , false , false , true } ,
{ " listtransactions " , & listtransactions , false , false , true } ,
2013-08-24 21:00:02 -07:00
{ " listunspent " , & listunspent , false , false , true } ,
{ " lockunspent " , & lockunspent , false , false , true } ,
2014-03-26 04:26:43 -07:00
{ " move " , & movecmd , false , false , true } ,
{ " sendfrom " , & sendfrom , false , false , true } ,
{ " sendmany " , & sendmany , false , false , true } ,
{ " sendtoaddress " , & sendtoaddress , false , false , true } ,
{ " setaccount " , & setaccount , true , false , true } ,
2013-12-13 07:06:32 -08:00
{ " settxfee " , & settxfee , false , false , true } ,
2014-03-26 04:26:43 -07:00
{ " signmessage " , & signmessage , false , false , true } ,
{ " walletlock " , & walletlock , true , false , true } ,
{ " walletpassphrasechange " , & walletpassphrasechange , false , false , true } ,
{ " walletpassphrase " , & walletpassphrase , true , false , true } ,
2013-12-08 06:26:08 -08:00
/* Wallet-enabled mining */
{ " getgenerate " , & getgenerate , true , false , false } ,
{ " gethashespersec " , & gethashespersec , true , false , false } ,
2014-03-26 04:26:43 -07:00
{ " getwork " , & getwork , true , false , true } ,
{ " setgenerate " , & setgenerate , true , true , false } ,
2013-11-29 07:04:29 -08:00
# endif // ENABLE_WALLET
2011-05-14 11:10:21 -07:00
} ;
2012-04-18 13:42:17 -07:00
CRPCTable : : CRPCTable ( )
2012-04-14 20:55:05 -07:00
{
unsigned int vcidx ;
for ( vcidx = 0 ; vcidx < ( sizeof ( vRPCCommands ) / sizeof ( vRPCCommands [ 0 ] ) ) ; vcidx + + )
{
2012-04-20 16:37:34 -07:00
const CRPCCommand * pcmd ;
2011-05-14 11:10:21 -07:00
2012-04-14 20:55:05 -07:00
pcmd = & vRPCCommands [ vcidx ] ;
mapCommands [ pcmd - > name ] = pcmd ;
}
}
2011-05-14 11:10:21 -07:00
2012-04-18 13:42:17 -07:00
const CRPCCommand * CRPCTable : : operator [ ] ( string name ) const
{
map < string , const CRPCCommand * > : : const_iterator it = mapCommands . find ( name ) ;
if ( it = = mapCommands . end ( ) )
return NULL ;
return ( * it ) . second ;
}
2011-05-14 11:10:21 -07:00
bool HTTPAuthorized ( map < string , string > & mapHeaders )
{
string strAuth = mapHeaders [ " authorization " ] ;
if ( strAuth . substr ( 0 , 6 ) ! = " Basic " )
return false ;
string strUserPass64 = strAuth . substr ( 6 ) ; boost : : trim ( strUserPass64 ) ;
string strUserPass = DecodeBase64 ( strUserPass64 ) ;
2013-08-08 02:58:57 -07:00
return TimingResistantEqual ( strUserPass , strRPCUserColonPass ) ;
2011-05-14 11:10:21 -07:00
}
void ErrorReply ( std : : ostream & stream , const Object & objError , const Value & id )
{
// Send error reply from json-rpc error object
2012-10-04 01:43:40 -07:00
int nStatus = HTTP_INTERNAL_SERVER_ERROR ;
2011-05-14 11:10:21 -07:00
int code = find_value ( objError , " code " ) . get_int ( ) ;
2012-10-04 01:43:40 -07:00
if ( code = = RPC_INVALID_REQUEST ) nStatus = HTTP_BAD_REQUEST ;
else if ( code = = RPC_METHOD_NOT_FOUND ) nStatus = HTTP_NOT_FOUND ;
2011-05-14 11:10:21 -07:00
string strReply = JSONRPCReply ( Value : : null , objError , id ) ;
2012-04-23 22:10:02 -07:00
stream < < HTTPReply ( nStatus , strReply , false ) < < std : : flush ;
2011-05-14 11:10:21 -07:00
}
2014-04-28 06:23:29 -07:00
CNetAddr BoostAsioToCNetAddr ( boost : : asio : : ip : : address address )
2011-05-14 11:10:21 -07:00
{
2014-04-28 04:48:26 -07:00
CNetAddr netaddr ;
2011-08-10 05:21:43 -07:00
// Make sure that IPv4-compatible and IPv4-mapped IPv6 addresses are treated as IPv4 addresses
if ( address . is_v6 ( )
& & ( address . to_v6 ( ) . is_v4_compatible ( )
| | address . to_v6 ( ) . is_v4_mapped ( ) ) )
2014-04-28 04:48:26 -07:00
address = address . to_v6 ( ) . to_v4 ( ) ;
if ( address . is_v4 ( ) )
{
boost : : asio : : ip : : address_v4 : : bytes_type bytes = address . to_v4 ( ) . to_bytes ( ) ;
netaddr . SetRaw ( NET_IPV4 , & bytes [ 0 ] ) ;
}
else
{
boost : : asio : : ip : : address_v6 : : bytes_type bytes = address . to_v6 ( ) . to_bytes ( ) ;
netaddr . SetRaw ( NET_IPV6 , & bytes [ 0 ] ) ;
}
return netaddr ;
}
bool ClientAllowed ( const boost : : asio : : ip : : address & address )
{
CNetAddr netaddr = BoostAsioToCNetAddr ( address ) ;
BOOST_FOREACH ( const CSubNet & subnet , rpc_allow_subnets )
if ( subnet . Match ( netaddr ) )
2011-05-14 11:10:21 -07:00
return true ;
return false ;
}
2012-04-14 17:35:58 -07:00
class AcceptedConnection
{
2011-08-10 06:07:46 -07:00
public :
virtual ~ AcceptedConnection ( ) { }
virtual std : : iostream & stream ( ) = 0 ;
virtual std : : string peer_address_to_string ( ) const = 0 ;
virtual void close ( ) = 0 ;
} ;
2012-04-14 17:35:58 -07:00
2011-08-10 06:07:46 -07:00
template < typename Protocol >
class AcceptedConnectionImpl : public AcceptedConnection
{
public :
AcceptedConnectionImpl (
asio : : io_service & io_service ,
ssl : : context & context ,
bool fUseSSL ) :
sslStream ( io_service , context ) ,
_d ( sslStream , fUseSSL ) ,
_stream ( _d )
{
}
virtual std : : iostream & stream ( )
{
return _stream ;
}
virtual std : : string peer_address_to_string ( ) const
{
return peer . address ( ) . to_string ( ) ;
}
2012-04-14 17:35:58 -07:00
2011-08-10 06:07:46 -07:00
virtual void close ( )
{
_stream . close ( ) ;
}
typename Protocol : : endpoint peer ;
asio : : ssl : : stream < typename Protocol : : socket > sslStream ;
private :
SSLIOStreamDevice < Protocol > _d ;
iostreams : : stream < SSLIOStreamDevice < Protocol > > _stream ;
2012-04-14 17:35:58 -07:00
} ;
2013-03-06 19:31:26 -08:00
void ServiceConnection ( AcceptedConnection * conn ) ;
2011-05-14 11:10:21 -07:00
2011-08-10 04:53:13 -07:00
// Forward declaration required for RPCListen
2011-08-10 06:07:46 -07:00
template < typename Protocol , typename SocketAcceptorService >
static void RPCAcceptHandler ( boost : : shared_ptr < basic_socket_acceptor < Protocol , SocketAcceptorService > > acceptor ,
2011-08-10 04:53:13 -07:00
ssl : : context & context ,
bool fUseSSL ,
2014-05-07 00:24:44 -07:00
boost : : shared_ptr < AcceptedConnection > conn ,
2011-08-10 04:53:13 -07:00
const boost : : system : : error_code & error ) ;
/**
* Sets up I / O resources to accept and handle a new connection .
*/
2011-08-10 06:07:46 -07:00
template < typename Protocol , typename SocketAcceptorService >
static void RPCListen ( boost : : shared_ptr < basic_socket_acceptor < Protocol , SocketAcceptorService > > acceptor ,
2011-08-10 04:53:13 -07:00
ssl : : context & context ,
const bool fUseSSL )
{
// Accept connection
2014-05-07 00:24:44 -07:00
boost : : shared_ptr < AcceptedConnectionImpl < Protocol > > conn ( new AcceptedConnectionImpl < Protocol > ( acceptor - > get_io_service ( ) , context , fUseSSL ) ) ;
2011-08-10 04:53:13 -07:00
acceptor - > async_accept (
conn - > sslStream . lowest_layer ( ) ,
conn - > peer ,
2011-08-10 06:07:46 -07:00
boost : : bind ( & RPCAcceptHandler < Protocol , SocketAcceptorService > ,
2011-08-10 04:53:13 -07:00
acceptor ,
boost : : ref ( context ) ,
fUseSSL ,
conn ,
2014-05-07 00:09:13 -07:00
_1 ) ) ;
2011-08-10 04:53:13 -07:00
}
2013-11-20 05:18:57 -08:00
2011-08-10 04:53:13 -07:00
/**
* Accept and handle incoming connection .
*/
2011-08-10 06:07:46 -07:00
template < typename Protocol , typename SocketAcceptorService >
static void RPCAcceptHandler ( boost : : shared_ptr < basic_socket_acceptor < Protocol , SocketAcceptorService > > acceptor ,
2011-08-10 04:53:13 -07:00
ssl : : context & context ,
const bool fUseSSL ,
2014-05-07 00:24:44 -07:00
boost : : shared_ptr < AcceptedConnection > conn ,
2011-08-10 04:53:13 -07:00
const boost : : system : : error_code & error )
{
2012-07-25 17:48:39 -07:00
// Immediately start accepting new connections, except when we're cancelled or our socket is closed.
2013-03-06 19:31:26 -08:00
if ( error ! = asio : : error : : operation_aborted & & acceptor - > is_open ( ) )
2012-06-24 04:20:17 -07:00
RPCListen ( acceptor , context , fUseSSL ) ;
2011-08-10 04:53:13 -07:00
2014-05-07 00:24:44 -07:00
AcceptedConnectionImpl < ip : : tcp > * tcp_conn = dynamic_cast < AcceptedConnectionImpl < ip : : tcp > * > ( conn . get ( ) ) ;
2011-08-10 06:07:46 -07:00
2011-08-10 04:53:13 -07:00
if ( error )
{
2014-05-07 00:09:13 -07:00
// TODO: Actually handle errors
LogPrintf ( " %s: Error: %s \n " , __func__ , error . message ( ) ) ;
2011-08-10 04:53:13 -07:00
}
// Restrict callers by IP. It is important to
// do this before starting client thread, to filter out
// certain DoS and misbehaving clients.
2013-03-06 19:31:26 -08:00
else if ( tcp_conn & & ! ClientAllowed ( tcp_conn - > peer . address ( ) ) )
2011-08-10 04:53:13 -07:00
{
// Only send a 403 if we're not using SSL to prevent a DoS during the SSL handshake.
if ( ! fUseSSL )
2012-10-04 01:43:40 -07:00
conn - > stream ( ) < < HTTPReply ( HTTP_FORBIDDEN , " " , false ) < < std : : flush ;
2014-05-07 00:24:44 -07:00
conn - > close ( ) ;
2011-08-10 04:53:13 -07:00
}
2013-03-06 19:31:26 -08:00
else {
2014-05-07 00:24:44 -07:00
ServiceConnection ( conn . get ( ) ) ;
2013-03-06 19:31:26 -08:00
conn - > close ( ) ;
2011-08-10 04:53:13 -07:00
}
}
2014-02-17 08:35:40 -08:00
static ip : : tcp : : endpoint ParseEndpoint ( const std : : string & strEndpoint , int defaultPort )
{
std : : string addr ;
int port = defaultPort ;
SplitHostPort ( strEndpoint , port , addr ) ;
return ip : : tcp : : endpoint ( asio : : ip : : address : : from_string ( addr ) , port ) ;
}
2013-03-06 19:31:26 -08:00
void StartRPCThreads ( )
2011-05-14 11:10:21 -07:00
{
2014-04-28 04:48:26 -07:00
rpc_allow_subnets . clear ( ) ;
rpc_allow_subnets . push_back ( CSubNet ( " 127.0.0.0/8 " ) ) ; // always allow IPv4 local subnet
rpc_allow_subnets . push_back ( CSubNet ( " ::1 " ) ) ; // always allow IPv6 localhost
if ( mapMultiArgs . count ( " -rpcallowip " ) )
{
const vector < string > & vAllow = mapMultiArgs [ " -rpcallowip " ] ;
BOOST_FOREACH ( string strAllow , vAllow )
{
CSubNet subnet ( strAllow ) ;
if ( ! subnet . IsValid ( ) )
{
uiInterface . ThreadSafeMessageBox (
strprintf ( " Invalid -rpcallowip subnet specification: %s " , strAllow ) ,
" " , 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 ) ;
2011-12-01 06:07:02 -08:00
strRPCUserColonPass = mapArgs [ " -rpcuser " ] + " : " + mapArgs [ " -rpcpassword " ] ;
2013-05-07 06:16:25 -07:00
if ( ( ( mapArgs [ " -rpcpassword " ] = = " " ) | |
( mapArgs [ " -rpcuser " ] = = mapArgs [ " -rpcpassword " ] ) ) & & Params ( ) . RequireRPCPassword ( ) )
2011-05-14 11:10:21 -07:00
{
2012-02-04 23:30:43 -08:00
unsigned char rand_pwd [ 32 ] ;
RAND_bytes ( rand_pwd , 32 ) ;
2011-05-14 11:10:21 -07:00
string strWhatAmI = " To use bitcoind " ;
if ( mapArgs . count ( " -server " ) )
strWhatAmI = strprintf ( _ ( " To use the %s option " ) , " \" -server \" " ) ;
else if ( mapArgs . count ( " -daemon " ) )
strWhatAmI = strprintf ( _ ( " To use the %s option " ) , " \" -daemon \" " ) ;
2012-05-06 10:40:58 -07:00
uiInterface . ThreadSafeMessageBox ( strprintf (
2013-04-02 06:45:08 -07:00
_ ( " %s, you must set a rpcpassword in the configuration file: \n "
" %s \n "
2012-03-31 06:08:25 -07:00
" It is recommended you use the following random password: \n "
" rpcuser=bitcoinrpc \n "
" rpcpassword=%s \n "
" (you do not need to remember this password) \n "
2012-11-04 22:41:53 -08:00
" The username and password MUST NOT be the same. \n "
2013-03-21 07:08:21 -07:00
" If the file does not exist, create it with owner-readable-only file permissions. \n "
" It is also recommended to set alertnotify so you are notified of problems; \n "
" for example: alertnotify=echo %%s | mail -s \" Bitcoin Alert \" admin@foo.com \n " ) ,
2014-01-16 07:15:27 -08:00
strWhatAmI ,
GetConfigFile ( ) . string ( ) ,
EncodeBase58 ( & rand_pwd [ 0 ] , & rand_pwd [ 0 ] + 32 ) ) ,
2012-11-04 23:04:21 -08:00
" " , CClientUIInterface : : MSG_ERROR ) ;
2012-06-10 22:40:14 -07:00
StartShutdown ( ) ;
2011-05-14 11:10:21 -07:00
return ;
}
2013-03-06 19:31:26 -08:00
assert ( rpc_io_service = = NULL ) ;
rpc_io_service = new asio : : io_service ( ) ;
rpc_ssl_context = new ssl : : context ( * rpc_io_service , ssl : : context : : sslv23 ) ;
2011-05-14 11:10:21 -07:00
2013-04-28 08:37:50 -07:00
const bool fUseSSL = GetBoolArg ( " -rpcssl " , false ) ;
2012-05-20 11:27:53 -07:00
2011-05-14 11:10:21 -07:00
if ( fUseSSL )
{
2013-03-06 19:31:26 -08:00
rpc_ssl_context - > set_options ( ssl : : context : : no_sslv2 ) ;
2012-03-31 06:05:55 -07:00
filesystem : : path pathCertFile ( GetArg ( " -rpcsslcertificatechainfile " , " server.cert " ) ) ;
if ( ! pathCertFile . is_complete ( ) ) pathCertFile = filesystem : : path ( GetDataDir ( ) ) / pathCertFile ;
2013-03-06 19:31:26 -08:00
if ( filesystem : : exists ( pathCertFile ) ) rpc_ssl_context - > use_certificate_chain_file ( pathCertFile . string ( ) ) ;
2014-01-16 07:15:27 -08:00
else LogPrintf ( " ThreadRPCServer ERROR: missing server certificate file %s \n " , pathCertFile . string ( ) ) ;
2012-03-31 06:05:55 -07:00
filesystem : : path pathPKFile ( GetArg ( " -rpcsslprivatekeyfile " , " server.pem " ) ) ;
if ( ! pathPKFile . is_complete ( ) ) pathPKFile = filesystem : : path ( GetDataDir ( ) ) / pathPKFile ;
2013-03-06 19:31:26 -08:00
if ( filesystem : : exists ( pathPKFile ) ) rpc_ssl_context - > use_private_key_file ( pathPKFile . string ( ) , ssl : : context : : pem ) ;
2014-01-16 07:15:27 -08:00
else LogPrintf ( " ThreadRPCServer ERROR: missing server private key file %s \n " , pathPKFile . string ( ) ) ;
2012-03-31 06:05:55 -07:00
2013-10-17 07:11:25 -07:00
string strCiphers = GetArg ( " -rpcsslciphers " , " TLSv1.2+HIGH:TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!3DES:@STRENGTH " ) ;
2013-03-06 19:31:26 -08:00
SSL_CTX_set_cipher_list ( rpc_ssl_context - > impl ( ) , strCiphers . c_str ( ) ) ;
2011-05-14 11:10:21 -07:00
}
2014-02-17 08:35:40 -08:00
std : : vector < ip : : tcp : : endpoint > vEndpoints ;
bool bBindAny = false ;
int defaultPort = GetArg ( " -rpcport " , Params ( ) . RPCPort ( ) ) ;
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 ) ) ;
}
catch ( boost : : system : : system_error & e )
{
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 ;
}
2012-06-28 09:32:32 -07:00
2012-09-12 07:45:01 -07:00
bool fListening = false ;
std : : string strerr ;
2014-02-17 08:35:40 -08:00
BOOST_FOREACH ( const ip : : tcp : : endpoint & endpoint , vEndpoints )
2011-08-10 05:17:02 -07:00
{
2014-02-17 08:35:40 -08:00
asio : : ip : : address bindAddress = endpoint . address ( ) ;
LogPrintf ( " Binding RPC on address %s port %i (IPv4+IPv6 bind any: %i) \n " , bindAddress . to_string ( ) , endpoint . port ( ) , bBindAny ) ;
boost : : system : : error_code v6_only_error ;
2014-05-09 01:01:50 -07:00
boost : : shared_ptr < ip : : tcp : : acceptor > acceptor ( new ip : : tcp : : acceptor ( * rpc_io_service ) ) ;
rpc_acceptors . push_back ( acceptor ) ;
2011-08-10 05:17:02 -07:00
2014-02-17 08:35:40 -08:00
try {
2012-06-24 04:20:17 -07:00
acceptor - > open ( endpoint . protocol ( ) ) ;
acceptor - > set_option ( boost : : asio : : ip : : tcp : : acceptor : : reuse_address ( true ) ) ;
2014-02-17 08:35:40 -08:00
// Try making the socket dual IPv6/IPv4 when listening on the IPv6 "any" address
acceptor - > set_option ( boost : : asio : : ip : : v6_only (
! bBindAny | | bindAddress ! = asio : : ip : : address_v6 : : any ( ) ) , v6_only_error ) ;
2012-06-24 04:20:17 -07:00
acceptor - > bind ( endpoint ) ;
acceptor - > listen ( socket_base : : max_connections ) ;
2013-03-06 19:31:26 -08:00
RPCListen ( acceptor , * rpc_ssl_context , fUseSSL ) ;
2012-09-12 07:45:01 -07:00
fListening = true ;
2014-02-17 08:35:40 -08:00
// If dual IPv6/IPv4 bind succesful, skip binding to IPv4 separately
if ( bBindAny & & bindAddress = = asio : : ip : : address_v6 : : any ( ) & & ! v6_only_error )
break ;
}
catch ( boost : : system : : system_error & e )
{
LogPrintf ( " ERROR: Binding RPC on address %s port %i failed: %s \n " , bindAddress . to_string ( ) , endpoint . port ( ) , e . what ( ) ) ;
strerr = strprintf ( _ ( " An error occurred while setting up the RPC address %s port %u for listening: %s " ) , bindAddress . to_string ( ) , endpoint . port ( ) , e . what ( ) ) ;
2011-08-10 05:17:02 -07:00
}
2012-09-12 07:45:01 -07:00
}
if ( ! fListening ) {
2012-11-04 23:04:21 -08:00
uiInterface . ThreadSafeMessageBox ( strerr , " " , CClientUIInterface : : MSG_ERROR ) ;
2012-06-17 05:30:37 -07:00
StartShutdown ( ) ;
2011-08-10 05:17:02 -07:00
return ;
}
2011-05-14 11:10:21 -07:00
2013-03-06 19:31:26 -08:00
rpc_worker_group = new boost : : thread_group ( ) ;
for ( int i = 0 ; i < GetArg ( " -rpcthreads " , 4 ) ; i + + )
rpc_worker_group - > create_thread ( boost : : bind ( & asio : : io_service : : run , rpc_io_service ) ) ;
}
2014-01-17 07:32:35 -08:00
void StartDummyRPCThread ( )
{
if ( rpc_io_service = = NULL )
{
rpc_io_service = new asio : : io_service ( ) ;
/* Create dummy "work" to keep the thread from exiting when no timeouts active,
* see http : //www.boost.org/doc/libs/1_51_0/doc/html/boost_asio/reference/io_service.html#boost_asio.reference.io_service.stopping_the_io_service_from_running_out_of_work */
rpc_dummy_work = new asio : : io_service : : work ( * rpc_io_service ) ;
rpc_worker_group = new boost : : thread_group ( ) ;
rpc_worker_group - > create_thread ( boost : : bind ( & asio : : io_service : : run , rpc_io_service ) ) ;
}
}
2013-03-06 19:31:26 -08:00
void StopRPCThreads ( )
{
if ( rpc_io_service = = NULL ) return ;
2014-05-09 01:01:50 -07:00
// First, cancel all timers and acceptors
// This is not done automatically by ->stop(), and in some cases the destructor of
// asio::io_service can hang if this is skipped.
BOOST_FOREACH ( const boost : : shared_ptr < ip : : tcp : : acceptor > & acceptor , rpc_acceptors )
acceptor - > cancel ( ) ;
rpc_acceptors . clear ( ) ;
BOOST_FOREACH ( const PAIRTYPE ( std : : string , boost : : shared_ptr < deadline_timer > ) & timer , deadlineTimers )
timer . second - > cancel ( ) ;
2013-05-07 07:47:00 -07:00
deadlineTimers . clear ( ) ;
2014-05-09 01:01:50 -07:00
2013-03-06 19:31:26 -08:00
rpc_io_service - > stop ( ) ;
2013-10-14 22:30:20 -07:00
if ( rpc_worker_group ! = NULL )
rpc_worker_group - > join_all ( ) ;
2014-01-17 07:32:35 -08:00
delete rpc_dummy_work ; rpc_dummy_work = NULL ;
2013-03-06 19:31:26 -08:00
delete rpc_worker_group ; rpc_worker_group = NULL ;
delete rpc_ssl_context ; rpc_ssl_context = NULL ;
delete rpc_io_service ; rpc_io_service = NULL ;
2012-04-14 17:35:58 -07:00
}
2013-05-07 07:47:00 -07:00
void RPCRunHandler ( const boost : : system : : error_code & err , boost : : function < void ( void ) > func )
{
if ( ! err )
func ( ) ;
}
2013-04-12 22:13:08 -07:00
void RPCRunLater ( const std : : string & name , boost : : function < void ( void ) > func , int64_t nSeconds )
2013-05-07 07:47:00 -07:00
{
assert ( rpc_io_service ! = NULL ) ;
if ( deadlineTimers . count ( name ) = = 0 )
{
deadlineTimers . insert ( make_pair ( name ,
boost : : shared_ptr < deadline_timer > ( new deadline_timer ( * rpc_io_service ) ) ) ) ;
}
deadlineTimers [ name ] - > expires_from_now ( posix_time : : seconds ( nSeconds ) ) ;
deadlineTimers [ name ] - > async_wait ( boost : : bind ( RPCRunHandler , _1 , func ) ) ;
}
2012-06-27 10:47:02 -07:00
class JSONRequest
{
public :
Value id ;
string strMethod ;
Array params ;
JSONRequest ( ) { id = Value : : null ; }
void parse ( const Value & valRequest ) ;
} ;
void JSONRequest : : parse ( const Value & valRequest )
{
// Parse request
if ( valRequest . type ( ) ! = obj_type )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_INVALID_REQUEST , " Invalid Request object " ) ;
2012-06-27 10:47:02 -07:00
const Object & request = valRequest . get_obj ( ) ;
// Parse id now so errors from here on will have the id
id = find_value ( request , " id " ) ;
// Parse method
Value valMethod = find_value ( request , " method " ) ;
if ( valMethod . type ( ) = = null_type )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_INVALID_REQUEST , " Missing method " ) ;
2012-06-27 10:47:02 -07:00
if ( valMethod . type ( ) ! = str_type )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_INVALID_REQUEST , " Method must be a string " ) ;
2012-06-27 10:47:02 -07:00
strMethod = valMethod . get_str ( ) ;
2012-08-02 18:12:55 -07:00
if ( strMethod ! = " getwork " & & strMethod ! = " getblocktemplate " )
2014-01-16 07:15:27 -08:00
LogPrint ( " rpc " , " ThreadRPCServer method=%s \n " , strMethod ) ;
2012-06-27 10:47:02 -07:00
// Parse params
Value valParams = find_value ( request , " params " ) ;
if ( valParams . type ( ) = = array_type )
params = valParams . get_array ( ) ;
else if ( valParams . type ( ) = = null_type )
params = Array ( ) ;
else
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_INVALID_REQUEST , " Params must be an array " ) ;
2012-06-27 10:47:02 -07:00
}
2013-11-20 05:18:57 -08:00
2012-06-23 23:01:28 -07:00
static Object JSONRPCExecOne ( const Value & req )
{
Object rpc_result ;
JSONRequest jreq ;
try {
jreq . parse ( req ) ;
Value result = tableRPC . execute ( jreq . strMethod , jreq . params ) ;
rpc_result = JSONRPCReplyObj ( result , Value : : null , jreq . id ) ;
}
catch ( Object & objError )
{
rpc_result = JSONRPCReplyObj ( Value : : null , objError , jreq . id ) ;
}
catch ( std : : exception & e )
{
rpc_result = JSONRPCReplyObj ( Value : : null ,
2012-10-04 00:34:44 -07:00
JSONRPCError ( RPC_PARSE_ERROR , e . what ( ) ) , jreq . id ) ;
2012-06-23 23:01:28 -07:00
}
return rpc_result ;
}
static string JSONRPCExecBatch ( const Array & vReq )
{
Array ret ;
for ( unsigned int reqIdx = 0 ; reqIdx < vReq . size ( ) ; reqIdx + + )
ret . push_back ( JSONRPCExecOne ( vReq [ reqIdx ] ) ) ;
2013-10-22 02:43:38 -07:00
return write_string ( Value ( ret ) , false ) + " \n " ;
2012-06-23 23:01:28 -07:00
}
2013-03-06 19:31:26 -08:00
void ServiceConnection ( AcceptedConnection * conn )
2012-04-14 17:35:58 -07:00
{
2012-04-23 22:10:02 -07:00
bool fRun = true ;
2014-03-13 14:51:05 -07:00
while ( fRun & & ! ShutdownRequested ( ) )
2013-03-06 19:31:26 -08:00
{
2012-11-04 13:06:38 -08:00
int nProto = 0 ;
2011-05-14 11:10:21 -07:00
map < string , string > mapHeaders ;
2012-11-04 14:16:46 -08:00
string strRequest , strMethod , strURI ;
// Read HTTP request line
if ( ! ReadHTTPRequestLine ( conn - > stream ( ) , nProto , strMethod , strURI ) )
break ;
2011-05-14 11:10:21 -07:00
2012-11-04 13:06:38 -08:00
// Read HTTP message headers and body
ReadHTTPMessage ( conn - > stream ( ) , mapHeaders , strRequest , nProto ) ;
2011-05-14 11:10:21 -07:00
2013-05-01 07:41:24 -07:00
if ( strURI ! = " / " ) {
conn - > stream ( ) < < HTTPReply ( HTTP_NOT_FOUND , " " , false ) < < std : : flush ;
break ;
}
2011-05-14 11:10:21 -07:00
// Check authorization
if ( mapHeaders . count ( " authorization " ) = = 0 )
{
2012-10-04 01:43:40 -07:00
conn - > stream ( ) < < HTTPReply ( HTTP_UNAUTHORIZED , " " , false ) < < std : : flush ;
2012-04-14 17:35:58 -07:00
break ;
2011-05-14 11:10:21 -07:00
}
if ( ! HTTPAuthorized ( mapHeaders ) )
{
2014-01-16 07:15:27 -08:00
LogPrintf ( " ThreadRPCServer incorrect password attempt from %s \n " , conn - > peer_address_to_string ( ) ) ;
2012-02-04 23:30:43 -08:00
/* Deter brute-forcing short passwords.
2013-10-01 00:47:16 -07:00
If this results in a DoS the user really
shouldn ' t have their RPC port exposed . */
2012-02-04 23:30:43 -08:00
if ( mapArgs [ " -rpcpassword " ] . size ( ) < 20 )
2013-03-07 11:25:21 -08:00
MilliSleep ( 250 ) ;
2011-05-14 11:10:21 -07:00
2012-10-04 01:43:40 -07:00
conn - > stream ( ) < < HTTPReply ( HTTP_UNAUTHORIZED , " " , false ) < < std : : flush ;
2012-04-14 17:35:58 -07:00
break ;
2011-05-14 11:10:21 -07:00
}
2012-04-23 22:10:02 -07:00
if ( mapHeaders [ " connection " ] = = " close " )
fRun = false ;
2011-05-14 11:10:21 -07:00
2012-06-27 10:47:02 -07:00
JSONRequest jreq ;
2011-05-14 11:10:21 -07:00
try
{
// Parse request
Value valRequest ;
2012-06-23 23:01:28 -07:00
if ( ! read_string ( strRequest , valRequest ) )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_PARSE_ERROR , " Parse error " ) ;
2011-05-14 11:10:21 -07:00
2012-06-23 23:01:28 -07:00
string strReply ;
// singleton request
if ( valRequest . type ( ) = = obj_type ) {
jreq . parse ( valRequest ) ;
2012-06-27 10:47:02 -07:00
2012-06-23 23:01:28 -07:00
Value result = tableRPC . execute ( jreq . strMethod , jreq . params ) ;
2012-04-09 12:07:25 -07:00
2012-06-23 23:01:28 -07:00
// Send reply
strReply = JSONRPCReply ( result , Value : : null , jreq . id ) ;
// array of requests
} else if ( valRequest . type ( ) = = array_type )
strReply = JSONRPCExecBatch ( valRequest . get_array ( ) ) ;
else
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_PARSE_ERROR , " Top-level object parse error " ) ;
2012-09-18 12:07:58 -07:00
2012-10-04 01:43:40 -07:00
conn - > stream ( ) < < HTTPReply ( HTTP_OK , strReply , fRun ) < < std : : flush ;
2011-05-14 11:10:21 -07:00
}
catch ( Object & objError )
{
2012-06-27 10:47:02 -07:00
ErrorReply ( conn - > stream ( ) , objError , jreq . id ) ;
2012-04-14 17:35:58 -07:00
break ;
2011-05-14 11:10:21 -07:00
}
catch ( std : : exception & e )
{
2012-10-04 00:34:44 -07:00
ErrorReply ( conn - > stream ( ) , JSONRPCError ( RPC_PARSE_ERROR , e . what ( ) ) , jreq . id ) ;
2012-04-14 17:35:58 -07:00
break ;
2011-05-14 11:10:21 -07:00
}
}
}
2012-04-09 12:07:25 -07:00
json_spirit : : Value CRPCTable : : execute ( const std : : string & strMethod , const json_spirit : : Array & params ) const
{
// Find method
const CRPCCommand * pcmd = tableRPC [ strMethod ] ;
if ( ! pcmd )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_METHOD_NOT_FOUND , " Method not found " ) ;
2013-11-29 07:04:29 -08:00
# ifdef ENABLE_WALLET
2013-08-24 21:00:02 -07:00
if ( pcmd - > reqWallet & & ! pwalletMain )
throw JSONRPCError ( RPC_METHOD_NOT_FOUND , " Method not found (disabled) " ) ;
2013-11-29 07:04:29 -08:00
# endif
2011-05-14 11:10:21 -07:00
2012-04-09 12:07:25 -07:00
// Observe safe mode
string strWarning = GetWarnings ( " rpc " ) ;
2013-04-28 08:37:50 -07:00
if ( strWarning ! = " " & & ! GetBoolArg ( " -disablesafemode " , false ) & &
2012-04-09 12:07:25 -07:00
! pcmd - > okSafeMode )
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_FORBIDDEN_BY_SAFE_MODE , string ( " Safe mode: " ) + strWarning ) ;
2012-04-09 12:07:25 -07:00
try
{
// Execute
Value result ;
{
2013-03-07 03:18:55 -08:00
if ( pcmd - > threadSafe )
2012-08-21 09:03:52 -07:00
result = pcmd - > actor ( params , false ) ;
2013-11-29 07:04:29 -08:00
# ifdef ENABLE_WALLET
2013-08-24 21:00:02 -07:00
else if ( ! pwalletMain ) {
LOCK ( cs_main ) ;
result = pcmd - > actor ( params , false ) ;
} else {
2012-08-21 09:03:52 -07:00
LOCK2 ( cs_main , pwalletMain - > cs_wallet ) ;
result = pcmd - > actor ( params , false ) ;
}
2013-11-29 07:04:29 -08:00
# else // ENABLE_WALLET
else {
LOCK ( cs_main ) ;
result = pcmd - > actor ( params , false ) ;
}
# endif // !ENABLE_WALLET
2012-04-09 12:07:25 -07:00
}
return result ;
}
catch ( std : : exception & e )
{
2012-10-04 00:34:44 -07:00
throw JSONRPCError ( RPC_MISC_ERROR , e . what ( ) ) ;
2012-04-09 12:07:25 -07:00
}
}
2011-05-14 11:10:21 -07:00
2013-11-29 06:48:07 -08:00
std : : string HelpExampleCli ( string methodname , string args ) {
return " > bitcoin-cli " + methodname + " " + args + " \n " ;
}
std : : string HelpExampleRpc ( string methodname , string args ) {
return " > curl --user myusername --data-binary '{ \" jsonrpc \" : \" 1.0 \" , \" id \" : \" curltest \" , "
" \" method \" : \" " + methodname + " \" , \" params \" : [ " + args + " ] }' -H 'content-type: text/plain;' http://127.0.0.1:8332/ \n " ;
}
2012-04-20 16:37:34 -07:00
const CRPCTable tableRPC ;