[VerusCoin.git] / rpc.cpp

// Copyright (c) 2010 Satoshi Nakamoto\r
// Distributed under the MIT/X11 software license, see the accompanying\r
// file license.txt or http://www.opensource.org/licenses/mit-license.php.\r
\r
#include "headers.h"\r
#undef printf\r
#include <boost/asio.hpp>\r
#include "json/json_spirit_reader_template.h"\r
#include "json/json_spirit_writer_template.h"\r
#include "json/json_spirit_utils.h"\r
#define printf OutputDebugStringF\r
// MinGW 3.4.5 gets "fatal error: had to relocate PCH" if the json headers are\r
// precompiled in headers.h.  The problem might be when the pch file goes over\r
// a certain size around 145MB.  If we need access to json_spirit outside this\r
// file, we could use the compiled json_spirit option.\r
\r
using boost::asio::ip::tcp;\r
using namespace json_spirit;\r
\r
void ThreadRPCServer2(void* parg);\r
typedef Value(*rpcfn_type)(const Array& params, bool fHelp);\r
extern map<string, rpcfn_type> mapCallTable;\r
\r
\r
\r
\r
\r
\r
\r
///\r
/// Note: This interface may still be subject to change.\r
///\r
\r
\r
\r
Value help(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "help\n"\r
            "List commands.");\r
\r
    string strRet;\r
    for (map<string, rpcfn_type>::iterator mi = mapCallTable.begin(); mi != mapCallTable.end(); ++mi)\r
    {\r
        try\r
        {\r
            Array params;\r
            (*(*mi).second)(params, true);\r
        }\r
        catch (std::exception& e)\r
        {\r
            // Help text is returned in an exception\r
            string strHelp = string(e.what());\r
            if (strHelp.find('\n') != -1)\r
                strHelp = strHelp.substr(0, strHelp.find('\n'));\r
            strRet += strHelp + "\n";\r
        }\r
    }\r
    strRet = strRet.substr(0,strRet.size()-1);\r
    return strRet;\r
}\r
\r
\r
Value stop(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "stop\n"\r
            "Stop bitcoin server.");\r
\r
    // Shutdown will take long enough that the response should get back\r
    CreateThread(Shutdown, NULL);\r
    return "bitcoin server stopping";\r
}\r
\r
\r
Value getblockcount(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getblockcount\n"\r
            "Returns the number of blocks in the longest block chain.");\r
\r
    return nBestHeight + 1;\r
}\r
\r
\r
Value getblocknumber(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getblocknumber\n"\r
            "Returns the block number of the latest block in the longest block chain.");\r
\r
    return nBestHeight;\r
}\r
\r
\r
Value getconnectioncount(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getconnectioncount\n"\r
            "Returns the number of connections to other nodes.");\r
\r
    return (int)vNodes.size();\r
}\r
\r
\r
double GetDifficulty()\r
{\r
    // Floating point number that is a multiple of the minimum difficulty,\r
    // minimum difficulty = 1.0.\r
    if (pindexBest == NULL)\r
        return 1.0;\r
    int nShift = 256 - 32 - 31; // to fit in a uint\r
    double dMinimum = (CBigNum().SetCompact(bnProofOfWorkLimit.GetCompact()) >> nShift).getuint();\r
    double dCurrently = (CBigNum().SetCompact(pindexBest->nBits) >> nShift).getuint();\r
    return dMinimum / dCurrently;\r
}\r
\r
Value getdifficulty(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getdifficulty\n"\r
            "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.");\r
\r
    return GetDifficulty();\r
}\r
\r
\r
Value getbalance(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getbalance\n"\r
            "Returns the server's available balance.");\r
\r
    return ((double)GetBalance() / (double)COIN);\r
}\r
\r
\r
Value getgenerate(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getgenerate\n"\r
            "Returns true or false.");\r
\r
    return (bool)fGenerateBitcoins;\r
}\r
\r
\r
Value setgenerate(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() < 1 || params.size() > 2)\r
        throw runtime_error(\r
            "setgenerate <generate> [genproclimit]\n"\r
            "<generate> is true or false to turn generation on or off.\n"\r
            "Generation is limited to [genproclimit] processors, -1 is unlimited.");\r
\r
    bool fGenerate = true;\r
    if (params.size() > 0)\r
        fGenerate = params[0].get_bool();\r
\r
    if (params.size() > 1)\r
    {\r
        int nGenProcLimit = params[1].get_int();\r
        fLimitProcessors = (nGenProcLimit != -1);\r
        CWalletDB().WriteSetting("fLimitProcessors", fLimitProcessors);\r
        if (nGenProcLimit != -1)\r
            CWalletDB().WriteSetting("nLimitProcessors", nLimitProcessors = nGenProcLimit);\r
    }\r
\r
    GenerateBitcoins(fGenerate);\r
    return Value::null;\r
}\r
\r
\r
Value getinfo(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 0)\r
        throw runtime_error(\r
            "getinfo");\r
\r
    Object obj;\r
    obj.push_back(Pair("balance",       (double)GetBalance() / (double)COIN));\r
    obj.push_back(Pair("blocks",        (int)nBestHeight + 1));\r
    obj.push_back(Pair("connections",   (int)vNodes.size()));\r
    obj.push_back(Pair("proxy",         (fUseProxy ? addrProxy.ToStringIPPort() : string())));\r
    obj.push_back(Pair("generate",      (bool)fGenerateBitcoins));\r
    obj.push_back(Pair("genproclimit",  (int)(fLimitProcessors ? nLimitProcessors : -1)));\r
    obj.push_back(Pair("difficulty",    (double)GetDifficulty()));\r
    return obj;\r
}\r
\r
\r
Value getnewaddress(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() > 1)\r
        throw runtime_error(\r
            "getnewaddress [label]\n"\r
            "Returns a new bitcoin address for receiving payments.  "\r
            "If [label] is specified (recommended), it is added to the address book "\r
            "so payments received with the address will be labeled.");\r
\r
    // Parse the label first so we don't generate a key if there's an error\r
    string strLabel;\r
    if (params.size() > 0)\r
        strLabel = params[0].get_str();\r
\r
    // Generate a new key that is added to wallet\r
    string strAddress = PubKeyToAddress(GenerateNewKey());\r
\r
    SetAddressBookName(strAddress, strLabel);\r
    return strAddress;\r
}\r
\r
\r
Value setlabel(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() < 1 || params.size() > 2)\r
        throw runtime_error(\r
            "setlabel <bitcoinaddress> <label>\n"\r
            "Sets the label associated with the given address.");\r
\r
    string strAddress = params[0].get_str();\r
    string strLabel;\r
    if (params.size() > 1)\r
        strLabel = params[1].get_str();\r
\r
    SetAddressBookName(strAddress, strLabel);\r
    return Value::null;\r
}\r
\r
\r
Value getlabel(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 1)\r
        throw runtime_error(\r
            "getlabel <bitcoinaddress>\n"\r
            "Returns the label associated with the given address.");\r
\r
    string strAddress = params[0].get_str();\r
\r
    string strLabel;\r
    CRITICAL_BLOCK(cs_mapAddressBook)\r
    {\r
        map<string, string>::iterator mi = mapAddressBook.find(strAddress);\r
        if (mi != mapAddressBook.end() && !(*mi).second.empty())\r
            strLabel = (*mi).second;\r
    }\r
    return strLabel;\r
}\r
\r
\r
Value getaddressesbylabel(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() != 1)\r
        throw runtime_error(\r
            "getaddressesbylabel <label>\n"\r
            "Returns the list of addresses with the given label.");\r
\r
    string strLabel = params[0].get_str();\r
\r
    // Find all addresses that have the given label\r
    Array ret;\r
    CRITICAL_BLOCK(cs_mapAddressBook)\r
    {\r
        foreach(const PAIRTYPE(string, string)& item, mapAddressBook)\r
        {\r
            const string& strAddress = item.first;\r
            const string& strName = item.second;\r
            if (strName == strLabel)\r
            {\r
                // We're only adding valid bitcoin addresses and not ip addresses\r
                CScript scriptPubKey;\r
                if (scriptPubKey.SetBitcoinAddress(strAddress))\r
                    ret.push_back(strAddress);\r
            }\r
        }\r
    }\r
    return ret;\r
}\r
\r
\r
Value sendtoaddress(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() < 2 || params.size() > 4)\r
        throw runtime_error(\r
            "sendtoaddress <bitcoinaddress> <amount> [comment] [comment-to]\n"\r
            "<amount> is a real and is rounded to the nearest 0.01");\r
\r
    string strAddress = params[0].get_str();\r
\r
    // Amount\r
    if (params[1].get_real() <= 0.0 || params[1].get_real() > 21000000.0)\r
        throw runtime_error("Invalid amount");\r
    int64 nAmount = roundint64(params[1].get_real() * 100.00) * CENT;\r
\r
    // Wallet comments\r
    CWalletTx wtx;\r
    if (params.size() > 2 && params[2].type() != null_type && !params[2].get_str().empty())\r
        wtx.mapValue["message"] = params[2].get_str();\r
    if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())\r
        wtx.mapValue["to"]      = params[3].get_str();\r
\r
    string strError = SendMoneyToBitcoinAddress(strAddress, nAmount, wtx);\r
    if (strError != "")\r
        throw runtime_error(strError);\r
    return "sent";\r
}\r
\r
\r
Value listtransactions(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() > 2)\r
        throw runtime_error(\r
            "listtransactions [count=10] [includegenerated=false]\n"\r
            "Returns up to [count] most recent transactions.");\r
\r
    int64 nCount = 10;\r
    if (params.size() > 0)\r
        nCount = params[0].get_int64();\r
    bool fGenerated = false;\r
    if (params.size() > 1)\r
        fGenerated = params[1].get_bool();\r
\r
    Array ret;\r
    //// not finished\r
    ret.push_back("not implemented yet");\r
    return ret;\r
}\r
\r
\r
Value getreceivedbyaddress(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() < 1 || params.size() > 2)\r
        throw runtime_error(\r
            "getreceivedbyaddress <bitcoinaddress> [minconf=1]\n"\r
            "Returns the total amount received by <bitcoinaddress> in transactions with at least [minconf] confirmations.");\r
\r
    // Bitcoin address\r
    string strAddress = params[0].get_str();\r
    CScript scriptPubKey;\r
    if (!scriptPubKey.SetBitcoinAddress(strAddress))\r
        throw runtime_error("Invalid bitcoin address");\r
    if (!IsMine(scriptPubKey))\r
        return (double)0.0;\r
\r
    // Minimum confirmations\r
    int nMinDepth = 1;\r
    if (params.size() > 1)\r
        nMinDepth = params[1].get_int();\r
\r
    // Tally\r
    int64 nAmount = 0;\r
    CRITICAL_BLOCK(cs_mapWallet)\r
    {\r
        for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)\r
        {\r
            const CWalletTx& wtx = (*it).second;\r
            if (wtx.IsCoinBase() || !wtx.IsFinal())\r
                continue;\r
\r
            foreach(const CTxOut& txout, wtx.vout)\r
                if (txout.scriptPubKey == scriptPubKey)\r
                    if (wtx.GetDepthInMainChain() >= nMinDepth)\r
                        nAmount += txout.nValue;\r
        }\r
    }\r
\r
    return (double)nAmount / (double)COIN;\r
}\r
\r
\r
Value getreceivedbylabel(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() < 1 || params.size() > 2)\r
        throw runtime_error(\r
            "getreceivedbylabel <label> [minconf=1]\n"\r
            "Returns the total amount received by addresses with <label> in transactions with at least [minconf] confirmations.");\r
\r
    // Get the set of pub keys that have the label\r
    string strLabel = params[0].get_str();\r
    set<CScript> setPubKey;\r
    CRITICAL_BLOCK(cs_mapAddressBook)\r
    {\r
        foreach(const PAIRTYPE(string, string)& item, mapAddressBook)\r
        {\r
            const string& strAddress = item.first;\r
            const string& strName = item.second;\r
            if (strName == strLabel)\r
            {\r
                // We're only counting our own valid bitcoin addresses and not ip addresses\r
                CScript scriptPubKey;\r
                if (scriptPubKey.SetBitcoinAddress(strAddress))\r
                    if (IsMine(scriptPubKey))\r
                        setPubKey.insert(scriptPubKey);\r
            }\r
        }\r
    }\r
\r
    // Minimum confirmations\r
    int nMinDepth = 1;\r
    if (params.size() > 1)\r
        nMinDepth = params[1].get_int();\r
\r
    // Tally\r
    int64 nAmount = 0;\r
    CRITICAL_BLOCK(cs_mapWallet)\r
    {\r
        for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)\r
        {\r
            const CWalletTx& wtx = (*it).second;\r
            if (wtx.IsCoinBase() || !wtx.IsFinal())\r
                continue;\r
\r
            foreach(const CTxOut& txout, wtx.vout)\r
                if (setPubKey.count(txout.scriptPubKey))\r
                    if (wtx.GetDepthInMainChain() >= nMinDepth)\r
                        nAmount += txout.nValue;\r
        }\r
    }\r
\r
    return (double)nAmount / (double)COIN;\r
}\r
\r
\r
struct tallyitem\r
{\r
    int64 nAmount;\r
    int nConf;\r
    tallyitem()\r
    {\r
        nAmount = 0;\r
        nConf = INT_MAX;\r
    }\r
};\r
\r
Value ListReceived(const Array& params, bool fByLabels)\r
{\r
    // Minimum confirmations\r
    int nMinDepth = 1;\r
    if (params.size() > 0)\r
        nMinDepth = params[0].get_int();\r
\r
    // Whether to include empty accounts\r
    bool fIncludeEmpty = false;\r
    if (params.size() > 1)\r
        fIncludeEmpty = params[1].get_bool();\r
\r
    // Tally\r
    map<uint160, tallyitem> mapTally;\r
    CRITICAL_BLOCK(cs_mapWallet)\r
    {\r
        for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)\r
        {\r
            const CWalletTx& wtx = (*it).second;\r
            if (wtx.IsCoinBase() || !wtx.IsFinal())\r
                continue;\r
\r
            int nDepth = wtx.GetDepthInMainChain();\r
            if (nDepth < nMinDepth)\r
                continue;\r
\r
            foreach(const CTxOut& txout, wtx.vout)\r
            {\r
                // Only counting our own bitcoin addresses and not ip addresses\r
                uint160 hash160 = txout.scriptPubKey.GetBitcoinAddressHash160();\r
                if (hash160 == 0 || !mapPubKeys.count(hash160)) // IsMine\r
                    continue;\r
\r
                tallyitem& item = mapTally[hash160];\r
                item.nAmount += txout.nValue;\r
                item.nConf = min(item.nConf, nDepth);\r
            }\r
        }\r
    }\r
\r
    // Reply\r
    Array ret;\r
    map<string, tallyitem> mapLabelTally;\r
    CRITICAL_BLOCK(cs_mapAddressBook)\r
    {\r
        foreach(const PAIRTYPE(string, string)& item, mapAddressBook)\r
        {\r
            const string& strAddress = item.first;\r
            const string& strLabel = item.second;\r
            uint160 hash160;\r
            if (!AddressToHash160(strAddress, hash160))\r
                continue;\r
            map<uint160, tallyitem>::iterator it = mapTally.find(hash160);\r
            if (it == mapTally.end() && !fIncludeEmpty)\r
                continue;\r
\r
            int64 nAmount = 0;\r
            int nConf = INT_MAX;\r
            if (it != mapTally.end())\r
            {\r
                nAmount = (*it).second.nAmount;\r
                nConf = (*it).second.nConf;\r
            }\r
\r
            if (fByLabels)\r
            {\r
                tallyitem& item = mapLabelTally[strLabel];\r
                item.nAmount += nAmount;\r
                item.nConf = min(item.nConf, nConf);\r
            }\r
            else\r
            {\r
                Object obj;\r
                obj.push_back(Pair("address",       strAddress));\r
                obj.push_back(Pair("label",         strLabel));\r
                obj.push_back(Pair("amount",        (double)nAmount / (double)COIN));\r
                obj.push_back(Pair("confirmations", (nConf == INT_MAX ? 0 : nConf)));\r
                ret.push_back(obj);\r
            }\r
        }\r
    }\r
\r
    if (fByLabels)\r
    {\r
        for (map<string, tallyitem>::iterator it = mapLabelTally.begin(); it != mapLabelTally.end(); ++it)\r
        {\r
            int64 nAmount = (*it).second.nAmount;\r
            int nConf = (*it).second.nConf;\r
            Object obj;\r
            obj.push_back(Pair("label",         (*it).first));\r
            obj.push_back(Pair("amount",        (double)nAmount / (double)COIN));\r
            obj.push_back(Pair("confirmations", (nConf == INT_MAX ? 0 : nConf)));\r
            ret.push_back(obj);\r
        }\r
    }\r
\r
    return ret;\r
}\r
\r
Value listreceivedbyaddress(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() > 2)\r
        throw runtime_error(\r
            "listreceivedbyaddress [minconf=1] [includeempty=false]\n"\r
            "[minconf] is the minimum number of confirmations before payments are included.\n"\r
            "[includeempty] whether to include addresses that haven't received any payments.\n"\r
            "Returns an array of objects containing:\n"\r
            "  \"address\" : receiving address\n"\r
            "  \"label\" : the label of the receiving address\n"\r
            "  \"amount\" : total amount received by the address\n"\r
            "  \"confirmations\" : number of confirmations of the most recent transaction included");\r
\r
    return ListReceived(params, false);\r
}\r
\r
Value listreceivedbylabel(const Array& params, bool fHelp)\r
{\r
    if (fHelp || params.size() > 2)\r
        throw runtime_error(\r
            "listreceivedbylabel [minconf=1] [includeempty=false]\n"\r
            "[minconf] is the minimum number of confirmations before payments are included.\n"\r
            "[includeempty] whether to include labels that haven't received any payments.\n"\r
            "Returns an array of objects containing:\n"\r
            "  \"label\" : the label of the receiving addresses\n"\r
            "  \"amount\" : total amount received by addresses with this label\n"\r
            "  \"confirmations\" : number of confirmations of the most recent transaction included");\r
\r
    return ListReceived(params, true);\r
}\r
\r
\r
\r
\r
\r
\r
\r
\r
\r
\r
\r
\r
\r
//\r
// Call Table\r
//\r
\r
pair<string, rpcfn_type> pCallTable[] =\r
{\r
    make_pair("help",                  &help),\r
    make_pair("stop",                  &stop),\r
    make_pair("getblockcount",         &getblockcount),\r
    make_pair("getblocknumber",        &getblocknumber),\r
    make_pair("getconnectioncount",    &getconnectioncount),\r
    make_pair("getdifficulty",         &getdifficulty),\r
    make_pair("getbalance",            &getbalance),\r
    make_pair("getgenerate",           &getgenerate),\r
    make_pair("setgenerate",           &setgenerate),\r
    make_pair("getinfo",               &getinfo),\r
    make_pair("getnewaddress",         &getnewaddress),\r
    make_pair("setlabel",              &setlabel),\r
    make_pair("getlabel",              &getlabel),\r
    make_pair("getaddressesbylabel",   &getaddressesbylabel),\r
    make_pair("sendtoaddress",         &sendtoaddress),\r
    make_pair("listtransactions",      &listtransactions),\r
    make_pair("getamountreceived",     &getreceivedbyaddress), // deprecated, renamed to getreceivedbyaddress\r
    make_pair("getallreceived",        &listreceivedbyaddress), // deprecated, renamed to listreceivedbyaddress\r
    make_pair("getreceivedbyaddress",  &getreceivedbyaddress),\r
    make_pair("getreceivedbylabel",    &getreceivedbylabel),\r
    make_pair("listreceivedbyaddress", &listreceivedbyaddress),\r
    make_pair("listreceivedbylabel",   &listreceivedbylabel),\r
};\r
map<string, rpcfn_type> mapCallTable(pCallTable, pCallTable + sizeof(pCallTable)/sizeof(pCallTable[0]));\r
\r
\r
\r
\r
//\r
// HTTP protocol\r
//\r
// This ain't Apache.  We're just using HTTP header for the length field\r
// and to be compatible with other JSON-RPC implementations.\r
//\r
\r
string HTTPPost(const string& strMsg)\r
{\r
    return strprintf(\r
            "POST / HTTP/1.1\r\n"\r
            "User-Agent: json-rpc/1.0\r\n"\r
            "Host: 127.0.0.1\r\n"\r
            "Content-Type: application/json\r\n"\r
            "Content-Length: %d\r\n"\r
            "Accept: application/json\r\n"\r
            "\r\n"\r
            "%s",\r
        strMsg.size(),\r
        strMsg.c_str());\r
}\r
\r
string HTTPReply(const string& strMsg, int nStatus=200)\r
{\r
    string strStatus;\r
    if (nStatus == 200) strStatus = "OK";\r
    if (nStatus == 500) strStatus = "Internal Server Error";\r
    return strprintf(\r
            "HTTP/1.1 %d %s\r\n"\r
            "Connection: close\r\n"\r
            "Content-Length: %d\r\n"\r
            "Content-Type: application/json\r\n"\r
            "Date: Sat, 08 Jul 2006 12:04:08 GMT\r\n"\r
            "Server: json-rpc/1.0\r\n"\r
            "\r\n"\r
            "%s",\r
        nStatus,\r
        strStatus.c_str(),\r
        strMsg.size(),\r
        strMsg.c_str());\r
}\r
\r
int ReadHTTPHeader(tcp::iostream& stream)\r
{\r
    int nLen = 0;\r
    loop\r
    {\r
        string str;\r
        std::getline(stream, str);\r
        if (str.empty() || str == "\r")\r
            break;\r
        if (str.substr(0,15) == "Content-Length:")\r
            nLen = atoi(str.substr(15));\r
    }\r
    return nLen;\r
}\r
\r
inline string ReadHTTP(tcp::iostream& stream)\r
{\r
    // Read header\r
    int nLen = ReadHTTPHeader(stream);\r
    if (nLen <= 0)\r
        return string();\r
\r
    // Read message\r
    vector<char> vch(nLen);\r
    stream.read(&vch[0], nLen);\r
    return string(vch.begin(), vch.end());\r
}\r
\r
\r
\r
//\r
// JSON-RPC protocol\r
//\r
// http://json-rpc.org/wiki/specification\r
// http://www.codeproject.com/KB/recipes/JSON_Spirit.aspx\r
//\r
\r
string JSONRPCRequest(const string& strMethod, const Array& params, const Value& id)\r
{\r
    Object request;\r
    request.push_back(Pair("method", strMethod));\r
    request.push_back(Pair("params", params));\r
    request.push_back(Pair("id", id));\r
    return write_string(Value(request), false) + "\n";\r
}\r
\r
string JSONRPCReply(const Value& result, const Value& error, const Value& id)\r
{\r
    Object reply;\r
    if (error.type() != null_type)\r
        reply.push_back(Pair("result", Value::null));\r
    else\r
        reply.push_back(Pair("result", result));\r
    reply.push_back(Pair("error", error));\r
    reply.push_back(Pair("id", id));\r
    return write_string(Value(reply), false) + "\n";\r
}\r
\r
\r
\r
\r
void ThreadRPCServer(void* parg)\r
{\r
    IMPLEMENT_RANDOMIZE_STACK(ThreadRPCServer(parg));\r
    try\r
    {\r
        vnThreadsRunning[4]++;\r
        ThreadRPCServer2(parg);\r
        vnThreadsRunning[4]--;\r
    }\r
    catch (std::exception& e) {\r
        vnThreadsRunning[4]--;\r
        PrintException(&e, "ThreadRPCServer()");\r
    } catch (...) {\r
        vnThreadsRunning[4]--;\r
        PrintException(NULL, "ThreadRPCServer()");\r
    }\r
    printf("ThreadRPCServer exiting\n");\r
}\r
\r
void ThreadRPCServer2(void* parg)\r
{\r
    printf("ThreadRPCServer started\n");\r
\r
    // Bind to loopback 127.0.0.1 so the socket can only be accessed locally\r
    boost::asio::io_service io_service;\r
    tcp::endpoint endpoint(boost::asio::ip::address_v4::loopback(), 8332);\r
    tcp::acceptor acceptor(io_service, endpoint);\r
\r
    loop\r
    {\r
        // Accept connection\r
        tcp::iostream stream;\r
        tcp::endpoint peer;\r
        vnThreadsRunning[4]--;\r
        acceptor.accept(*stream.rdbuf(), peer);\r
        vnThreadsRunning[4]++;\r
        if (fShutdown)\r
            return;\r
\r
        // Shouldn't be possible for anyone else to connect, but just in case\r
        if (peer.address().to_string() != "127.0.0.1")\r
            continue;\r
\r
        // Receive request\r
        string strRequest = ReadHTTP(stream);\r
        printf("ThreadRPCServer request=%s", strRequest.c_str());\r
\r
        // Handle multiple invocations per request\r
        string::iterator begin = strRequest.begin();\r
        while (skipspaces(begin), begin != strRequest.end())\r
        {\r
            string::iterator prev = begin;\r
            Value id;\r
            try\r
            {\r
                // Parse request\r
                Value valRequest;\r
                if (!read_range(begin, strRequest.end(), valRequest))\r
                    throw runtime_error("Parse error.");\r
                const Object& request = valRequest.get_obj();\r
                if (find_value(request, "method").type() != str_type ||\r
                    find_value(request, "params").type() != array_type)\r
                    throw runtime_error("Invalid request.");\r
\r
                string strMethod    = find_value(request, "method").get_str();\r
                const Array& params = find_value(request, "params").get_array();\r
                id                  = find_value(request, "id");\r
\r
                // Execute\r
                map<string, rpcfn_type>::iterator mi = mapCallTable.find(strMethod);\r
                if (mi == mapCallTable.end())\r
                    throw runtime_error("Method not found.");\r
                Value result = (*(*mi).second)(params, false);\r
\r
                // Send reply\r
                string strReply = JSONRPCReply(result, Value::null, id);\r
                stream << HTTPReply(strReply, 200) << std::flush;\r
            }\r
            catch (std::exception& e)\r
            {\r
                // Send error reply\r
                string strReply = JSONRPCReply(Value::null, e.what(), id);\r
                stream << HTTPReply(strReply, 500) << std::flush;\r
            }\r
            if (begin == prev)\r
                break;\r
        }\r
    }\r
}\r
\r
\r
\r
\r
Value CallRPC(const string& strMethod, const Array& params)\r
{\r
    // Connect to localhost\r
    tcp::iostream stream("127.0.0.1", "8332");\r
    if (stream.fail())\r
        throw runtime_error("couldn't connect to server");\r
\r
    // Send request\r
    string strRequest = JSONRPCRequest(strMethod, params, 1);\r
    stream << HTTPPost(strRequest) << std::flush;\r
\r
    // Receive reply\r
    string strReply = ReadHTTP(stream);\r
    if (strReply.empty())\r
        throw runtime_error("no response from server");\r
\r
    // Parse reply\r
    Value valReply;\r
    if (!read_string(strReply, valReply))\r
        throw runtime_error("couldn't parse reply from server");\r
    const Object& reply = valReply.get_obj();\r
    if (reply.empty())\r
        throw runtime_error("expected reply to have result, error and id properties");\r
\r
    const Value& result = find_value(reply, "result");\r
    const Value& error  = find_value(reply, "error");\r
    const Value& id     = find_value(reply, "id");\r
\r
    if (error.type() == str_type)\r
        throw runtime_error(error.get_str());\r
    else if (error.type() != null_type)\r
        throw runtime_error(write_string(error, false));\r
    return result;\r
}\r
\r
\r
\r
\r
template<typename T>\r
void ConvertTo(Value& value)\r
{\r
    if (value.type() == str_type)\r
    {\r
        // reinterpret string as unquoted json value\r
        Value value2;\r
        if (!read_string(value.get_str(), value2))\r
            throw runtime_error("type mismatch");\r
        value = value2.get_value<T>();\r
    }\r
    else\r
    {\r
        value = value.get_value<T>();\r
    }\r
}\r
\r
int CommandLineRPC(int argc, char *argv[])\r
{\r
    try\r
    {\r
        // Check that method exists\r
        if (argc < 2)\r
            throw runtime_error("too few parameters");\r
        string strMethod = argv[1];\r
        if (!mapCallTable.count(strMethod))\r
            throw runtime_error(strprintf("unknown command: %s", strMethod.c_str()));\r
\r
        Value result;\r
        if (argc == 3 && strcmp(argv[2], "-?") == 0)\r
        {\r
            // Call help locally, help text is returned in an exception\r
            try\r
            {\r
                map<string, rpcfn_type>::iterator mi = mapCallTable.find(strMethod);\r
                Array params;\r
                (*(*mi).second)(params, true);\r
            }\r
            catch (std::exception& e)\r
            {\r
                result = e.what();\r
            }\r
        }\r
        else\r
        {\r
            // Parameters default to strings\r
            Array params;\r
            for (int i = 2; i < argc; i++)\r
                params.push_back(argv[i]);\r
            int n = params.size();\r
\r
            //\r
            // Special case non-string parameter types\r
            //\r
            if (strMethod == "setgenerate"            && n > 0) ConvertTo<bool>(params[0]);\r
            if (strMethod == "setgenerate"            && n > 1) ConvertTo<boost::int64_t>(params[1]);\r
            if (strMethod == "sendtoaddress"          && n > 1) ConvertTo<double>(params[1]);\r
            if (strMethod == "listtransactions"       && n > 0) ConvertTo<boost::int64_t>(params[0]);\r
            if (strMethod == "listtransactions"       && n > 1) ConvertTo<bool>(params[1]);\r
            if (strMethod == "getamountreceived"      && n > 1) ConvertTo<boost::int64_t>(params[1]); // deprecated\r
            if (strMethod == "getreceivedbyaddress"   && n > 1) ConvertTo<boost::int64_t>(params[1]);\r
            if (strMethod == "getreceivedbylabel"     && n > 1) ConvertTo<boost::int64_t>(params[1]);\r
            if (strMethod == "getallreceived"         && n > 0) ConvertTo<boost::int64_t>(params[0]); // deprecated\r
            if (strMethod == "getallreceived"         && n > 1) ConvertTo<bool>(params[1]);\r
            if (strMethod == "listreceivedbyaddress"  && n > 0) ConvertTo<boost::int64_t>(params[0]);\r
            if (strMethod == "listreceivedbyaddress"  && n > 1) ConvertTo<bool>(params[1]);\r
            if (strMethod == "listreceivedbylabel"    && n > 0) ConvertTo<boost::int64_t>(params[0]);\r
            if (strMethod == "listreceivedbylabel"    && n > 1) ConvertTo<bool>(params[1]);\r
\r
            // Execute\r
            result = CallRPC(strMethod, params);\r
        }\r
\r
        // Print result\r
        string strResult = (result.type() == str_type ? result.get_str() : write_string(result, true));\r
        if (result.type() != null_type)\r
        {\r
            if (fWindows && fGUI)\r
                // Windows GUI apps can't print to command line,\r
                // so settle for a message box yuck\r
                MyMessageBox(strResult.c_str(), "Bitcoin", wxOK);\r
            else\r
                fprintf(stdout, "%s\n", strResult.c_str());\r
        }\r
        return 0;\r
    }\r
    catch (std::exception& e) {\r
        if (fWindows && fGUI)\r
            MyMessageBox(strprintf("error: %s\n", e.what()).c_str(), "Bitcoin", wxOK);\r
        else\r
            fprintf(stderr, "error: %s\n", e.what());\r
    } catch (...) {\r
        PrintException(NULL, "CommandLineRPC()");\r
    }\r
    return 1;\r
}\r
\r
\r
\r
\r
#ifdef TEST\r
int main(int argc, char *argv[])\r
{\r
#ifdef _MSC_VER\r
    // Turn off microsoft heap dump noise\r
    _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);\r
    _CrtSetReportFile(_CRT_WARN, CreateFile("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));\r
#endif\r
    setbuf(stdin, NULL);\r
    setbuf(stdout, NULL);\r
    setbuf(stderr, NULL);\r
\r
    try\r
    {\r
        if (argc >= 2 && string(argv[1]) == "-server")\r
        {\r
            printf("server ready\n");\r
            ThreadRPCServer(NULL);\r
        }\r
        else\r
        {\r
            return CommandLineRPC(argc, argv);\r
        }\r
    }\r
    catch (std::exception& e) {\r
        PrintException(&e, "main()");\r
    } catch (...) {\r
        PrintException(NULL, "main()");\r
    }\r
    return 0;\r
}\r
#endif\r