// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "init.h"
-#include "util.h"
-#include "sync.h"
-#include "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";
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;
}
bool HTTPAuthorized(ix::WebSocketHttpHeaders& 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";
}
{
unsigned char rand_pwd[32];
RAND_bytes(rand_pwd, 32);
- string strWhatAmI = "To use novacoind";
+ std::string strWhatAmI = "To use novacoind";
if (mapArgs.count("-server"))
strWhatAmI = strprintf(_("To use the %s option"), "\"-server\"");
else if (mapArgs.count("-daemon"))
return;
}
- string host = GetArg("-rpchost", "127.0.0.1");
+ 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"] = string("novacoin-json-rpc/") + FormatFullVersion();
- headers["WWW-Authenticate"] = "Basic realm=\"jsonrpc\"";
+ 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>(401, "Unauthorized", ix::HttpErrorCode::Ok, headers, "Not authorized");
+ return std::make_shared<ix::HttpResponse>(HTTP_UNAUTHORIZED, "Unauthorized", ix::HttpErrorCode::Ok, headers, "Not authorized");
}
if (request->method != "POST") {
connectionState->setTerminated();
- return std::make_shared<ix::HttpResponse>(400, "Bad request", ix::HttpErrorCode::Ok, headers, "Bad request");
+ 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));
}
});
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()));
// 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