src/rpcclient.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 "rpcclient.h"
   7
   8 #include "rpcprotocol.h"
   9 #include "util.h"
  10
  11 #include <set>
  12 #include <stdint.h>
  13
  14 #include <boost/algorithm/string/case_conv.hpp> // for to_lower()
  15 #include <univalue.h>
  16
  17 using namespace std;
  18
  19 class CRPCConvertParam
  20 {
  21 public:
  22     std::string methodName;            //! method whose params want conversion
  23     int paramIdx;                      //! 0-based idx of param to convert
  24 };
  25
  26 static const CRPCConvertParam vRPCConvertParams[] =
  27 {
  28     { "stop", 0 },
  29     { "setmocktime", 0 },
  30     { "getaddednodeinfo", 0 },
  31     { "setgenerate", 0 },
  32     { "setgenerate", 1 },
  33     { "generate", 0 },
  34     { "getnetworkhashps", 0 },
  35     { "getnetworkhashps", 1 },
  36     { "sendtoaddress", 1 },
  37     { "sendtoaddress", 4 },
  38     { "settxfee", 0 },
  39     { "getreceivedbyaddress", 1 },
  40     { "getreceivedbyaccount", 1 },
  41     { "listreceivedbyaddress", 0 },
  42     { "listreceivedbyaddress", 1 },
  43     { "listreceivedbyaddress", 2 },
  44     { "listreceivedbyaccount", 0 },
  45     { "listreceivedbyaccount", 1 },
  46     { "listreceivedbyaccount", 2 },
  47     { "getbalance", 1 },
  48     { "getbalance", 2 },
  49     { "getblockhash", 0 },
  50     { "move", 2 },
  51     { "move", 3 },
  52     { "sendfrom", 2 },
  53     { "sendfrom", 3 },
  54     { "listtransactions", 1 },
  55     { "listtransactions", 2 },
  56     { "listtransactions", 3 },
  57     { "listaccounts", 0 },
  58     { "listaccounts", 1 },
  59     { "walletpassphrase", 1 },
  60     { "getblocktemplate", 0 },
  61     { "listsinceblock", 1 },
  62     { "listsinceblock", 2 },
  63     { "sendmany", 1 },
  64     { "sendmany", 2 },
  65     { "sendmany", 4 },
  66     { "addmultisigaddress", 0 },
  67     { "addmultisigaddress", 1 },
  68     { "createmultisig", 0 },
  69     { "createmultisig", 1 },
  70     { "listunspent", 0 },
  71     { "listunspent", 1 },
  72     { "listunspent", 2 },
  73     { "getblock", 1 },
  74     { "getblockheader", 1 },
  75     { "gettransaction", 1 },
  76     { "getrawtransaction", 1 },
  77     { "createrawtransaction", 0 },
  78     { "createrawtransaction", 1 },
  79     { "createrawtransaction", 2 },
  80     { "signrawtransaction", 1 },
  81     { "signrawtransaction", 2 },
  82     { "sendrawtransaction", 1 },
  83     { "fundrawtransaction", 1 },
  84     { "gettxout", 1 },
  85     { "gettxout", 2 },
  86     { "gettxoutproof", 0 },
  87     { "lockunspent", 0 },
  88     { "lockunspent", 1 },
  89     { "importprivkey", 2 },
  90     { "importaddress", 2 },
  91     { "importaddress", 3 },
  92     { "importpubkey", 2 },
  93     { "verifychain", 0 },
  94     { "verifychain", 1 },
  95     { "keypoolrefill", 0 },
  96     { "getrawmempool", 0 },
  97     { "estimatefee", 0 },
  98     { "estimatepriority", 0 },
  99     { "estimatesmartfee", 0 },
 100     { "estimatesmartpriority", 0 },
 101     { "prioritisetransaction", 1 },
 102     { "prioritisetransaction", 2 },
 103     { "setban", 2 },
 104     { "setban", 3 },
 105 };
 106
 107 class CRPCConvertTable
 108 {
 109 private:
 110     std::set<std::pair<std::string, int> > members;
 111
 112 public:
 113     CRPCConvertTable();
 114
 115     bool convert(const std::string& method, int idx) {
 116         return (members.count(std::make_pair(method, idx)) > 0);
 117     }
 118 };
 119
 120 CRPCConvertTable::CRPCConvertTable()
 121 {
 122     const unsigned int n_elem =
 123         (sizeof(vRPCConvertParams) / sizeof(vRPCConvertParams[0]));
 124
 125     for (unsigned int i = 0; i < n_elem; i++) {
 126         members.insert(std::make_pair(vRPCConvertParams[i].methodName,
 127                                       vRPCConvertParams[i].paramIdx));
 128     }
 129 }
 130
 131 static CRPCConvertTable rpcCvtTable;
 132
 133 /** Non-RFC4627 JSON parser, accepts internal values (such as numbers, true, false, null)
 134  * as well as objects and arrays.
 135  */
 136 UniValue ParseNonRFCJSONValue(const std::string& strVal)
 137 {
 138     UniValue jVal;
 139     if (!jVal.read(std::string("[")+strVal+std::string("]")) ||
 140         !jVal.isArray() || jVal.size()!=1)
 141         throw runtime_error(string("Error parsing JSON:")+strVal);
 142     return jVal[0];
 143 }
 144
 145 /** Convert strings to command-specific RPC representation */
 146 UniValue RPCConvertValues(const std::string &strMethod, const std::vector<std::string> &strParams)
 147 {
 148     UniValue params(UniValue::VARR);
 149
 150     for (unsigned int idx = 0; idx < strParams.size(); idx++) {
 151         const std::string& strVal = strParams[idx];
 152
 153         if (!rpcCvtTable.convert(strMethod, idx)) {
 154             // insert string value directly
 155             params.push_back(strVal);
 156         } else {
 157             // parse string as JSON, insert bool/number/object/etc. value
 158             params.push_back(ParseNonRFCJSONValue(strVal));
 159         }
 160     }
 161
 162     return params;
 163 }
 164