// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "init.h"
-#include "util.h"
-#include "sync.h"
-#include "ui_interface.h"
#include "base58.h"
#include "bitcoinrpc.h"
#include "db.h"
+#include "interface.h"
+#include "sync.h"
+#include "util.h"
#undef printf
-#include <memory>
-#include <ixwebsocket/IXHttpServer.h>
-#include <ixwebsocket/IXHttpClient.h>
-#include <boost/asio.hpp>
-#include <boost/asio/ip/v6_only.hpp>
-#include <boost/bind.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/foreach.hpp>
-#include <boost/iostreams/concepts.hpp>
-#include <boost/iostreams/stream.hpp>
+
#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/asio/ssl.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <boost/shared_ptr.hpp>
+#include <ixwebsocket/IXHttpClient.h>
+#include <ixwebsocket/IXHttpServer.h>
+
#include <list>
+#include <memory>
#define printf OutputDebugStringF
-using namespace std;
-using namespace boost;
using namespace json_spirit;
std::unique_ptr<ix::HttpServer> g_server;
return GetBoolArg("-testnet", false) ? 18344 : 8344;
}
-Object JSONRPCError(int code, const string& message)
+Object JSONRPCError(int code, const std::string& message)
{
Object error;
error.push_back(Pair("code", code));
}
void RPCTypeCheck(const Array& params,
- const list<Value_type>& typesExpected,
+ const std::list<Value_type>& typesExpected,
bool fAllowNull)
{
unsigned int i = 0;
- BOOST_FOREACH(Value_type t, typesExpected)
+ for(Value_type t : typesExpected)
{
if (params.size() <= i)
break;
const Value& v = params[i];
if (!((v.type() == t) || (fAllowNull && (v.type() == null_type))))
{
- string err = strprintf("Expected type %s, got %s",
+ std::string err = strprintf("Expected type %s, got %s",
Value_type_name[t], Value_type_name[v.type()]);
throw JSONRPCError(RPC_TYPE_ERROR, err);
}
}
void RPCTypeCheck(const Object& o,
- const map<string, Value_type>& typesExpected,
+ const std::map<std::string, Value_type>& typesExpected,
bool fAllowNull)
{
- BOOST_FOREACH(const PAIRTYPE(string, Value_type)& t, typesExpected)
+ for(const auto& t : typesExpected)
{
const Value& v = find_value(o, t.first);
if (!fAllowNull && v.type() == null_type)
if (!((v.type() == t.second) || (fAllowNull && (v.type() == null_type))))
{
- string err = strprintf("Expected type %s for %s, got %s",
+ std::string err = strprintf("Expected type %s for %s, got %s",
Value_type_name[t.second], t.first.c_str(), Value_type_name[v.type()]);
throw JSONRPCError(RPC_TYPE_ERROR, err);
}
int64_t AmountFromValue(const Value& value)
{
double dAmount = value.get_real();
- if (dAmount <= 0.0 || dAmount > MAX_MONEY)
+ if (dAmount <= 0.0 || dAmount > (double) (MAX_MONEY / 100000000))
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
int64_t nAmount = roundint64(dAmount * COIN);
if (!MoneyRange(nAmount))
// Utilities: convert hex-encoded Values
// (throws error if not hex).
//
-uint256 ParseHashV(const Value& v, string strName)
+uint256 ParseHashV(const Value& v, const std::string& strName)
{
- string strHex;
+ std::string strHex;
if (v.type() == str_type)
strHex = v.get_str();
if (!IsHex(strHex)) // Note: IsHex("") is false
return result;
}
-uint256 ParseHashO(const Object& o, string strKey)
+uint256 ParseHashO(const Object& o, const std::string& strKey)
{
return ParseHashV(find_value(o, strKey), strKey);
}
-vector<unsigned char> ParseHexV(const Value& v, string strName)
+std::vector<unsigned char> ParseHexV(const Value& v, const std::string& strName)
{
- string strHex;
+ std::string strHex;
if (v.type() == str_type)
strHex = v.get_str();
if (!IsHex(strHex))
return ParseHex(strHex);
}
-vector<unsigned char> ParseHexO(const Object& o, string strKey)
+std::vector<unsigned char> ParseHexO(const Object& o, const std::string& strKey)
{
return ParseHexV(find_value(o, strKey), strKey);
}
/// Note: This interface may still be subject to change.
///
-string CRPCTable::help(string strCommand) const
+std::string CRPCTable::help(const std::string& strCommand) const
{
- string strRet;
- set<rpcfn_type> setDone;
- for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
+ std::string strRet;
+ std::set<rpcfn_type> setDone;
+ for (const auto & mapCommand : mapCommands)
{
- const CRPCCommand *pcmd = mi->second;
- string strMethod = mi->first;
+ const CRPCCommand *pcmd = mapCommand.second;
+ std::string strMethod = mapCommand.first;
// We already filter duplicates, but these deprecated screw up the sort order
- if (strMethod.find("label") != string::npos)
+ if (strMethod.find("label") != std::string::npos)
continue;
if (!strCommand.empty() && strMethod != strCommand)
continue;
if (setDone.insert(pfn).second)
(*pfn)(params, true);
}
- catch (std::exception& e)
+ catch (const std::exception& e)
{
// Help text is returned in an exception
- string strHelp = string(e.what());
+ std::string strHelp = std::string(e.what());
if (strCommand.empty())
- if (strHelp.find('\n') != string::npos)
+ if (strHelp.find('\n') != std::string::npos)
strHelp = strHelp.substr(0, strHelp.find('\n'));
- strRet += strHelp + "\n";
+ strRet += strHelp + '\n';
}
}
if (strRet.empty())
Value help(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"help [command]\n"
"List commands, or get help for a command.");
- string strCommand;
- if (params.size() > 0)
+ std::string strCommand;
+ if (!params.empty())
strCommand = params[0].get_str();
return tableRPC.help(strCommand);
Value stop(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
- throw runtime_error(
+ throw std::runtime_error(
"stop <detach>\n"
"<detach> is true or false to detach the database or not for this stop only\n"
"Stop NovaCoin server (and possibly override the detachdb config value).");
// Shutdown will take long enough that the response should get back
- if (params.size() > 0)
+ if (!params.empty())
bitdb.SetDetach(params[0].get_bool());
StartShutdown();
return "NovaCoin server stopping";
{ "submitblock", &submitblock, false, false },
{ "listsinceblock", &listsinceblock, false, false },
{ "dumpprivkey", &dumpprivkey, false, false },
- { "dumppem", &dumppem, true, false },
{ "dumpwallet", &dumpwallet, true, false },
{ "importwallet", &importwallet, false, false },
{ "importprivkey", &importprivkey, false, false },
{ "listmalleableviews", &listmalleableviews, false, false},
{ "dumpmalleablekey", &dumpmalleablekey, false, false},
{ "importmalleablekey", &importmalleablekey, true, false },
- { "encryptdata", &encryptdata, false, false },
- { "decryptdata", &decryptdata, false, false },
- { "encryptmessage", &encryptmessage, false, false },
- { "decryptmessage", &decryptmessage, false, false },
{ "sendalert", &sendalert, false, false},
};
CRPCTable::CRPCTable()
{
- unsigned int vcidx;
- for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
+ for (const auto & vRPCCommand : vRPCCommands)
{
const CRPCCommand *pcmd;
- pcmd = &vRPCCommands[vcidx];
+ pcmd = &vRPCCommand;
mapCommands[pcmd->name] = pcmd;
}
}
-const CRPCCommand *CRPCTable::operator[](string name) const
+const CRPCCommand *CRPCTable::operator[](const std::string& name) const
{
- map<string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
+ auto it = mapCommands.find(name);
if (it == mapCommands.end())
- return NULL;
+ return nullptr;
return (*it).second;
}
-string rfc1123Time()
-{
- return DateTimeStrFormat("%a, %d %b %Y %H:%M:%S +0000", GetTime());
-}
-
-static string HTTPReply(int nStatus, const string& strMsg, bool keepalive)
-{
- if (nStatus == HTTP_UNAUTHORIZED)
- return strprintf("HTTP/1.0 401 Authorization Required\r\n"
- "Date: %s\r\n"
- "Server: novacoin-json-rpc/%s\r\n"
- "WWW-Authenticate: Basic realm=\"jsonrpc\"\r\n"
- "Content-Type: text/html\r\n"
- "Content-Length: 296\r\n"
- "\r\n"
- "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\r\n"
- "\"http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd\">\r\n"
- "<HTML>\r\n"
- "<HEAD>\r\n"
- "<TITLE>Error</TITLE>\r\n"
- "<META HTTP-EQUIV='Content-Type' CONTENT='text/html; charset=ISO-8859-1'>\r\n"
- "</HEAD>\r\n"
- "<BODY><H1>401 Unauthorized.</H1></BODY>\r\n"
- "</HTML>\r\n", rfc1123Time().c_str(), FormatFullVersion().c_str());
- const char *cStatus;
- if (nStatus == HTTP_OK) cStatus = "OK";
- else if (nStatus == HTTP_BAD_REQUEST) cStatus = "Bad Request";
- else if (nStatus == HTTP_FORBIDDEN) cStatus = "Forbidden";
- else if (nStatus == HTTP_NOT_FOUND) cStatus = "Not Found";
- else if (nStatus == HTTP_INTERNAL_SERVER_ERROR) cStatus = "Internal Server Error";
- else cStatus = "";
- return strprintf(
- "HTTP/1.1 %d %s\r\n"
- "Date: %s\r\n"
- "Connection: %s\r\n"
- "Content-Length: %" PRIszu "\r\n"
- "Content-Type: application/json\r\n"
- "Server: novacoin-json-rpc/%s\r\n"
- "\r\n"
- "%s",
- nStatus,
- cStatus,
- rfc1123Time().c_str(),
- keepalive ? "keep-alive" : "close",
- strMsg.size(),
- FormatFullVersion().c_str(),
- strMsg.c_str());
-}
-
-int ReadHTTPStatus(std::basic_istream<char>& stream, int &proto)
-{
- string str;
- getline(stream, str);
- vector<string> vWords;
- istringstream iss(str);
- copy(istream_iterator<string>(iss), istream_iterator<string>(), back_inserter(vWords));
- if (vWords.size() < 2)
- return HTTP_INTERNAL_SERVER_ERROR;
- proto = 0;
- const char *ver = strstr(str.c_str(), "HTTP/1.");
- if (ver != NULL)
- proto = atoi(ver+7);
- return atoi(vWords[1].c_str());
-}
-
-int ReadHTTPHeader(std::basic_istream<char>& stream, map<string, string>& mapHeadersRet)
-{
- int nLen = 0;
- for ( ; ; )
- {
- string str;
- std::getline(stream, str);
- if (str.empty() || str == "\r")
- break;
- string::size_type nColon = str.find(":");
- if (nColon != string::npos)
- {
- string strHeader = str.substr(0, nColon);
- boost::trim(strHeader);
- boost::to_lower(strHeader);
- string strValue = str.substr(nColon+1);
- boost::trim(strValue);
- mapHeadersRet[strHeader] = strValue;
- if (strHeader == "content-length")
- nLen = atoi(strValue.c_str());
- }
- }
- return nLen;
-}
-
-int ReadHTTP(std::basic_istream<char>& stream, map<string, string>& mapHeadersRet, string& strMessageRet)
+bool HTTPAuthorized(ix::WebSocketHttpHeaders& mapHeaders)
{
- mapHeadersRet.clear();
- strMessageRet.clear();
-
- // Read status
- int nProto = 0;
- int nStatus = ReadHTTPStatus(stream, nProto);
-
- // Read header
- int nLen = ReadHTTPHeader(stream, mapHeadersRet);
- if (nLen < 0 || nLen > (int)MAX_SIZE)
- return HTTP_INTERNAL_SERVER_ERROR;
-
- // Read message
- if (nLen > 0)
- {
- vector<char> vch(nLen);
- stream.read(&vch[0], nLen);
- strMessageRet = string(vch.begin(), vch.end());
- }
-
- string sConHdr = mapHeadersRet["connection"];
-
- if ((sConHdr != "close") && (sConHdr != "keep-alive"))
- {
- if (nProto >= 1)
- mapHeadersRet["connection"] = "keep-alive";
- else
- mapHeadersRet["connection"] = "close";
- }
-
- return nStatus;
-}
-
-bool HTTPAuthorized(map<string, string>& mapHeaders)
-{
- string strAuth = mapHeaders["authorization"];
+ std::string strAuth = mapHeaders["authorization"];
if (strAuth.substr(0,6) != "Basic ")
return false;
- string strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
- string strUserPass = DecodeBase64(strUserPass64);
+ std::string strUserPass64 = strAuth.substr(6); boost::algorithm::trim(strUserPass64);
+ std::string strUserPass = DecodeBase64(strUserPass64);
return TimingResistantEqual(strUserPass, strRPCUserColonPass);
}
// http://www.codeproject.com/KB/recipes/JSON_Spirit.aspx
//
-string JSONRPCRequest(const string& strMethod, const Array& params, const Value& id)
+std::string JSONRPCRequest(const std::string& strMethod, const Array& params, const Value& id)
{
Object request;
request.push_back(Pair("method", strMethod));
return reply;
}
-string JSONRPCReply(const Value& result, const Value& error, const Value& id)
+std::string JSONRPCReply(const Value& result, const Value& error, const Value& id)
{
Object reply = JSONRPCReplyObj(result, error, id);
return write_string(Value(reply), false) + "\n";
}
-string ErrorReply(const Object& objError, const Value& id)
+std::string ErrorReply(const Object& objError, const Value& id)
{
// Send error reply from json-rpc error object
int nStatus = HTTP_INTERNAL_SERVER_ERROR;
{
public:
Value id;
- string strMethod;
+ std::string strMethod;
Array params;
JSONRequest() { id = Value::null; }
{
rpc_result = JSONRPCReplyObj(Value::null, objError, jreq.id);
}
- catch (std::exception& e)
+ catch (const std::exception& e)
{
rpc_result = JSONRPCReplyObj(Value::null,
JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
return rpc_result;
}
-static string JSONRPCExecBatch(const Array& vReq)
+static std::string JSONRPCExecBatch(const Array& vReq)
{
Array ret;
- for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
- ret.push_back(JSONRPCExecOne(vReq[reqIdx]));
+ for (const auto & reqIdx : vReq)
+ ret.push_back(JSONRPCExecOne(reqIdx));
return write_string(Value(ret), false) + "\n";
}
void StartRPCServer()
{
- string host = GetArg("-rpchost", "127.0.0.1");
+ strRPCUserColonPass = mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"];
+ if (mapArgs["-rpcpassword"].empty())
+ {
+ unsigned char rand_pwd[32];
+ RAND_bytes(rand_pwd, 32);
+ std::string strWhatAmI = "To use novacoind";
+ if (mapArgs.count("-server"))
+ strWhatAmI = strprintf(_("To use the %s option"), "\"-server\"");
+ else if (mapArgs.count("-daemon"))
+ strWhatAmI = strprintf(_("To use the %s option"), "\"-daemon\"");
+ uiInterface.ThreadSafeMessageBox(strprintf(
+ _("%s, you must set a rpcpassword in the configuration file:\n %s\n"
+ "It is recommended you use the following random password:\n"
+ "rpcuser=novacoinrpc\n"
+ "rpcpassword=%s\n"
+ "(you do not need to remember this password)\n"
+ "If the file does not exist, create it with owner-readable-only file permissions.\n"),
+ strWhatAmI.c_str(),
+ GetConfigFile().string().c_str(),
+ EncodeBase58(&rand_pwd[0],&rand_pwd[0]+32).c_str()),
+ _("Error"), CClientUIInterface::OK | CClientUIInterface::MODAL);
+ StartShutdown();
+ return;
+ }
+
+ std::string host = GetArg("-rpchost", "127.0.0.1");
int port = GetArg("-rpcport", GetDefaultRPCPort());
- g_server = std::unique_ptr<ix::HttpServer>(new ix::HttpServer(port, host));
+ g_server = std::make_unique<ix::HttpServer>(port, host);
LOCK(cs_THREAD_RPCHANDLER);
- g_server->setOnConnectionCallback([](ix::HttpRequestPtr request, std::shared_ptr<ix::ConnectionState> connectionState) -> ix::HttpResponsePtr {
+ g_server->setOnConnectionCallback([](const ix::HttpRequestPtr& request, const std::shared_ptr<ix::ConnectionState>& connectionState) -> ix::HttpResponsePtr {
ix::WebSocketHttpHeaders headers;
+ headers["Server"] = std::string("novacoin-json-rpc/") + FormatFullVersion();
+ headers["WWW-Authenticate"] = R"(Basic realm="jsonrpc")";
+
+ if (!HTTPAuthorized(request->headers))
+ {
+ printf("ThreadRPCServer incorrect password attempt from %s\n", connectionState->getRemoteIp().c_str());
+ connectionState->setTerminated();
+ return std::make_shared<ix::HttpResponse>(HTTP_UNAUTHORIZED, "Unauthorized", ix::HttpErrorCode::Ok, headers, "Not authorized");
+ }
if (request->method != "POST") {
- return std::make_shared<ix::HttpResponse>(400, "Bad request", ix::HttpErrorCode::Ok, headers, "Bad request");
+ connectionState->setTerminated();
+ return std::make_shared<ix::HttpResponse>(HTTP_BAD_REQUEST, "Bad request", ix::HttpErrorCode::Ok, headers, "Bad request");
}
JSONRequest jreq;
if (!read_string(request->body, valRequest))
throw JSONRPCError(RPC_PARSE_ERROR, "Parse error");
- string strReply;
+ std::string strReply;
// singleton request
if (valRequest.type() == obj_type) {
}
catch(Object& objError)
{
- return std::make_shared<ix::HttpResponse>(500, "Internal Server Error", ix::HttpErrorCode::Ok, headers, ErrorReply(objError, jreq.id));
+ return std::make_shared<ix::HttpResponse>(HTTP_INTERNAL_SERVER_ERROR, "Internal Server Error", ix::HttpErrorCode::Ok, headers, ErrorReply(objError, jreq.id));
}
- catch(std::exception& e)
+ catch(const std::exception& e)
{
- return std::make_shared<ix::HttpResponse>(500, "Internal Server Error", ix::HttpErrorCode::Ok, headers, ErrorReply(JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id));
+ return std::make_shared<ix::HttpResponse>(HTTP_INTERNAL_SERVER_ERROR, "Internal Server Error", ix::HttpErrorCode::Ok, headers, ErrorReply(JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id));
}
});
return StartShutdown();
}
+ // Run listening thread
+ g_server->start();
+
// We're listening now
vnThreadsRunning[THREAD_RPCLISTENER]++;
}
vnThreadsRunning[THREAD_RPCLISTENER]--;
}
-json_spirit::Value CRPCTable::execute(const std::string &strMethod, const json_spirit::Array ¶ms) const
+ json_spirit::Value CRPCTable::execute(const std::string &strMethod, const json_spirit::Array ¶ms) const
{
// Find method
const CRPCCommand *pcmd = tableRPC[strMethod];
throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
// Observe safe mode
- string strWarning = GetWarnings("rpc");
+ std::string strWarning = GetWarnings("rpc");
if (!strWarning.empty() && !GetBoolArg("-disablesafemode") &&
!pcmd->okSafeMode)
- throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, string("Safe mode: ") + strWarning);
+ throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, std::string("Safe mode: ") + strWarning);
try
{
}
return result;
}
- catch (std::exception& e)
+ catch (const std::exception& e)
{
throw JSONRPCError(RPC_MISC_ERROR, e.what());
}
std::vector<std::string> CRPCTable::listCommands() const
{
std::vector<std::string> commandList;
- typedef std::map<std::string, const CRPCCommand*> commandMap;
-
- std::transform( mapCommands.begin(), mapCommands.end(),
- std::back_inserter(commandList),
- boost::bind(&commandMap::value_type::first,_1) );
+ for (const auto& i : mapCommands) commandList.emplace_back(i.first);
return commandList;
}
-Object CallRPC(const string& strMethod, const Array& params)
+Object CallRPC(const std::string& strMethod, const Array& params)
{
if (mapArgs["-rpcuser"].empty() && mapArgs["-rpcpassword"].empty())
- throw runtime_error(strprintf(
+ throw std::runtime_error(strprintf(
_("You must set rpcpassword=<password> in the configuration file:\n%s\n"
"If the file does not exist, create it with owner-readable-only file permissions."),
GetConfigFile().string().c_str()));
+ // Init net subsystem
+ ix::initNetSystem();
+
// Create HTTP client
ix::HttpClient httpClient;
ix::HttpRequestArgsPtr args = httpClient.createRequest();
// HTTP basic authentication
ix::WebSocketHttpHeaders mapRequestHeaders;
- string strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
- mapRequestHeaders["Authorization"] = string("Basic ") + strUserPass64;
+ std::string strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
+ mapRequestHeaders["Authorization"] = std::string("Basic ") + strUserPass64;
args->extraHeaders = mapRequestHeaders;
// Timeouts
args->transferTimeout = GetArgInt("-rpc_transfertimeout", 30000);
bool fUseSSL = GetBoolArg("-rpcssl");
- string url = string(fUseSSL ? "https://" : "http://") + GetArg("-rpcconnect", "127.0.0.1") + ":" + GetArg("-rpcport", itostr(GetDefaultRPCPort()));
+ std::string url = std::string(fUseSSL ? "https://" : "http://") + GetArg("-rpcconnect", "127.0.0.1") + ":" + GetArg("-rpcport", itostr(GetDefaultRPCPort()));
// Send request
- string strRequest = JSONRPCRequest(strMethod, params, GetRandInt(INT32_MAX));
+ std::string strRequest = JSONRPCRequest(strMethod, params, GetRandInt(INT32_MAX));
auto out = httpClient.post(url, strRequest, args);
// Process reply
int nStatus = out->statusCode;
- string strReply = out->body;
+ std::string strReply = out->body;
ix::WebSocketHttpHeaders mapHeaders = out->headers;
// Receive reply
if (nStatus == HTTP_UNAUTHORIZED)
- throw runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
- else if (nStatus >= 400 && nStatus != HTTP_BAD_REQUEST && nStatus != HTTP_NOT_FOUND && nStatus != HTTP_INTERNAL_SERVER_ERROR)
- throw runtime_error(strprintf("server returned HTTP error %d", nStatus));
+ throw std::runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
+ else if (nStatus >= HTTP_BAD_REQUEST && nStatus != HTTP_BAD_REQUEST && nStatus != HTTP_NOT_FOUND && nStatus != HTTP_INTERNAL_SERVER_ERROR)
+ throw std::runtime_error(strprintf("server returned HTTP error %d", nStatus));
else if (strReply.empty())
- throw runtime_error("no response from server");
+ throw std::runtime_error("no response from server");
// Parse reply
Value valReply;
if (!read_string(strReply, valReply))
- throw runtime_error("couldn't parse reply from server");
+ throw std::runtime_error("couldn't parse reply from server");
const Object& reply = valReply.get_obj();
if (reply.empty())
- throw runtime_error("expected reply to have result, error and id properties");
+ throw std::runtime_error("expected reply to have result, error and id properties");
return reply;
}
{
// reinterpret string as unquoted json value
Value value2;
- string strJSON = value.get_str();
+ std::string strJSON = value.get_str();
if (!read_string(strJSON, value2))
- throw runtime_error(string("Error parsing JSON:")+strJSON);
+ throw std::runtime_error(std::string("Error parsing JSON:")+strJSON);
ConvertTo<T>(value2, fAllowNull);
value = value2;
}
Array RPCConvertValues(const std::string &strMethod, const std::vector<std::string> &strParams)
{
Array params;
- BOOST_FOREACH(const std::string ¶m, strParams)
+ for(const auto ¶m : strParams)
params.push_back(param);
size_t n = params.size();
int CommandLineRPC(int argc, char *argv[])
{
- string strPrint;
+ std::string strPrint;
int nRet = 0;
try
{
// Method
if (argc < 2)
- throw runtime_error("too few parameters");
- string strMethod = argv[1];
+ throw std::runtime_error("too few parameters");
+ std::string strMethod = argv[1];
// Parameters default to strings
std::vector<std::string> strParams(&argv[2], &argv[argc]);
strPrint = write_string(result, true);
}
}
- catch (std::exception& e)
+ catch (const std::exception& e)
{
- strPrint = string("error: ") + e.what();
+ strPrint = std::string("error: ") + e.what();
nRet = 87;
}
catch (...)
{
- PrintException(NULL, "CommandLineRPC()");
+ PrintException(nullptr, "CommandLineRPC()");
}
if (!strPrint.empty())
git://git.novaco.in / novacoin.git / blobdiff