src/rpcserver.cpp

   1 // Copyright (c) 2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "rpcserver.h"
   7
   8 #include "base58.h"
   9 #include "init.h"
  10 #include "random.h"
  11 #include "sync.h"
  12 #include "ui_interface.h"
  13 #include "util.h"
  14 #include "utilstrencodings.h"
  15 #ifdef ENABLE_WALLET
  16 #include "wallet/wallet.h"
  17 #endif
  18
  19 #include <boost/algorithm/string.hpp>
  20 #include <boost/asio.hpp>
  21 #include <boost/asio/ssl.hpp>
  22 #include <boost/bind.hpp>
  23 #include <boost/filesystem.hpp>
  24 #include <boost/foreach.hpp>
  25 #include <boost/iostreams/concepts.hpp>
  26 #include <boost/iostreams/stream.hpp>
  27 #include <boost/shared_ptr.hpp>
  28 #include <boost/signals2/signal.hpp>
  29 #include <boost/thread.hpp>
  30 #include "json/json_spirit_writer_template.h"
  31
  32 using namespace boost::asio;
  33 using namespace json_spirit;
  34 using namespace RPCServer;
  35 using namespace std;
  36
  37 static std::string strRPCUserColonPass;
  38
  39 static bool fRPCRunning = false;
  40 static bool fRPCInWarmup = true;
  41 static std::string rpcWarmupStatus("RPC server started");
  42 static CCriticalSection cs_rpcWarmup;
  43
  44 //! These are created by StartRPCThreads, destroyed in StopRPCThreads
  45 static boost::asio::io_service* rpc_io_service = NULL;
  46 static map<string, boost::shared_ptr<deadline_timer> > deadlineTimers;
  47 static ssl::context* rpc_ssl_context = NULL;
  48 static boost::thread_group* rpc_worker_group = NULL;
  49 static boost::asio::io_service::work *rpc_dummy_work = NULL;
  50 static std::vector<CSubNet> rpc_allow_subnets; //!< List of subnets to allow RPC connections from
  51 static std::vector< boost::shared_ptr<ip::tcp::acceptor> > rpc_acceptors;
  52
  53 static struct CRPCSignals
  54 {
  55     boost::signals2::signal<void ()> Started;
  56     boost::signals2::signal<void ()> Stopped;
  57     boost::signals2::signal<void (const CRPCCommand&)> PreCommand;
  58     boost::signals2::signal<void (const CRPCCommand&)> PostCommand;
  59 } g_rpcSignals;
  60
  61 void RPCServer::OnStarted(boost::function<void ()> slot)
  62 {
  63     g_rpcSignals.Started.connect(slot);
  64 }
  65
  66 void RPCServer::OnStopped(boost::function<void ()> slot)
  67 {
  68     g_rpcSignals.Stopped.connect(slot);
  69 }
  70
  71 void RPCServer::OnPreCommand(boost::function<void (const CRPCCommand&)> slot)
  72 {
  73     g_rpcSignals.PreCommand.connect(boost::bind(slot, _1));
  74 }
  75
  76 void RPCServer::OnPostCommand(boost::function<void (const CRPCCommand&)> slot)
  77 {
  78     g_rpcSignals.PostCommand.connect(boost::bind(slot, _1));
  79 }
  80
  81 void RPCTypeCheck(const Array& params,
  82                   const list<Value_type>& typesExpected,
  83                   bool fAllowNull)
  84 {
  85     unsigned int i = 0;
  86     BOOST_FOREACH(Value_type t, typesExpected)
  87     {
  88         if (params.size() <= i)
  89             break;
  90
  91         const Value& v = params[i];
  92         if (!((v.type() == t) || (fAllowNull && (v.type() == null_type))))
  93         {
  94             string err = strprintf("Expected type %s, got %s",
  95                                    Value_type_name[t], Value_type_name[v.type()]);
  96             throw JSONRPCError(RPC_TYPE_ERROR, err);
  97         }
  98         i++;
  99     }
 100 }
 101
 102 void RPCTypeCheck(const Object& o,
 103                   const map<string, Value_type>& typesExpected,
 104                   bool fAllowNull)
 105 {
 106     BOOST_FOREACH(const PAIRTYPE(string, Value_type)& t, typesExpected)
 107     {
 108         const Value& v = find_value(o, t.first);
 109         if (!fAllowNull && v.type() == null_type)
 110             throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));
 111
 112         if (!((v.type() == t.second) || (fAllowNull && (v.type() == null_type))))
 113         {
 114             string err = strprintf("Expected type %s for %s, got %s",
 115                                    Value_type_name[t.second], t.first, Value_type_name[v.type()]);
 116             throw JSONRPCError(RPC_TYPE_ERROR, err);
 117         }
 118     }
 119 }
 120
 121 static inline int64_t roundint64(double d)
 122 {
 123     return (int64_t)(d > 0 ? d + 0.5 : d - 0.5);
 124 }
 125
 126 CAmount AmountFromValue(const Value& value)
 127 {
 128     double dAmount = value.get_real();
 129     if (dAmount <= 0.0 || dAmount > 21000000.0)
 130         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
 131     CAmount nAmount = roundint64(dAmount * COIN);
 132     if (!MoneyRange(nAmount))
 133         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
 134     return nAmount;
 135 }
 136
 137 Value ValueFromAmount(const CAmount& amount)
 138 {
 139     return (double)amount / (double)COIN;
 140 }
 141
 142 uint256 ParseHashV(const Value& v, string strName)
 143 {
 144     string strHex;
 145     if (v.type() == str_type)
 146         strHex = v.get_str();
 147     if (!IsHex(strHex)) // Note: IsHex("") is false
 148         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
 149     uint256 result;
 150     result.SetHex(strHex);
 151     return result;
 152 }
 153 uint256 ParseHashO(const Object& o, string strKey)
 154 {
 155     return ParseHashV(find_value(o, strKey), strKey);
 156 }
 157 vector<unsigned char> ParseHexV(const Value& v, string strName)
 158 {
 159     string strHex;
 160     if (v.type() == str_type)
 161         strHex = v.get_str();
 162     if (!IsHex(strHex))
 163         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
 164     return ParseHex(strHex);
 165 }
 166 vector<unsigned char> ParseHexO(const Object& o, string strKey)
 167 {
 168     return ParseHexV(find_value(o, strKey), strKey);
 169 }
 170
 171
 172 /**
 173  * Note: This interface may still be subject to change.
 174  */
 175
 176 string CRPCTable::help(string strCommand) const
 177 {
 178     string strRet;
 179     string category;
 180     set<rpcfn_type> setDone;
 181     vector<pair<string, const CRPCCommand*> > vCommands;
 182
 183     for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
 184         vCommands.push_back(make_pair(mi->second->category + mi->first, mi->second));
 185     sort(vCommands.begin(), vCommands.end());
 186
 187     BOOST_FOREACH(const PAIRTYPE(string, const CRPCCommand*)& command, vCommands)
 188     {
 189         const CRPCCommand *pcmd = command.second;
 190         string strMethod = pcmd->name;
 191         // We already filter duplicates, but these deprecated screw up the sort order
 192         if (strMethod.find("label") != string::npos)
 193             continue;
 194         if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
 195             continue;
 196         try
 197         {
 198             Array params;
 199             rpcfn_type pfn = pcmd->actor;
 200             if (setDone.insert(pfn).second)
 201                 (*pfn)(params, true);
 202         }
 203         catch (const std::exception& e)
 204         {
 205             // Help text is returned in an exception
 206             string strHelp = string(e.what());
 207             if (strCommand == "")
 208             {
 209                 if (strHelp.find('\n') != string::npos)
 210                     strHelp = strHelp.substr(0, strHelp.find('\n'));
 211
 212                 if (category != pcmd->category)
 213                 {
 214                     if (!category.empty())
 215                         strRet += "\n";
 216                     category = pcmd->category;
 217                     string firstLetter = category.substr(0,1);
 218                     boost::to_upper(firstLetter);
 219                     strRet += "== " + firstLetter + category.substr(1) + " ==\n";
 220                 }
 221             }
 222             strRet += strHelp + "\n";
 223         }
 224     }
 225     if (strRet == "")
 226         strRet = strprintf("help: unknown command: %s\n", strCommand);
 227     strRet = strRet.substr(0,strRet.size()-1);
 228     return strRet;
 229 }
 230
 231 Value help(const Array& params, bool fHelp)
 232 {
 233     if (fHelp || params.size() > 1)
 234         throw runtime_error(
 235             "help ( \"command\" )\n"
 236             "\nList all commands, or get help for a specified command.\n"
 237             "\nArguments:\n"
 238             "1. \"command\"     (string, optional) The command to get help on\n"
 239             "\nResult:\n"
 240             "\"text\"     (string) The help text\n"
 241         );
 242
 243     string strCommand;
 244     if (params.size() > 0)
 245         strCommand = params[0].get_str();
 246
 247     return tableRPC.help(strCommand);
 248 }
 249
 250
 251 Value stop(const Array& params, bool fHelp)
 252 {
 253     // Accept the deprecated and ignored 'detach' boolean argument
 254     if (fHelp || params.size() > 1)
 255         throw runtime_error(
 256             "stop\n"
 257             "\nStop Zcash server.");
 258     // Shutdown will take long enough that the response should get back
 259     StartShutdown();
 260     return "Zcash server stopping";
 261 }
 262
 263
 264
 265 /**
 266  * Call Table
 267  */
 268 static const CRPCCommand vRPCCommands[] =
 269 { //  category              name                      actor (function)         okSafeMode
 270   //  --------------------- ------------------------  -----------------------  ----------
 271     /* Overall control/query calls */
 272     { "control",            "getinfo",                &getinfo,                true  }, /* uses wallet if enabled */
 273     { "control",            "help",                   &help,                   true  },
 274     { "control",            "stop",                   &stop,                   true  },
 275
 276     /* P2P networking */
 277     { "network",            "getnetworkinfo",         &getnetworkinfo,         true  },
 278     { "network",            "addnode",                &addnode,                true  },
 279     { "network",            "getaddednodeinfo",       &getaddednodeinfo,       true  },
 280     { "network",            "getconnectioncount",     &getconnectioncount,     true  },
 281     { "network",            "getnettotals",           &getnettotals,           true  },
 282     { "network",            "getpeerinfo",            &getpeerinfo,            true  },
 283     { "network",            "ping",                   &ping,                   true  },
 284
 285     /* Block chain and UTXO */
 286     { "blockchain",         "getblockchaininfo",      &getblockchaininfo,      true  },
 287     { "blockchain",         "getbestblockhash",       &getbestblockhash,       true  },
 288     { "blockchain",         "getblockcount",          &getblockcount,          true  },
 289     { "blockchain",         "getblock",               &getblock,               true  },
 290     { "blockchain",         "getblockhash",           &getblockhash,           true  },
 291     { "blockchain",         "getchaintips",           &getchaintips,           true  },
 292     { "blockchain",         "getdifficulty",          &getdifficulty,          true  },
 293     { "blockchain",         "getmempoolinfo",         &getmempoolinfo,         true  },
 294     { "blockchain",         "getrawmempool",          &getrawmempool,          true  },
 295     { "blockchain",         "gettxout",               &gettxout,               true  },
 296     { "blockchain",         "gettxoutproof",          &gettxoutproof,          true  },
 297     { "blockchain",         "verifytxoutproof",       &verifytxoutproof,       true  },
 298     { "blockchain",         "gettxoutsetinfo",        &gettxoutsetinfo,        true  },
 299     { "blockchain",         "verifychain",            &verifychain,            true  },
 300
 301     /* Mining */
 302     { "mining",             "getblocktemplate",       &getblocktemplate,       true  },
 303     { "mining",             "getmininginfo",          &getmininginfo,          true  },
 304     { "mining",             "getnetworkhashps",       &getnetworkhashps,       true  },
 305     { "mining",             "prioritisetransaction",  &prioritisetransaction,  true  },
 306     { "mining",             "submitblock",            &submitblock,            true  },
 307     { "mining",             "getblocksubsidy",        &getblocksubsidy,        true  },
 308
 309 #ifdef ENABLE_WALLET
 310     /* Coin generation */
 311     { "generating",         "getgenerate",            &getgenerate,            true  },
 312     { "generating",         "setgenerate",            &setgenerate,            true  },
 313     { "generating",         "generate",               &generate,               true  },
 314 #endif
 315
 316     /* Raw transactions */
 317     { "rawtransactions",    "createrawtransaction",   &createrawtransaction,   true  },
 318     { "rawtransactions",    "decoderawtransaction",   &decoderawtransaction,   true  },
 319     { "rawtransactions",    "decodescript",           &decodescript,           true  },
 320     { "rawtransactions",    "getrawtransaction",      &getrawtransaction,      true  },
 321     { "rawtransactions",    "sendrawtransaction",     &sendrawtransaction,     false },
 322     { "rawtransactions",    "signrawtransaction",     &signrawtransaction,     false }, /* uses wallet if enabled */
 323
 324     /* Utility functions */
 325     { "util",               "createmultisig",         &createmultisig,         true  },
 326     { "util",               "validateaddress",        &validateaddress,        true  }, /* uses wallet if enabled */
 327     { "util",               "verifymessage",          &verifymessage,          true  },
 328     { "util",               "estimatefee",            &estimatefee,            true  },
 329     { "util",               "estimatepriority",       &estimatepriority,       true  },
 330
 331     /* Not shown in help */
 332     { "hidden",             "invalidateblock",        &invalidateblock,        true  },
 333     { "hidden",             "reconsiderblock",        &reconsiderblock,        true  },
 334     { "hidden",             "setmocktime",            &setmocktime,            true  },
 335 #ifdef ENABLE_WALLET
 336     { "hidden",             "resendwallettransactions", &resendwallettransactions, true},
 337 #endif
 338
 339 #ifdef ENABLE_WALLET
 340     /* Wallet */
 341     { "wallet",             "addmultisigaddress",     &addmultisigaddress,     true  },
 342     { "wallet",             "backupwallet",           &backupwallet,           true  },
 343     { "wallet",             "dumpprivkey",            &dumpprivkey,            true  },
 344     { "wallet",             "dumpwallet",             &dumpwallet,             true  },
 345     { "wallet",             "encryptwallet",          &encryptwallet,          true  },
 346     { "wallet",             "getaccountaddress",      &getaccountaddress,      true  },
 347     { "wallet",             "getaccount",             &getaccount,             true  },
 348     { "wallet",             "getaddressesbyaccount",  &getaddressesbyaccount,  true  },
 349     { "wallet",             "getbalance",             &getbalance,             false },
 350     { "wallet",             "getnewaddress",          &getnewaddress,          true  },
 351     { "wallet",             "getrawchangeaddress",    &getrawchangeaddress,    true  },
 352     { "wallet",             "getreceivedbyaccount",   &getreceivedbyaccount,   false },
 353     { "wallet",             "getreceivedbyaddress",   &getreceivedbyaddress,   false },
 354     { "wallet",             "gettransaction",         &gettransaction,         false },
 355     { "wallet",             "getunconfirmedbalance",  &getunconfirmedbalance,  false },
 356     { "wallet",             "getwalletinfo",          &getwalletinfo,          false },
 357     { "wallet",             "importprivkey",          &importprivkey,          true  },
 358     { "wallet",             "importwallet",           &importwallet,           true  },
 359     { "wallet",             "importaddress",          &importaddress,          true  },
 360     { "wallet",             "keypoolrefill",          &keypoolrefill,          true  },
 361     { "wallet",             "listaccounts",           &listaccounts,           false },
 362     { "wallet",             "listaddressgroupings",   &listaddressgroupings,   false },
 363     { "wallet",             "listlockunspent",        &listlockunspent,        false },
 364     { "wallet",             "listreceivedbyaccount",  &listreceivedbyaccount,  false },
 365     { "wallet",             "listreceivedbyaddress",  &listreceivedbyaddress,  false },
 366     { "wallet",             "listsinceblock",         &listsinceblock,         false },
 367     { "wallet",             "listtransactions",       &listtransactions,       false },
 368     { "wallet",             "listunspent",            &listunspent,            false },
 369     { "wallet",             "lockunspent",            &lockunspent,            true  },
 370     { "wallet",             "move",                   &movecmd,                false },
 371     { "wallet",             "sendfrom",               &sendfrom,               false },
 372     { "wallet",             "sendmany",               &sendmany,               false },
 373     { "wallet",             "sendtoaddress",          &sendtoaddress,          false },
 374     { "wallet",             "setaccount",             &setaccount,             true  },
 375     { "wallet",             "settxfee",               &settxfee,               true  },
 376     { "wallet",             "signmessage",            &signmessage,            true  },
 377     { "wallet",             "walletlock",             &walletlock,             true  },
 378     { "wallet",             "walletpassphrasechange", &walletpassphrasechange, true  },
 379     { "wallet",             "walletpassphrase",       &walletpassphrase,       true  },
 380     { "wallet",             "zcbenchmark",            &zc_benchmark,           true  },
 381     { "wallet",             "zcrawkeygen",            &zc_raw_keygen,          true  },
 382     { "wallet",             "zcrawjoinsplit",         &zc_raw_joinsplit,       true  },
 383     { "wallet",             "zcrawreceive",           &zc_raw_receive,         true  },
 384     { "wallet",             "zcsamplejoinsplit",      &zc_sample_joinsplit,    true  }
 385 #endif // ENABLE_WALLET
 386 };
 387
 388 CRPCTable::CRPCTable()
 389 {
 390     unsigned int vcidx;
 391     for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
 392     {
 393         const CRPCCommand *pcmd;
 394
 395         pcmd = &vRPCCommands[vcidx];
 396         mapCommands[pcmd->name] = pcmd;
 397     }
 398 }
 399
 400 const CRPCCommand *CRPCTable::operator[](string name) const
 401 {
 402     map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
 403     if (it == mapCommands.end())
 404         return NULL;
 405     return (*it).second;
 406 }
 407
 408
 409 bool HTTPAuthorized(map<string, string>& mapHeaders)
 410 {
 411     string strAuth = mapHeaders["authorization"];
 412     if (strAuth.substr(0,6) != "Basic ")
 413         return false;
 414     string strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
 415     string strUserPass = DecodeBase64(strUserPass64);
 416     return TimingResistantEqual(strUserPass, strRPCUserColonPass);
 417 }
 418
 419 void ErrorReply(std::ostream& stream, const Object& objError, const Value& id)
 420 {
 421     // Send error reply from json-rpc error object
 422     int nStatus = HTTP_INTERNAL_SERVER_ERROR;
 423     int code = find_value(objError, "code").get_int();
 424     if (code == RPC_INVALID_REQUEST) nStatus = HTTP_BAD_REQUEST;
 425     else if (code == RPC_METHOD_NOT_FOUND) nStatus = HTTP_NOT_FOUND;
 426     string strReply = JSONRPCReply(Value::null, objError, id);
 427     stream << HTTPReply(nStatus, strReply, false) << std::flush;
 428 }
 429
 430 CNetAddr BoostAsioToCNetAddr(boost::asio::ip::address address)
 431 {
 432     CNetAddr netaddr;
 433     // Make sure that IPv4-compatible and IPv4-mapped IPv6 addresses are treated as IPv4 addresses
 434     if (address.is_v6()
 435      && (address.to_v6().is_v4_compatible()
 436       || address.to_v6().is_v4_mapped()))
 437         address = address.to_v6().to_v4();
 438
 439     if(address.is_v4())
 440     {
 441         boost::asio::ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
 442         netaddr.SetRaw(NET_IPV4, &bytes[0]);
 443     }
 444     else
 445     {
 446         boost::asio::ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
 447         netaddr.SetRaw(NET_IPV6, &bytes[0]);
 448     }
 449     return netaddr;
 450 }
 451
 452 bool ClientAllowed(const boost::asio::ip::address& address)
 453 {
 454     CNetAddr netaddr = BoostAsioToCNetAddr(address);
 455     BOOST_FOREACH(const CSubNet &subnet, rpc_allow_subnets)
 456         if (subnet.Match(netaddr))
 457             return true;
 458     return false;
 459 }
 460
 461 template <typename Protocol>
 462 class AcceptedConnectionImpl : public AcceptedConnection
 463 {
 464 public:
 465     AcceptedConnectionImpl(
 466             boost::asio::io_service& io_service,
 467             ssl::context &context,
 468             bool fUseSSL) :
 469         sslStream(io_service, context),
 470         _d(sslStream, fUseSSL),
 471         _stream(_d)
 472     {
 473     }
 474
 475     virtual std::iostream& stream()
 476     {
 477         return _stream;
 478     }
 479
 480     virtual std::string peer_address_to_string() const
 481     {
 482         return peer.address().to_string();
 483     }
 484
 485     virtual void close()
 486     {
 487         _stream.close();
 488     }
 489
 490     typename Protocol::endpoint peer;
 491     boost::asio::ssl::stream<typename Protocol::socket> sslStream;
 492
 493 private:
 494     SSLIOStreamDevice<Protocol> _d;
 495     boost::iostreams::stream< SSLIOStreamDevice<Protocol> > _stream;
 496 };
 497
 498 void ServiceConnection(AcceptedConnection *conn);
 499
 500 //! Forward declaration required for RPCListen
 501 template <typename Protocol, typename SocketAcceptorService>
 502 static void RPCAcceptHandler(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
 503                              ssl::context& context,
 504                              bool fUseSSL,
 505                              boost::shared_ptr< AcceptedConnection > conn,
 506                              const boost::system::error_code& error);
 507
 508 /**
 509  * Sets up I/O resources to accept and handle a new connection.
 510  */
 511 template <typename Protocol, typename SocketAcceptorService>
 512 static void RPCListen(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
 513                    ssl::context& context,
 514                    const bool fUseSSL)
 515 {
 516     // Accept connection
 517     boost::shared_ptr< AcceptedConnectionImpl<Protocol> > conn(new AcceptedConnectionImpl<Protocol>(acceptor->get_io_service(), context, fUseSSL));
 518
 519     acceptor->async_accept(
 520             conn->sslStream.lowest_layer(),
 521             conn->peer,
 522             boost::bind(&RPCAcceptHandler<Protocol, SocketAcceptorService>,
 523                 acceptor,
 524                 boost::ref(context),
 525                 fUseSSL,
 526                 conn,
 527                 _1));
 528 }
 529
 530
 531 /**
 532  * Accept and handle incoming connection.
 533  */
 534 template <typename Protocol, typename SocketAcceptorService>
 535 static void RPCAcceptHandler(boost::shared_ptr< basic_socket_acceptor<Protocol, SocketAcceptorService> > acceptor,
 536                              ssl::context& context,
 537                              const bool fUseSSL,
 538                              boost::shared_ptr< AcceptedConnection > conn,
 539                              const boost::system::error_code& error)
 540 {
 541     // Immediately start accepting new connections, except when we're cancelled or our socket is closed.
 542     if (error != boost::asio::error::operation_aborted && acceptor->is_open())
 543         RPCListen(acceptor, context, fUseSSL);
 544
 545     AcceptedConnectionImpl<ip::tcp>* tcp_conn = dynamic_cast< AcceptedConnectionImpl<ip::tcp>* >(conn.get());
 546
 547     if (error)
 548     {
 549         // TODO: Actually handle errors
 550         LogPrintf("%s: Error: %s\n", __func__, error.message());
 551     }
 552     // Restrict callers by IP.  It is important to
 553     // do this before starting client thread, to filter out
 554     // certain DoS and misbehaving clients.
 555     else if (tcp_conn && !ClientAllowed(tcp_conn->peer.address()))
 556     {
 557         // Only send a 403 if we're not using SSL to prevent a DoS during the SSL handshake.
 558         if (!fUseSSL)
 559             conn->stream() << HTTPError(HTTP_FORBIDDEN, false) << std::flush;
 560         conn->close();
 561     }
 562     else {
 563         ServiceConnection(conn.get());
 564         conn->close();
 565     }
 566 }
 567
 568 static ip::tcp::endpoint ParseEndpoint(const std::string &strEndpoint, int defaultPort)
 569 {
 570     std::string addr;
 571     int port = defaultPort;
 572     SplitHostPort(strEndpoint, port, addr);
 573     return ip::tcp::endpoint(boost::asio::ip::address::from_string(addr), port);
 574 }
 575
 576 void StartRPCThreads()
 577 {
 578     rpc_allow_subnets.clear();
 579     rpc_allow_subnets.push_back(CSubNet("127.0.0.0/8")); // always allow IPv4 local subnet
 580     rpc_allow_subnets.push_back(CSubNet("::1")); // always allow IPv6 localhost
 581     if (mapMultiArgs.count("-rpcallowip"))
 582     {
 583         const vector<string>& vAllow = mapMultiArgs["-rpcallowip"];
 584         BOOST_FOREACH(string strAllow, vAllow)
 585         {
 586             CSubNet subnet(strAllow);
 587             if(!subnet.IsValid())
 588             {
 589                 uiInterface.ThreadSafeMessageBox(
 590                     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),
 591                     "", CClientUIInterface::MSG_ERROR);
 592                 StartShutdown();
 593                 return;
 594             }
 595             rpc_allow_subnets.push_back(subnet);
 596         }
 597     }
 598     std::string strAllowed;
 599     BOOST_FOREACH(const CSubNet &subnet, rpc_allow_subnets)
 600         strAllowed += subnet.ToString() + " ";
 601     LogPrint("rpc", "Allowing RPC connections from: %s\n", strAllowed);
 602
 603     strRPCUserColonPass = mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"];
 604     if (((mapArgs["-rpcpassword"] == "") ||
 605          (mapArgs["-rpcuser"] == mapArgs["-rpcpassword"])) && Params().RequireRPCPassword())
 606     {
 607         unsigned char rand_pwd[32];
 608         GetRandBytes(rand_pwd, 32);
 609         uiInterface.ThreadSafeMessageBox(strprintf(
 610             _("To use bitcoind, or the -server option to bitcoin-qt, you must set an rpcpassword in the configuration file:\n"
 611               "%s\n"
 612               "It is recommended you use the following random password:\n"
 613               "rpcuser=bitcoinrpc\n"
 614               "rpcpassword=%s\n"
 615               "(you do not need to remember this password)\n"
 616               "The username and password MUST NOT be the same.\n"
 617               "If the file does not exist, create it with owner-readable-only file permissions.\n"
 618               "It is also recommended to set alertnotify so you are notified of problems;\n"
 619               "for example: alertnotify=echo %%s | mail -s \"Bitcoin Alert\" [email protected]\n"),
 620                 GetConfigFile().string(),
 621                 EncodeBase58(&rand_pwd[0],&rand_pwd[0]+32)),
 622                 "", CClientUIInterface::MSG_ERROR | CClientUIInterface::SECURE);
 623         StartShutdown();
 624         return;
 625     }
 626
 627     assert(rpc_io_service == NULL);
 628     rpc_io_service = new boost::asio::io_service();
 629     rpc_ssl_context = new ssl::context(*rpc_io_service, ssl::context::sslv23);
 630
 631     const bool fUseSSL = GetBoolArg("-rpcssl", false);
 632
 633     if (fUseSSL)
 634     {
 635         rpc_ssl_context->set_options(ssl::context::no_sslv2 | ssl::context::no_sslv3);
 636
 637         boost::filesystem::path pathCertFile(GetArg("-rpcsslcertificatechainfile", "server.cert"));
 638         if (!pathCertFile.is_complete()) pathCertFile = boost::filesystem::path(GetDataDir()) / pathCertFile;
 639         if (boost::filesystem::exists(pathCertFile)) rpc_ssl_context->use_certificate_chain_file(pathCertFile.string());
 640         else LogPrintf("ThreadRPCServer ERROR: missing server certificate file %s\n", pathCertFile.string());
 641
 642         boost::filesystem::path pathPKFile(GetArg("-rpcsslprivatekeyfile", "server.pem"));
 643         if (!pathPKFile.is_complete()) pathPKFile = boost::filesystem::path(GetDataDir()) / pathPKFile;
 644         if (boost::filesystem::exists(pathPKFile)) rpc_ssl_context->use_private_key_file(pathPKFile.string(), ssl::context::pem);
 645         else LogPrintf("ThreadRPCServer ERROR: missing server private key file %s\n", pathPKFile.string());
 646
 647         string strCiphers = GetArg("-rpcsslciphers", "TLSv1.2+HIGH:TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!3DES:@STRENGTH");
 648         SSL_CTX_set_cipher_list(rpc_ssl_context->impl(), strCiphers.c_str());
 649     }
 650
 651     std::vector<ip::tcp::endpoint> vEndpoints;
 652     bool bBindAny = false;
 653     int defaultPort = GetArg("-rpcport", BaseParams().RPCPort());
 654     if (!mapArgs.count("-rpcallowip")) // Default to loopback if not allowing external IPs
 655     {
 656         vEndpoints.push_back(ip::tcp::endpoint(boost::asio::ip::address_v6::loopback(), defaultPort));
 657         vEndpoints.push_back(ip::tcp::endpoint(boost::asio::ip::address_v4::loopback(), defaultPort));
 658         if (mapArgs.count("-rpcbind"))
 659         {
 660             LogPrintf("WARNING: option -rpcbind was ignored because -rpcallowip was not specified, refusing to allow everyone to connect\n");
 661         }
 662     } else if (mapArgs.count("-rpcbind")) // Specific bind address
 663     {
 664         BOOST_FOREACH(const std::string &addr, mapMultiArgs["-rpcbind"])
 665         {
 666             try {
 667                 vEndpoints.push_back(ParseEndpoint(addr, defaultPort));
 668             }
 669             catch (const boost::system::system_error&)
 670             {
 671                 uiInterface.ThreadSafeMessageBox(
 672                     strprintf(_("Could not parse -rpcbind value %s as network address"), addr),
 673                     "", CClientUIInterface::MSG_ERROR);
 674                 StartShutdown();
 675                 return;
 676             }
 677         }
 678     } else { // No specific bind address specified, bind to any
 679         vEndpoints.push_back(ip::tcp::endpoint(boost::asio::ip::address_v6::any(), defaultPort));
 680         vEndpoints.push_back(ip::tcp::endpoint(boost::asio::ip::address_v4::any(), defaultPort));
 681         // Prefer making the socket dual IPv6/IPv4 instead of binding
 682         // to both addresses separately.
 683         bBindAny = true;
 684     }
 685
 686     bool fListening = false;
 687     std::string strerr;
 688     std::string straddress;
 689     BOOST_FOREACH(const ip::tcp::endpoint &endpoint, vEndpoints)
 690     {
 691         try {
 692             boost::asio::ip::address bindAddress = endpoint.address();
 693             straddress = bindAddress.to_string();
 694             LogPrintf("Binding RPC on address %s port %i (IPv4+IPv6 bind any: %i)\n", straddress, endpoint.port(), bBindAny);
 695             boost::system::error_code v6_only_error;
 696             boost::shared_ptr<ip::tcp::acceptor> acceptor(new ip::tcp::acceptor(*rpc_io_service));
 697
 698             acceptor->open(endpoint.protocol());
 699             acceptor->set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
 700
 701             // Try making the socket dual IPv6/IPv4 when listening on the IPv6 "any" address
 702             acceptor->set_option(boost::asio::ip::v6_only(
 703                 !bBindAny || bindAddress != boost::asio::ip::address_v6::any()), v6_only_error);
 704
 705             acceptor->bind(endpoint);
 706             acceptor->listen(socket_base::max_connections);
 707
 708             RPCListen(acceptor, *rpc_ssl_context, fUseSSL);
 709
 710             fListening = true;
 711             rpc_acceptors.push_back(acceptor);
 712             // If dual IPv6/IPv4 bind successful, skip binding to IPv4 separately
 713             if(bBindAny && bindAddress == boost::asio::ip::address_v6::any() && !v6_only_error)
 714                 break;
 715         }
 716         catch (const boost::system::system_error& e)
 717         {
 718             LogPrintf("ERROR: Binding RPC on address %s port %i failed: %s\n", straddress, endpoint.port(), e.what());
 719             strerr = strprintf(_("An error occurred while setting up the RPC address %s port %u for listening: %s"), straddress, endpoint.port(), e.what());
 720         }
 721     }
 722
 723     if (!fListening) {
 724         uiInterface.ThreadSafeMessageBox(strerr, "", CClientUIInterface::MSG_ERROR);
 725         StartShutdown();
 726         return;
 727     }
 728
 729     rpc_worker_group = new boost::thread_group();
 730     for (int i = 0; i < GetArg("-rpcthreads", 4); i++)
 731         rpc_worker_group->create_thread(boost::bind(&boost::asio::io_service::run, rpc_io_service));
 732     fRPCRunning = true;
 733     g_rpcSignals.Started();
 734 }
 735
 736 void StartDummyRPCThread()
 737 {
 738     if(rpc_io_service == NULL)
 739     {
 740         rpc_io_service = new boost::asio::io_service();
 741         /* Create dummy "work" to keep the thread from exiting when no timeouts active,
 742          * 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 */
 743         rpc_dummy_work = new boost::asio::io_service::work(*rpc_io_service);
 744         rpc_worker_group = new boost::thread_group();
 745         rpc_worker_group->create_thread(boost::bind(&boost::asio::io_service::run, rpc_io_service));
 746         fRPCRunning = true;
 747     }
 748 }
 749
 750 void StopRPCThreads()
 751 {
 752     if (rpc_io_service == NULL) return;
 753     // Set this to false first, so that longpolling loops will exit when woken up
 754     fRPCRunning = false;
 755
 756     // First, cancel all timers and acceptors
 757     // This is not done automatically by ->stop(), and in some cases the destructor of
 758     // boost::asio::io_service can hang if this is skipped.
 759     boost::system::error_code ec;
 760     BOOST_FOREACH(const boost::shared_ptr<ip::tcp::acceptor> &acceptor, rpc_acceptors)
 761     {
 762         acceptor->cancel(ec);
 763         if (ec)
 764             LogPrintf("%s: Warning: %s when cancelling acceptor\n", __func__, ec.message());
 765     }
 766     rpc_acceptors.clear();
 767     BOOST_FOREACH(const PAIRTYPE(std::string, boost::shared_ptr<deadline_timer>) &timer, deadlineTimers)
 768     {
 769         timer.second->cancel(ec);
 770         if (ec)
 771             LogPrintf("%s: Warning: %s when cancelling timer\n", __func__, ec.message());
 772     }
 773     deadlineTimers.clear();
 774
 775     rpc_io_service->stop();
 776     g_rpcSignals.Stopped();
 777     if (rpc_worker_group != NULL)
 778         rpc_worker_group->join_all();
 779     delete rpc_dummy_work; rpc_dummy_work = NULL;
 780     delete rpc_worker_group; rpc_worker_group = NULL;
 781     delete rpc_ssl_context; rpc_ssl_context = NULL;
 782     delete rpc_io_service; rpc_io_service = NULL;
 783 }
 784
 785 bool IsRPCRunning()
 786 {
 787     return fRPCRunning;
 788 }
 789
 790 void SetRPCWarmupStatus(const std::string& newStatus)
 791 {
 792     LOCK(cs_rpcWarmup);
 793     rpcWarmupStatus = newStatus;
 794 }
 795
 796 void SetRPCWarmupFinished()
 797 {
 798     LOCK(cs_rpcWarmup);
 799     assert(fRPCInWarmup);
 800     fRPCInWarmup = false;
 801 }
 802
 803 bool RPCIsInWarmup(std::string *outStatus)
 804 {
 805     LOCK(cs_rpcWarmup);
 806     if (outStatus)
 807         *outStatus = rpcWarmupStatus;
 808     return fRPCInWarmup;
 809 }
 810
 811 void RPCRunHandler(const boost::system::error_code& err, boost::function<void(void)> func)
 812 {
 813     if (!err)
 814         func();
 815 }
 816
 817 void RPCRunLater(const std::string& name, boost::function<void(void)> func, int64_t nSeconds)
 818 {
 819     assert(rpc_io_service != NULL);
 820
 821     if (deadlineTimers.count(name) == 0)
 822     {
 823         deadlineTimers.insert(make_pair(name,
 824                                         boost::shared_ptr<deadline_timer>(new deadline_timer(*rpc_io_service))));
 825     }
 826     deadlineTimers[name]->expires_from_now(boost::posix_time::seconds(nSeconds));
 827     deadlineTimers[name]->async_wait(boost::bind(RPCRunHandler, _1, func));
 828 }
 829
 830 class JSONRequest
 831 {
 832 public:
 833     Value id;
 834     string strMethod;
 835     Array params;
 836
 837     JSONRequest() { id = Value::null; }
 838     void parse(const Value& valRequest);
 839 };
 840
 841 void JSONRequest::parse(const Value& valRequest)
 842 {
 843     // Parse request
 844     if (valRequest.type() != obj_type)
 845         throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
 846     const Object& request = valRequest.get_obj();
 847
 848     // Parse id now so errors from here on will have the id
 849     id = find_value(request, "id");
 850
 851     // Parse method
 852     Value valMethod = find_value(request, "method");
 853     if (valMethod.type() == null_type)
 854         throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
 855     if (valMethod.type() != str_type)
 856         throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
 857     strMethod = valMethod.get_str();
 858     if (strMethod != "getblocktemplate")
 859         LogPrint("rpc", "ThreadRPCServer method=%s\n", SanitizeString(strMethod));
 860
 861     // Parse params
 862     Value valParams = find_value(request, "params");
 863     if (valParams.type() == array_type)
 864         params = valParams.get_array();
 865     else if (valParams.type() == null_type)
 866         params = Array();
 867     else
 868         throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array");
 869 }
 870
 871
 872 static Object JSONRPCExecOne(const Value& req)
 873 {
 874     Object rpc_result;
 875
 876     JSONRequest jreq;
 877     try {
 878         jreq.parse(req);
 879
 880         Value result = tableRPC.execute(jreq.strMethod, jreq.params);
 881         rpc_result = JSONRPCReplyObj(result, Value::null, jreq.id);
 882     }
 883     catch (const Object& objError)
 884     {
 885         rpc_result = JSONRPCReplyObj(Value::null, objError, jreq.id);
 886     }
 887     catch (const std::exception& e)
 888     {
 889         rpc_result = JSONRPCReplyObj(Value::null,
 890                                      JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
 891     }
 892
 893     return rpc_result;
 894 }
 895
 896 static string JSONRPCExecBatch(const Array& vReq)
 897 {
 898     Array ret;
 899     for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
 900         ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
 901
 902     return write_string(Value(ret), false) + "\n";
 903 }
 904
 905 static bool HTTPReq_JSONRPC(AcceptedConnection *conn,
 906                             string& strRequest,
 907                             map<string, string>& mapHeaders,
 908                             bool fRun)
 909 {
 910     // Check authorization
 911     if (mapHeaders.count("authorization") == 0)
 912     {
 913         conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
 914         return false;
 915     }
 916
 917     if (!HTTPAuthorized(mapHeaders))
 918     {
 919         LogPrintf("ThreadRPCServer incorrect password attempt from %s\n", conn->peer_address_to_string());
 920         /* Deter brute-forcing
 921            We don't support exposing the RPC port, so this shouldn't result
 922            in a DoS. */
 923         MilliSleep(250);
 924
 925         conn->stream() << HTTPError(HTTP_UNAUTHORIZED, false) << std::flush;
 926         return false;
 927     }
 928
 929     JSONRequest jreq;
 930     try
 931     {
 932         // Parse request
 933         Value valRequest;
 934         if (!read_string(strRequest, valRequest))
 935             throw JSONRPCError(RPC_PARSE_ERROR, "Parse error");
 936
 937         // Return immediately if in warmup
 938         {
 939             LOCK(cs_rpcWarmup);
 940             if (fRPCInWarmup)
 941                 throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
 942         }
 943
 944         string strReply;
 945
 946         // singleton request
 947         if (valRequest.type() == obj_type) {
 948             jreq.parse(valRequest);
 949
 950             Value result = tableRPC.execute(jreq.strMethod, jreq.params);
 951
 952             // Send reply
 953             strReply = JSONRPCReply(result, Value::null, jreq.id);
 954
 955         // array of requests
 956         } else if (valRequest.type() == array_type)
 957             strReply = JSONRPCExecBatch(valRequest.get_array());
 958         else
 959             throw JSONRPCError(RPC_PARSE_ERROR, "Top-level object parse error");
 960
 961         conn->stream() << HTTPReplyHeader(HTTP_OK, fRun, strReply.size()) << strReply << std::flush;
 962     }
 963     catch (const Object& objError)
 964     {
 965         ErrorReply(conn->stream(), objError, jreq.id);
 966         return false;
 967     }
 968     catch (const std::exception& e)
 969     {
 970         ErrorReply(conn->stream(), JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
 971         return false;
 972     }
 973     return true;
 974 }
 975
 976 void ServiceConnection(AcceptedConnection *conn)
 977 {
 978     bool fRun = true;
 979     while (fRun && !ShutdownRequested())
 980     {
 981         int nProto = 0;
 982         map<string, string> mapHeaders;
 983         string strRequest, strMethod, strURI;
 984
 985         // Read HTTP request line
 986         if (!ReadHTTPRequestLine(conn->stream(), nProto, strMethod, strURI))
 987             break;
 988
 989         // Read HTTP message headers and body
 990         ReadHTTPMessage(conn->stream(), mapHeaders, strRequest, nProto, MAX_SIZE);
 991
 992         // HTTP Keep-Alive is false; close connection immediately
 993         if ((mapHeaders["connection"] == "close") || (!GetBoolArg("-rpckeepalive", true)))
 994             fRun = false;
 995
 996         // Process via JSON-RPC API
 997         if (strURI == "/") {
 998             if (!HTTPReq_JSONRPC(conn, strRequest, mapHeaders, fRun))
 999                 break;
1000
1001         // Process via HTTP REST API
1002         } else if (strURI.substr(0, 6) == "/rest/" && GetBoolArg("-rest", false)) {
1003             if (!HTTPReq_REST(conn, strURI, strRequest, mapHeaders, fRun))
1004                 break;
1005
1006         } else {
1007             conn->stream() << HTTPError(HTTP_NOT_FOUND, false) << std::flush;
1008             break;
1009         }
1010     }
1011 }
1012
1013 json_spirit::Value CRPCTable::execute(const std::string &strMethod, const json_spirit::Array &params) const
1014 {
1015     // Find method
1016     const CRPCCommand *pcmd = tableRPC[strMethod];
1017     if (!pcmd)
1018         throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
1019
1020     g_rpcSignals.PreCommand(*pcmd);
1021
1022     try
1023     {
1024         // Execute
1025         return pcmd->actor(params, false);
1026     }
1027     catch (const std::exception& e)
1028     {
1029         throw JSONRPCError(RPC_MISC_ERROR, e.what());
1030     }
1031
1032     g_rpcSignals.PostCommand(*pcmd);
1033 }
1034
1035 std::string HelpExampleCli(string methodname, string args){
1036     return "> bitcoin-cli " + methodname + " " + args + "\n";
1037 }
1038
1039 std::string HelpExampleRpc(string methodname, string args){
1040     return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
1041         "\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:8232/\n";
1042 }
1043
1044 const CRPCTable tableRPC;