#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>
void ThreadRPCServer3(void* parg);
-static inline unsigned short GetDefaultRPCPort()
+static inline uint16_t GetDefaultRPCPort()
{
return GetBoolArg("-testnet", false) ? 18344 : 8344;
}
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",
+ auto err = strprintf("Expected type %s, got %s",
Value_type_name[t], Value_type_name[v.type()]);
throw JSONRPCError(RPC_TYPE_ERROR, err);
}
const map<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",
+ auto 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);
}
double dAmount = value.get_real();
if (dAmount <= 0.0 || dAmount > MAX_MONEY)
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
- int64_t nAmount = roundint64(dAmount * COIN);
+ auto nAmount = roundint64(dAmount * COIN);
if (!MoneyRange(nAmount))
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
return nAmount;
return (double)amount / (double)COIN;
}
-std::string HexBits(unsigned int nBits)
+string HexBits(uint32_t nBits)
{
union {
- int32_t nBits;
+ uint32_t nBits;
char cBits[4];
} uBits;
- uBits.nBits = htonl((int32_t)nBits);
+ uBits.nBits = htonl(nBits);
return HexStr(BEGIN(uBits.cBits), END(uBits.cBits));
}
-
//
// Utilities: convert hex-encoded Values
// (throws error if not hex).
for (map<string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
{
const CRPCCommand *pcmd = mi->second;
- string strMethod = mi->first;
+ auto strMethod = mi->first;
// We already filter duplicates, but these deprecated screw up the sort order
if (strMethod.find("label") != string::npos)
continue;
catch (std::exception& e)
{
// Help text is returned in an exception
- string strHelp = string(e.what());
+ auto strHelp = string(e.what());
if (strCommand.empty())
if (strHelp.find('\n') != string::npos)
strHelp = strHelp.substr(0, strHelp.find('\n'));
const CRPCCommand *CRPCTable::operator[](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 (*it).second;
<< "Content-Length: " << strMsg.size() << "\r\n"
<< "Connection: close\r\n"
<< "Accept: application/json\r\n";
- BOOST_FOREACH(const PAIRTYPE(string, string)& item, mapRequestHeaders)
+ for(const auto& item : mapRequestHeaders)
s << item.first << ": " << item.second << "\r\n";
s << "\r\n" << strMsg;
string::size_type nColon = str.find(":");
if (nColon != string::npos)
{
- string strHeader = str.substr(0, nColon);
+ auto strHeader = str.substr(0, nColon);
boost::trim(strHeader);
- boost::to_lower(strHeader);
- string strValue = str.substr(nColon+1);
+ transform(strHeader.begin(), strHeader.end(), strHeader.begin(), ::tolower);
+ auto strValue = str.substr(nColon+1);
boost::trim(strValue);
mapHeadersRet[strHeader] = strValue;
if (strHeader == "content-length")
strMessageRet = string(vch.begin(), vch.end());
}
- string sConHdr = mapHeadersRet["connection"];
+ auto sConHdr = mapHeadersRet["connection"];
if ((sConHdr != "close") && (sConHdr != "keep-alive"))
{
bool HTTPAuthorized(map<string, string>& mapHeaders)
{
- string strAuth = mapHeaders["authorization"];
+ auto strAuth = mapHeaders["authorization"];
if (strAuth.substr(0,6) != "Basic ")
return false;
- string strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
- string strUserPass = DecodeBase64(strUserPass64);
+ auto strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
+ auto strUserPass = DecodeBase64(strUserPass64);
return TimingResistantEqual(strUserPass, strRPCUserColonPass);
}
string JSONRPCReply(const Value& result, const Value& error, const Value& id)
{
- Object reply = JSONRPCReplyObj(result, error, id);
+ auto reply = JSONRPCReplyObj(result, error, id);
return write_string(Value(reply), false) + "\n";
}
int code = find_value(objError, "code").get_int();
if (code == RPC_INVALID_REQUEST) nStatus = HTTP_BAD_REQUEST;
else if (code == RPC_METHOD_NOT_FOUND) nStatus = HTTP_NOT_FOUND;
- string strReply = JSONRPCReply(Value::null, objError, id);
+ auto strReply = JSONRPCReply(Value::null, objError, id);
stream << HTTPReply(nStatus, strReply, false) << std::flush;
}
const string strAddress = address.to_string();
const vector<string>& vAllow = mapMultiArgs["-rpcallowip"];
- BOOST_FOREACH(string strAllow, vAllow)
+ for(string strAllow : vAllow)
if (WildcardMatch(strAddress, strAllow))
return true;
return false;
if (filesystem::exists(pathPKFile)) context.use_private_key_file(pathPKFile.string(), ssl::context::pem);
else printf("ThreadRPCServer ERROR: missing server private key file %s\n", pathPKFile.string().c_str());
- string strCiphers = GetArg("-rpcsslciphers", "TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH");
+ auto strCiphers = GetArg("-rpcsslciphers", "TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH");
SSL_CTX_set_cipher_list(context.impl(), strCiphers.c_str());
}
id = find_value(request, "id");
// Parse method
- Value valMethod = find_value(request, "method");
+ auto valMethod = find_value(request, "method");
if (valMethod.type() == null_type)
throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
if (valMethod.type() != str_type)
printf("ThreadRPCServer method=%s\n", strMethod.c_str());
// Parse params
- Value valParams = find_value(request, "params");
+ auto valParams = find_value(request, "params");
if (valParams.type() == array_type)
params = valParams.get_array();
else if (valParams.type() == null_type)
try {
jreq.parse(req);
- Value result = tableRPC.execute(jreq.strMethod, jreq.params);
+ auto result = tableRPC.execute(jreq.strMethod, jreq.params);
rpc_result = JSONRPCReplyObj(result, Value::null, jreq.id);
}
catch (Object& objError)
if (valRequest.type() == obj_type) {
jreq.parse(valRequest);
- Value result = tableRPC.execute(jreq.strMethod, jreq.params);
+ auto result = tableRPC.execute(jreq.strMethod, jreq.params);
// Send reply
strReply = JSONRPCReply(result, Value::null, jreq.id);
throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
// Observe safe mode
- string strWarning = GetWarnings("rpc");
+ auto strWarning = GetWarnings("rpc");
if (!strWarning.empty() && !GetBoolArg("-disablesafemode") &&
!pcmd->okSafeMode)
throw JSONRPCError(RPC_FORBIDDEN_BY_SAFE_MODE, string("Safe mode: ") + strWarning);
asio::ssl::stream<asio::ip::tcp::socket> sslStream(io_service, context);
SSLIOStreamDevice<asio::ip::tcp> d(sslStream, fUseSSL);
iostreams::stream< SSLIOStreamDevice<asio::ip::tcp> > stream(d);
- if (!d.connect(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", itostr(GetDefaultRPCPort()))))
+ if (!d.connect(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", to_string(GetDefaultRPCPort()))))
throw runtime_error("couldn't connect to server");
// HTTP basic authentication
- string strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
+ auto strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
map<string, string> mapRequestHeaders;
mapRequestHeaders["Authorization"] = string("Basic ") + strUserPass64;
// Send request
- string strRequest = JSONRPCRequest(strMethod, params, 1);
- string strPost = HTTPPost(strRequest, mapRequestHeaders);
+ auto strRequest = JSONRPCRequest(strMethod, params, 1);
+ auto strPost = HTTPPost(strRequest, mapRequestHeaders);
stream << strPost << std::flush;
// Receive reply
{
// reinterpret string as unquoted json value
Value value2;
- string strJSON = value.get_str();
+ auto strJSON = value.get_str();
if (!read_string(strJSON, value2))
throw runtime_error(string("Error parsing JSON:")+strJSON);
ConvertTo<T>(value2, fAllowNull);
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();
+ auto n = params.size();
//
// Special case non-string parameter types
// Method
if (argc < 2)
throw runtime_error("too few parameters");
- string strMethod = argv[1];
+ auto strMethod = argv[1];
// Parameters default to strings
std::vector<std::string> strParams(&argv[2], &argv[argc]);
- Array params = RPCConvertValues(strMethod, strParams);
+ auto params = RPCConvertValues(strMethod, strParams);
// Execute
- Object reply = CallRPC(strMethod, params);
+ auto reply = CallRPC(strMethod, params);
// Parse reply
- const Value& result = find_value(reply, "result");
- const Value& error = find_value(reply, "error");
+ const auto& result = find_value(reply, "result");
+ const auto& error = find_value(reply, "error");
if (error.type() != null_type)
{
git://git.novaco.in / novacoin.git / blobdiff