src/bitcoin-cli.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 #if defined(HAVE_CONFIG_H)
   7 #include "config/bitcoin-config.h"
   8 #endif
   9
  10 #include "chainparamsbase.h"
  11 #include "clientversion.h"
  12 #include "fs.h"
  13 #include "rpc/client.h"
  14 #include "rpc/protocol.h"
  15 #include "util.h"
  16 #include "utilstrencodings.h"
  17
  18 #include <stdio.h>
  19
  20 #include <event2/buffer.h>
  21 #include <event2/keyvalq_struct.h>
  22 #include "support/events.h"
  23
  24 #include <univalue.h>
  25
  26 static const char DEFAULT_RPCCONNECT[] = "127.0.0.1";
  27 static const int DEFAULT_HTTP_CLIENT_TIMEOUT=900;
  28 static const bool DEFAULT_NAMED=false;
  29 static const int CONTINUE_EXECUTION=-1;
  30
  31 std::string HelpMessageCli()
  32 {
  33     const auto defaultBaseParams = CreateBaseChainParams(CBaseChainParams::MAIN);
  34     const auto testnetBaseParams = CreateBaseChainParams(CBaseChainParams::TESTNET);
  35     std::string strUsage;
  36     strUsage += HelpMessageGroup(_("Options:"));
  37     strUsage += HelpMessageOpt("-?", _("This help message"));
  38     strUsage += HelpMessageOpt("-conf=<file>", strprintf(_("Specify configuration file (default: %s)"), BITCOIN_CONF_FILENAME));
  39     strUsage += HelpMessageOpt("-datadir=<dir>", _("Specify data directory"));
  40     AppendParamsHelpMessages(strUsage);
  41     strUsage += HelpMessageOpt("-named", strprintf(_("Pass named instead of positional arguments (default: %s)"), DEFAULT_NAMED));
  42     strUsage += HelpMessageOpt("-rpcconnect=<ip>", strprintf(_("Send commands to node running on <ip> (default: %s)"), DEFAULT_RPCCONNECT));
  43     strUsage += HelpMessageOpt("-rpcport=<port>", strprintf(_("Connect to JSON-RPC on <port> (default: %u or testnet: %u)"), defaultBaseParams->RPCPort(), testnetBaseParams->RPCPort()));
  44     strUsage += HelpMessageOpt("-rpcwait", _("Wait for RPC server to start"));
  45     strUsage += HelpMessageOpt("-rpcuser=<user>", _("Username for JSON-RPC connections"));
  46     strUsage += HelpMessageOpt("-rpcpassword=<pw>", _("Password for JSON-RPC connections"));
  47     strUsage += HelpMessageOpt("-rpcclienttimeout=<n>", strprintf(_("Timeout in seconds during HTTP requests, or 0 for no timeout. (default: %d)"), DEFAULT_HTTP_CLIENT_TIMEOUT));
  48     strUsage += HelpMessageOpt("-stdin", _("Read extra arguments from standard input, one per line until EOF/Ctrl-D (recommended for sensitive information such as passphrases)"));
  49
  50     return strUsage;
  51 }
  52
  53 //////////////////////////////////////////////////////////////////////////////
  54 //
  55 // Start
  56 //
  57
  58 //
  59 // Exception thrown on connection error.  This error is used to determine
  60 // when to wait if -rpcwait is given.
  61 //
  62 class CConnectionFailed : public std::runtime_error
  63 {
  64 public:
  65
  66     explicit inline CConnectionFailed(const std::string& msg) :
  67         std::runtime_error(msg)
  68     {}
  69
  70 };
  71
  72 //
  73 // This function returns either one of EXIT_ codes when it's expected to stop the process or
  74 // CONTINUE_EXECUTION when it's expected to continue further.
  75 //
  76 static int AppInitRPC(int argc, char* argv[])
  77 {
  78     //
  79     // Parameters
  80     //
  81     ParseParameters(argc, argv);
  82     if (argc<2 || IsArgSet("-?") || IsArgSet("-h") || IsArgSet("-help") || IsArgSet("-version")) {
  83         std::string strUsage = strprintf(_("%s RPC client version"), _(PACKAGE_NAME)) + " " + FormatFullVersion() + "\n";
  84         if (!IsArgSet("-version")) {
  85             strUsage += "\n" + _("Usage:") + "\n" +
  86                   "  bitcoin-cli [options] <command> [params]  " + strprintf(_("Send command to %s"), _(PACKAGE_NAME)) + "\n" +
  87                   "  bitcoin-cli [options] -named <command> [name=value] ... " + strprintf(_("Send command to %s (with named arguments)"), _(PACKAGE_NAME)) + "\n" +
  88                   "  bitcoin-cli [options] help                " + _("List commands") + "\n" +
  89                   "  bitcoin-cli [options] help <command>      " + _("Get help for a command") + "\n";
  90
  91             strUsage += "\n" + HelpMessageCli();
  92         }
  93
  94         fprintf(stdout, "%s", strUsage.c_str());
  95         if (argc < 2) {
  96             fprintf(stderr, "Error: too few parameters\n");
  97             return EXIT_FAILURE;
  98         }
  99         return EXIT_SUCCESS;
 100     }
 101     if (!fs::is_directory(GetDataDir(false))) {
 102         fprintf(stderr, "Error: Specified data directory \"%s\" does not exist.\n", GetArg("-datadir", "").c_str());
 103         return EXIT_FAILURE;
 104     }
 105     try {
 106         ReadConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME));
 107     } catch (const std::exception& e) {
 108         fprintf(stderr,"Error reading configuration file: %s\n", e.what());
 109         return EXIT_FAILURE;
 110     }
 111     // Check for -testnet or -regtest parameter (BaseParams() calls are only valid after this clause)
 112     try {
 113         SelectBaseParams(ChainNameFromCommandLine());
 114     } catch (const std::exception& e) {
 115         fprintf(stderr, "Error: %s\n", e.what());
 116         return EXIT_FAILURE;
 117     }
 118     if (GetBoolArg("-rpcssl", false))
 119     {
 120         fprintf(stderr, "Error: SSL mode for RPC (-rpcssl) is no longer supported.\n");
 121         return EXIT_FAILURE;
 122     }
 123     return CONTINUE_EXECUTION;
 124 }
 125
 126
 127 /** Reply structure for request_done to fill in */
 128 struct HTTPReply
 129 {
 130     HTTPReply(): status(0), error(-1) {}
 131
 132     int status;
 133     int error;
 134     std::string body;
 135 };
 136
 137 const char *http_errorstring(int code)
 138 {
 139     switch(code) {
 140 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
 141     case EVREQ_HTTP_TIMEOUT:
 142         return "timeout reached";
 143     case EVREQ_HTTP_EOF:
 144         return "EOF reached";
 145     case EVREQ_HTTP_INVALID_HEADER:
 146         return "error while reading header, or invalid header";
 147     case EVREQ_HTTP_BUFFER_ERROR:
 148         return "error encountered while reading or writing";
 149     case EVREQ_HTTP_REQUEST_CANCEL:
 150         return "request was canceled";
 151     case EVREQ_HTTP_DATA_TOO_LONG:
 152         return "response body is larger than allowed";
 153 #endif
 154     default:
 155         return "unknown";
 156     }
 157 }
 158
 159 static void http_request_done(struct evhttp_request *req, void *ctx)
 160 {
 161     HTTPReply *reply = static_cast<HTTPReply*>(ctx);
 162
 163     if (req == NULL) {
 164         /* If req is NULL, it means an error occurred while connecting: the
 165          * error code will have been passed to http_error_cb.
 166          */
 167         reply->status = 0;
 168         return;
 169     }
 170
 171     reply->status = evhttp_request_get_response_code(req);
 172
 173     struct evbuffer *buf = evhttp_request_get_input_buffer(req);
 174     if (buf)
 175     {
 176         size_t size = evbuffer_get_length(buf);
 177         const char *data = (const char*)evbuffer_pullup(buf, size);
 178         if (data)
 179             reply->body = std::string(data, size);
 180         evbuffer_drain(buf, size);
 181     }
 182 }
 183
 184 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
 185 static void http_error_cb(enum evhttp_request_error err, void *ctx)
 186 {
 187     HTTPReply *reply = static_cast<HTTPReply*>(ctx);
 188     reply->error = err;
 189 }
 190 #endif
 191
 192 UniValue CallRPC(const std::string& strMethod, const UniValue& params)
 193 {
 194     std::string host;
 195     // In preference order, we choose the following for the port:
 196     //     1. -rpcport
 197     //     2. port in -rpcconnect (ie following : in ipv4 or ]: in ipv6)
 198     //     3. default port for chain
 199     int port = BaseParams().RPCPort();
 200     SplitHostPort(GetArg("-rpcconnect", DEFAULT_RPCCONNECT), port, host);
 201     port = GetArg("-rpcport", port);
 202
 203     // Obtain event base
 204     raii_event_base base = obtain_event_base();
 205
 206     // Synchronously look up hostname
 207     raii_evhttp_connection evcon = obtain_evhttp_connection_base(base.get(), host, port);
 208     evhttp_connection_set_timeout(evcon.get(), GetArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT));
 209
 210     HTTPReply response;
 211     raii_evhttp_request req = obtain_evhttp_request(http_request_done, (void*)&response);
 212     if (req == NULL)
 213         throw std::runtime_error("create http request failed");
 214 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
 215     evhttp_request_set_error_cb(req.get(), http_error_cb);
 216 #endif
 217
 218     // Get credentials
 219     std::string strRPCUserColonPass;
 220     if (GetArg("-rpcpassword", "") == "") {
 221         // Try fall back to cookie-based authentication if no password is provided
 222         if (!GetAuthCookie(&strRPCUserColonPass)) {
 223             throw std::runtime_error(strprintf(
 224                 _("Could not locate RPC credentials. No authentication cookie could be found, and no rpcpassword is set in the configuration file (%s)"),
 225                     GetConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME)).string().c_str()));
 226
 227         }
 228     } else {
 229         strRPCUserColonPass = GetArg("-rpcuser", "") + ":" + GetArg("-rpcpassword", "");
 230     }
 231
 232     struct evkeyvalq* output_headers = evhttp_request_get_output_headers(req.get());
 233     assert(output_headers);
 234     evhttp_add_header(output_headers, "Host", host.c_str());
 235     evhttp_add_header(output_headers, "Connection", "close");
 236     evhttp_add_header(output_headers, "Authorization", (std::string("Basic ") + EncodeBase64(strRPCUserColonPass)).c_str());
 237
 238     // Attach request data
 239     std::string strRequest = JSONRPCRequestObj(strMethod, params, 1).write() + "\n";
 240     struct evbuffer* output_buffer = evhttp_request_get_output_buffer(req.get());
 241     assert(output_buffer);
 242     evbuffer_add(output_buffer, strRequest.data(), strRequest.size());
 243
 244     int r = evhttp_make_request(evcon.get(), req.get(), EVHTTP_REQ_POST, "/");
 245     req.release(); // ownership moved to evcon in above call
 246     if (r != 0) {
 247         throw CConnectionFailed("send http request failed");
 248     }
 249
 250     event_base_dispatch(base.get());
 251
 252     if (response.status == 0)
 253         throw CConnectionFailed(strprintf("couldn't connect to server: %s (code %d)\n(make sure server is running and you are connecting to the correct RPC port)", http_errorstring(response.error), response.error));
 254     else if (response.status == HTTP_UNAUTHORIZED)
 255         throw std::runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
 256     else if (response.status >= 400 && response.status != HTTP_BAD_REQUEST && response.status != HTTP_NOT_FOUND && response.status != HTTP_INTERNAL_SERVER_ERROR)
 257         throw std::runtime_error(strprintf("server returned HTTP error %d", response.status));
 258     else if (response.body.empty())
 259         throw std::runtime_error("no response from server");
 260
 261     // Parse reply
 262     UniValue valReply(UniValue::VSTR);
 263     if (!valReply.read(response.body))
 264         throw std::runtime_error("couldn't parse reply from server");
 265     const UniValue& reply = valReply.get_obj();
 266     if (reply.empty())
 267         throw std::runtime_error("expected reply to have result, error and id properties");
 268
 269     return reply;
 270 }
 271
 272 int CommandLineRPC(int argc, char *argv[])
 273 {
 274     std::string strPrint;
 275     int nRet = 0;
 276     try {
 277         // Skip switches
 278         while (argc > 1 && IsSwitchChar(argv[1][0])) {
 279             argc--;
 280             argv++;
 281         }
 282         std::vector<std::string> args = std::vector<std::string>(&argv[1], &argv[argc]);
 283         if (GetBoolArg("-stdin", false)) {
 284             // Read one arg per line from stdin and append
 285             std::string line;
 286             while (std::getline(std::cin,line))
 287                 args.push_back(line);
 288         }
 289         if (args.size() < 1)
 290             throw std::runtime_error("too few parameters (need at least command)");
 291         std::string strMethod = args[0];
 292         args.erase(args.begin()); // Remove trailing method name from arguments vector
 293
 294         UniValue params;
 295         if(GetBoolArg("-named", DEFAULT_NAMED)) {
 296             params = RPCConvertNamedValues(strMethod, args);
 297         } else {
 298             params = RPCConvertValues(strMethod, args);
 299         }
 300
 301         // Execute and handle connection failures with -rpcwait
 302         const bool fWait = GetBoolArg("-rpcwait", false);
 303         do {
 304             try {
 305                 const UniValue reply = CallRPC(strMethod, params);
 306
 307                 // Parse reply
 308                 const UniValue& result = find_value(reply, "result");
 309                 const UniValue& error  = find_value(reply, "error");
 310
 311                 if (!error.isNull()) {
 312                     // Error
 313                     int code = error["code"].get_int();
 314                     if (fWait && code == RPC_IN_WARMUP)
 315                         throw CConnectionFailed("server in warmup");
 316                     strPrint = "error: " + error.write();
 317                     nRet = abs(code);
 318                     if (error.isObject())
 319                     {
 320                         UniValue errCode = find_value(error, "code");
 321                         UniValue errMsg  = find_value(error, "message");
 322                         strPrint = errCode.isNull() ? "" : "error code: "+errCode.getValStr()+"\n";
 323
 324                         if (errMsg.isStr())
 325                             strPrint += "error message:\n"+errMsg.get_str();
 326                     }
 327                 } else {
 328                     // Result
 329                     if (result.isNull())
 330                         strPrint = "";
 331                     else if (result.isStr())
 332                         strPrint = result.get_str();
 333                     else
 334                         strPrint = result.write(2);
 335                 }
 336                 // Connection succeeded, no need to retry.
 337                 break;
 338             }
 339             catch (const CConnectionFailed&) {
 340                 if (fWait)
 341                     MilliSleep(1000);
 342                 else
 343                     throw;
 344             }
 345         } while (fWait);
 346     }
 347     catch (const boost::thread_interrupted&) {
 348         throw;
 349     }
 350     catch (const std::exception& e) {
 351         strPrint = std::string("error: ") + e.what();
 352         nRet = EXIT_FAILURE;
 353     }
 354     catch (...) {
 355         PrintExceptionContinue(NULL, "CommandLineRPC()");
 356         throw;
 357     }
 358
 359     if (strPrint != "") {
 360         fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
 361     }
 362     return nRet;
 363 }
 364
 365 int main(int argc, char* argv[])
 366 {
 367     SetupEnvironment();
 368     if (!SetupNetworking()) {
 369         fprintf(stderr, "Error: Initializing networking failed\n");
 370         return EXIT_FAILURE;
 371     }
 372
 373     try {
 374         int ret = AppInitRPC(argc, argv);
 375         if (ret != CONTINUE_EXECUTION)
 376             return ret;
 377     }
 378     catch (const std::exception& e) {
 379         PrintExceptionContinue(&e, "AppInitRPC()");
 380         return EXIT_FAILURE;
 381     } catch (...) {
 382         PrintExceptionContinue(NULL, "AppInitRPC()");
 383         return EXIT_FAILURE;
 384     }
 385
 386     int ret = EXIT_FAILURE;
 387     try {
 388         ret = CommandLineRPC(argc, argv);
 389     }
 390     catch (const std::exception& e) {
 391         PrintExceptionContinue(&e, "CommandLineRPC()");
 392     } catch (...) {
 393         PrintExceptionContinue(NULL, "CommandLineRPC()");
 394     }
 395     return ret;
 396 }