src/rpc/server.cpp

   1 // Copyright (c) 2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 "rpc/server.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
  16 #include <univalue.h>
  17
  18 #include <boost/bind.hpp>
  19 #include <boost/filesystem.hpp>
  20 #include <boost/foreach.hpp>
  21 #include <boost/iostreams/concepts.hpp>
  22 #include <boost/iostreams/stream.hpp>
  23 #include <boost/shared_ptr.hpp>
  24 #include <boost/signals2/signal.hpp>
  25 #include <boost/thread.hpp>
  26 #include <boost/algorithm/string/case_conv.hpp> // for to_upper()
  27
  28 #include <memory> // for unique_ptr
  29 #include <unordered_map>
  30
  31 using namespace RPCServer;
  32 using namespace std;
  33
  34 static bool fRPCRunning = false;
  35 static bool fRPCInWarmup = true;
  36 static std::string rpcWarmupStatus("RPC server started");
  37 static CCriticalSection cs_rpcWarmup;
  38 /* Timer-creating functions */
  39 static RPCTimerInterface* timerInterface = NULL;
  40 /* Map of name to timer. */
  41 static std::map<std::string, std::unique_ptr<RPCTimerBase> > deadlineTimers;
  42
  43 static struct CRPCSignals
  44 {
  45     boost::signals2::signal<void ()> Started;
  46     boost::signals2::signal<void ()> Stopped;
  47     boost::signals2::signal<void (const CRPCCommand&)> PreCommand;
  48 } g_rpcSignals;
  49
  50 void RPCServer::OnStarted(boost::function<void ()> slot)
  51 {
  52     g_rpcSignals.Started.connect(slot);
  53 }
  54
  55 void RPCServer::OnStopped(boost::function<void ()> slot)
  56 {
  57     g_rpcSignals.Stopped.connect(slot);
  58 }
  59
  60 void RPCServer::OnPreCommand(boost::function<void (const CRPCCommand&)> slot)
  61 {
  62     g_rpcSignals.PreCommand.connect(boost::bind(slot, _1));
  63 }
  64
  65 void RPCTypeCheck(const UniValue& params,
  66                   const list<UniValue::VType>& typesExpected,
  67                   bool fAllowNull)
  68 {
  69     unsigned int i = 0;
  70     BOOST_FOREACH(UniValue::VType t, typesExpected)
  71     {
  72         if (params.size() <= i)
  73             break;
  74
  75         const UniValue& v = params[i];
  76         if (!((v.type() == t) || (fAllowNull && (v.isNull()))))
  77         {
  78             string err = strprintf("Expected type %s, got %s",
  79                                    uvTypeName(t), uvTypeName(v.type()));
  80             throw JSONRPCError(RPC_TYPE_ERROR, err);
  81         }
  82         i++;
  83     }
  84 }
  85
  86 void RPCTypeCheckObj(const UniValue& o,
  87     const map<string, UniValueType>& typesExpected,
  88     bool fAllowNull,
  89     bool fStrict)
  90 {
  91     for (const auto& t : typesExpected) {
  92         const UniValue& v = find_value(o, t.first);
  93         if (!fAllowNull && v.isNull())
  94             throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));
  95
  96         if (!(t.second.typeAny || v.type() == t.second.type || (fAllowNull && v.isNull()))) {
  97             string err = strprintf("Expected type %s for %s, got %s",
  98                 uvTypeName(t.second.type), t.first, uvTypeName(v.type()));
  99             throw JSONRPCError(RPC_TYPE_ERROR, err);
 100         }
 101     }
 102
 103     if (fStrict)
 104     {
 105         BOOST_FOREACH(const string& k, o.getKeys())
 106         {
 107             if (typesExpected.count(k) == 0)
 108             {
 109                 string err = strprintf("Unexpected key %s", k);
 110                 throw JSONRPCError(RPC_TYPE_ERROR, err);
 111             }
 112         }
 113     }
 114 }
 115
 116 CAmount AmountFromValue(const UniValue& value)
 117 {
 118     if (!value.isNum() && !value.isStr())
 119         throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
 120     CAmount amount;
 121     if (!ParseFixedPoint(value.getValStr(), 8, &amount))
 122         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
 123     if (!MoneyRange(amount))
 124         throw JSONRPCError(RPC_TYPE_ERROR, "Amount out of range");
 125     return amount;
 126 }
 127
 128 UniValue ValueFromAmount(const CAmount& amount)
 129 {
 130     bool sign = amount < 0;
 131     int64_t n_abs = (sign ? -amount : amount);
 132     int64_t quotient = n_abs / COIN;
 133     int64_t remainder = n_abs % COIN;
 134     return UniValue(UniValue::VNUM,
 135             strprintf("%s%d.%08d", sign ? "-" : "", quotient, remainder));
 136 }
 137
 138 uint256 ParseHashV(const UniValue& v, string strName)
 139 {
 140     string strHex;
 141     if (v.isStr())
 142         strHex = v.get_str();
 143     if (!IsHex(strHex)) // Note: IsHex("") is false
 144         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
 145     if (64 != strHex.length())
 146         throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d)", strName, 64, strHex.length()));
 147     uint256 result;
 148     result.SetHex(strHex);
 149     return result;
 150 }
 151 uint256 ParseHashO(const UniValue& o, string strKey)
 152 {
 153     return ParseHashV(find_value(o, strKey), strKey);
 154 }
 155 vector<unsigned char> ParseHexV(const UniValue& v, string strName)
 156 {
 157     string strHex;
 158     if (v.isStr())
 159         strHex = v.get_str();
 160     if (!IsHex(strHex))
 161         throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
 162     return ParseHex(strHex);
 163 }
 164 vector<unsigned char> ParseHexO(const UniValue& o, string strKey)
 165 {
 166     return ParseHexV(find_value(o, strKey), strKey);
 167 }
 168
 169 /**
 170  * Note: This interface may still be subject to change.
 171  */
 172
 173 std::string CRPCTable::help(const std::string& strCommand) const
 174 {
 175     string strRet;
 176     string category;
 177     set<rpcfn_type> setDone;
 178     vector<pair<string, const CRPCCommand*> > vCommands;
 179
 180     for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
 181         vCommands.push_back(make_pair(mi->second->category + mi->first, mi->second));
 182     sort(vCommands.begin(), vCommands.end());
 183
 184     BOOST_FOREACH(const PAIRTYPE(string, const CRPCCommand*)& command, vCommands)
 185     {
 186         const CRPCCommand *pcmd = command.second;
 187         string strMethod = pcmd->name;
 188         // We already filter duplicates, but these deprecated screw up the sort order
 189         if (strMethod.find("label") != string::npos)
 190             continue;
 191         if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
 192             continue;
 193         try
 194         {
 195             JSONRPCRequest jreq;
 196             jreq.fHelp = true;
 197             rpcfn_type pfn = pcmd->actor;
 198             if (setDone.insert(pfn).second)
 199                 (*pfn)(jreq);
 200         }
 201         catch (const std::exception& e)
 202         {
 203             // Help text is returned in an exception
 204             string strHelp = string(e.what());
 205             if (strCommand == "")
 206             {
 207                 if (strHelp.find('\n') != string::npos)
 208                     strHelp = strHelp.substr(0, strHelp.find('\n'));
 209
 210                 if (category != pcmd->category)
 211                 {
 212                     if (!category.empty())
 213                         strRet += "\n";
 214                     category = pcmd->category;
 215                     string firstLetter = category.substr(0,1);
 216                     boost::to_upper(firstLetter);
 217                     strRet += "== " + firstLetter + category.substr(1) + " ==\n";
 218                 }
 219             }
 220             strRet += strHelp + "\n";
 221         }
 222     }
 223     if (strRet == "")
 224         strRet = strprintf("help: unknown command: %s\n", strCommand);
 225     strRet = strRet.substr(0,strRet.size()-1);
 226     return strRet;
 227 }
 228
 229 UniValue help(const JSONRPCRequest& jsonRequest)
 230 {
 231     if (jsonRequest.fHelp || jsonRequest.params.size() > 1)
 232         throw runtime_error(
 233             "help ( \"command\" )\n"
 234             "\nList all commands, or get help for a specified command.\n"
 235             "\nArguments:\n"
 236             "1. \"command\"     (string, optional) The command to get help on\n"
 237             "\nResult:\n"
 238             "\"text\"     (string) The help text\n"
 239         );
 240
 241     string strCommand;
 242     if (jsonRequest.params.size() > 0)
 243         strCommand = jsonRequest.params[0].get_str();
 244
 245     return tableRPC.help(strCommand);
 246 }
 247
 248
 249 UniValue stop(const JSONRPCRequest& jsonRequest)
 250 {
 251     // Accept the deprecated and ignored 'detach' boolean argument
 252     if (jsonRequest.fHelp || jsonRequest.params.size() > 1)
 253         throw runtime_error(
 254             "stop\n"
 255             "\nStop Bitcoin server.");
 256     // Event loop will exit after current HTTP requests have been handled, so
 257     // this reply will get back to the client.
 258     StartShutdown();
 259     return "Bitcoin server stopping";
 260 }
 261
 262 /**
 263  * Call Table
 264  */
 265 static const CRPCCommand vRPCCommands[] =
 266 { //  category              name                      actor (function)         okSafe argNames
 267   //  --------------------- ------------------------  -----------------------  ------ ----------
 268     /* Overall control/query calls */
 269     { "control",            "help",                   &help,                   true,  {"command"}  },
 270     { "control",            "stop",                   &stop,                   true,  {}  },
 271 };
 272
 273 CRPCTable::CRPCTable()
 274 {
 275     unsigned int vcidx;
 276     for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
 277     {
 278         const CRPCCommand *pcmd;
 279
 280         pcmd = &vRPCCommands[vcidx];
 281         mapCommands[pcmd->name] = pcmd;
 282     }
 283 }
 284
 285 const CRPCCommand *CRPCTable::operator[](const std::string &name) const
 286 {
 287     map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
 288     if (it == mapCommands.end())
 289         return NULL;
 290     return (*it).second;
 291 }
 292
 293 bool CRPCTable::appendCommand(const std::string& name, const CRPCCommand* pcmd)
 294 {
 295     if (IsRPCRunning())
 296         return false;
 297
 298     // don't allow overwriting for now
 299     map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
 300     if (it != mapCommands.end())
 301         return false;
 302
 303     mapCommands[name] = pcmd;
 304     return true;
 305 }
 306
 307 bool StartRPC()
 308 {
 309     LogPrint("rpc", "Starting RPC\n");
 310     fRPCRunning = true;
 311     g_rpcSignals.Started();
 312     return true;
 313 }
 314
 315 void InterruptRPC()
 316 {
 317     LogPrint("rpc", "Interrupting RPC\n");
 318     // Interrupt e.g. running longpolls
 319     fRPCRunning = false;
 320 }
 321
 322 void StopRPC()
 323 {
 324     LogPrint("rpc", "Stopping RPC\n");
 325     deadlineTimers.clear();
 326     g_rpcSignals.Stopped();
 327 }
 328
 329 bool IsRPCRunning()
 330 {
 331     return fRPCRunning;
 332 }
 333
 334 void SetRPCWarmupStatus(const std::string& newStatus)
 335 {
 336     LOCK(cs_rpcWarmup);
 337     rpcWarmupStatus = newStatus;
 338 }
 339
 340 void SetRPCWarmupFinished()
 341 {
 342     LOCK(cs_rpcWarmup);
 343     assert(fRPCInWarmup);
 344     fRPCInWarmup = false;
 345 }
 346
 347 bool RPCIsInWarmup(std::string *outStatus)
 348 {
 349     LOCK(cs_rpcWarmup);
 350     if (outStatus)
 351         *outStatus = rpcWarmupStatus;
 352     return fRPCInWarmup;
 353 }
 354
 355 void JSONRPCRequest::parse(const UniValue& valRequest)
 356 {
 357     // Parse request
 358     if (!valRequest.isObject())
 359         throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
 360     const UniValue& request = valRequest.get_obj();
 361
 362     // Parse id now so errors from here on will have the id
 363     id = find_value(request, "id");
 364
 365     // Parse method
 366     UniValue valMethod = find_value(request, "method");
 367     if (valMethod.isNull())
 368         throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
 369     if (!valMethod.isStr())
 370         throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
 371     strMethod = valMethod.get_str();
 372     if (strMethod != "getblocktemplate")
 373         LogPrint("rpc", "ThreadRPCServer method=%s\n", SanitizeString(strMethod));
 374
 375     // Parse params
 376     UniValue valParams = find_value(request, "params");
 377     if (valParams.isArray() || valParams.isObject())
 378         params = valParams;
 379     else if (valParams.isNull())
 380         params = UniValue(UniValue::VARR);
 381     else
 382         throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array or object");
 383 }
 384
 385 static UniValue JSONRPCExecOne(const UniValue& req)
 386 {
 387     UniValue rpc_result(UniValue::VOBJ);
 388
 389     JSONRPCRequest jreq;
 390     try {
 391         jreq.parse(req);
 392
 393         UniValue result = tableRPC.execute(jreq);
 394         rpc_result = JSONRPCReplyObj(result, NullUniValue, jreq.id);
 395     }
 396     catch (const UniValue& objError)
 397     {
 398         rpc_result = JSONRPCReplyObj(NullUniValue, objError, jreq.id);
 399     }
 400     catch (const std::exception& e)
 401     {
 402         rpc_result = JSONRPCReplyObj(NullUniValue,
 403                                      JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
 404     }
 405
 406     return rpc_result;
 407 }
 408
 409 std::string JSONRPCExecBatch(const UniValue& vReq)
 410 {
 411     UniValue ret(UniValue::VARR);
 412     for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
 413         ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
 414
 415     return ret.write() + "\n";
 416 }
 417
 418 /**
 419  * Process named arguments into a vector of positional arguments, based on the
 420  * passed-in specification for the RPC call's arguments.
 421  */
 422 static inline JSONRPCRequest transformNamedArguments(const JSONRPCRequest& in, const std::vector<std::string>& argNames)
 423 {
 424     JSONRPCRequest out = in;
 425     out.params = UniValue(UniValue::VARR);
 426     // Build a map of parameters, and remove ones that have been processed, so that we can throw a focused error if
 427     // there is an unknown one.
 428     const std::vector<std::string>& keys = in.params.getKeys();
 429     const std::vector<UniValue>& values = in.params.getValues();
 430     std::unordered_map<std::string, const UniValue*> argsIn;
 431     for (size_t i=0; i<keys.size(); ++i) {
 432         argsIn[keys[i]] = &values[i];
 433     }
 434     // Process expected parameters.
 435     int hole = 0;
 436     for (const std::string &argName: argNames) {
 437         auto fr = argsIn.find(argName);
 438         if (fr != argsIn.end()) {
 439             for (int i = 0; i < hole; ++i) {
 440                 // Fill hole between specified parameters with JSON nulls,
 441                 // but not at the end (for backwards compatibility with calls
 442                 // that act based on number of specified parameters).
 443                 out.params.push_back(UniValue());
 444             }
 445             hole = 0;
 446             out.params.push_back(*fr->second);
 447             argsIn.erase(fr);
 448         } else {
 449             hole += 1;
 450         }
 451     }
 452     // If there are still arguments in the argsIn map, this is an error.
 453     if (!argsIn.empty()) {
 454         throw JSONRPCError(RPC_INVALID_PARAMETER, "Unknown named parameter " + argsIn.begin()->first);
 455     }
 456     // Return request with named arguments transformed to positional arguments
 457     return out;
 458 }
 459
 460 UniValue CRPCTable::execute(const JSONRPCRequest &request) const
 461 {
 462     // Return immediately if in warmup
 463     {
 464         LOCK(cs_rpcWarmup);
 465         if (fRPCInWarmup)
 466             throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
 467     }
 468
 469     // Find method
 470     const CRPCCommand *pcmd = tableRPC[request.strMethod];
 471     if (!pcmd)
 472         throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
 473
 474     g_rpcSignals.PreCommand(*pcmd);
 475
 476     try
 477     {
 478         // Execute, convert arguments to array if necessary
 479         if (request.params.isObject()) {
 480             return pcmd->actor(transformNamedArguments(request, pcmd->argNames));
 481         } else {
 482             return pcmd->actor(request);
 483         }
 484     }
 485     catch (const std::exception& e)
 486     {
 487         throw JSONRPCError(RPC_MISC_ERROR, e.what());
 488     }
 489 }
 490
 491 std::vector<std::string> CRPCTable::listCommands() const
 492 {
 493     std::vector<std::string> commandList;
 494     typedef std::map<std::string, const CRPCCommand*> commandMap;
 495
 496     std::transform( mapCommands.begin(), mapCommands.end(),
 497                    std::back_inserter(commandList),
 498                    boost::bind(&commandMap::value_type::first,_1) );
 499     return commandList;
 500 }
 501
 502 std::string HelpExampleCli(const std::string& methodname, const std::string& args)
 503 {
 504     return "> bitcoin-cli " + methodname + " " + args + "\n";
 505 }
 506
 507 std::string HelpExampleRpc(const std::string& methodname, const std::string& args)
 508 {
 509     return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
 510         "\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:8332/\n";
 511 }
 512
 513 void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
 514 {
 515     if (!timerInterface)
 516         timerInterface = iface;
 517 }
 518
 519 void RPCSetTimerInterface(RPCTimerInterface *iface)
 520 {
 521     timerInterface = iface;
 522 }
 523
 524 void RPCUnsetTimerInterface(RPCTimerInterface *iface)
 525 {
 526     if (timerInterface == iface)
 527         timerInterface = NULL;
 528 }
 529
 530 void RPCRunLater(const std::string& name, boost::function<void(void)> func, int64_t nSeconds)
 531 {
 532     if (!timerInterface)
 533         throw JSONRPCError(RPC_INTERNAL_ERROR, "No timer handler registered for RPC");
 534     deadlineTimers.erase(name);
 535     LogPrint("rpc", "queue run of timer %s in %i seconds (using %s)\n", name, nSeconds, timerInterface->Name());
 536     deadlineTimers.emplace(name, std::unique_ptr<RPCTimerBase>(timerInterface->NewTimer(func, nSeconds*1000)));
 537 }
 538
 539 int RPCSerializationFlags()
 540 {
 541     int flag = 0;
 542     if (GetArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) == 0)
 543         flag |= SERIALIZE_TRANSACTION_NO_WITNESS;
 544     return flag;
 545 }
 546
 547 CRPCTable tableRPC;