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.
6 #if defined(HAVE_CONFIG_H)
7 #include "config/bitcoin-config.h"
10 #include "chainparamsbase.h"
11 #include "clientversion.h"
13 #include "rpc/client.h"
14 #include "rpc/protocol.h"
16 #include "utilstrencodings.h"
20 #include <event2/buffer.h>
21 #include <event2/keyvalq_struct.h>
22 #include "support/events.h"
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;
31 std::string
HelpMessageCli()
33 const auto defaultBaseParams
= CreateBaseChainParams(CBaseChainParams::MAIN
);
34 const auto testnetBaseParams
= CreateBaseChainParams(CBaseChainParams::TESTNET
);
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 strUsage
+= HelpMessageOpt("-rpcwallet=<walletname>", _("Send RPC for non-default wallet on RPC server (argument is wallet filename in bitcoind directory, required if bitcoind/-Qt runs with multiple wallets)"));
54 //////////////////////////////////////////////////////////////////////////////
60 // Exception thrown on connection error. This error is used to determine
61 // when to wait if -rpcwait is given.
63 class CConnectionFailed
: public std::runtime_error
67 explicit inline CConnectionFailed(const std::string
& msg
) :
68 std::runtime_error(msg
)
74 // This function returns either one of EXIT_ codes when it's expected to stop the process or
75 // CONTINUE_EXECUTION when it's expected to continue further.
77 static int AppInitRPC(int argc
, char* argv
[])
82 ParseParameters(argc
, argv
);
83 if (argc
<2 || IsArgSet("-?") || IsArgSet("-h") || IsArgSet("-help") || IsArgSet("-version")) {
84 std::string strUsage
= strprintf(_("%s RPC client version"), _(PACKAGE_NAME
)) + " " + FormatFullVersion() + "\n";
85 if (!IsArgSet("-version")) {
86 strUsage
+= "\n" + _("Usage:") + "\n" +
87 " bitcoin-cli [options] <command> [params] " + strprintf(_("Send command to %s"), _(PACKAGE_NAME
)) + "\n" +
88 " bitcoin-cli [options] -named <command> [name=value] ... " + strprintf(_("Send command to %s (with named arguments)"), _(PACKAGE_NAME
)) + "\n" +
89 " bitcoin-cli [options] help " + _("List commands") + "\n" +
90 " bitcoin-cli [options] help <command> " + _("Get help for a command") + "\n";
92 strUsage
+= "\n" + HelpMessageCli();
95 fprintf(stdout
, "%s", strUsage
.c_str());
97 fprintf(stderr
, "Error: too few parameters\n");
102 if (!fs::is_directory(GetDataDir(false))) {
103 fprintf(stderr
, "Error: Specified data directory \"%s\" does not exist.\n", GetArg("-datadir", "").c_str());
107 ReadConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME
));
108 } catch (const std::exception
& e
) {
109 fprintf(stderr
,"Error reading configuration file: %s\n", e
.what());
112 // Check for -testnet or -regtest parameter (BaseParams() calls are only valid after this clause)
114 SelectBaseParams(ChainNameFromCommandLine());
115 } catch (const std::exception
& e
) {
116 fprintf(stderr
, "Error: %s\n", e
.what());
119 if (GetBoolArg("-rpcssl", false))
121 fprintf(stderr
, "Error: SSL mode for RPC (-rpcssl) is no longer supported.\n");
124 return CONTINUE_EXECUTION
;
128 /** Reply structure for request_done to fill in */
131 HTTPReply(): status(0), error(-1) {}
138 const char *http_errorstring(int code
)
141 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
142 case EVREQ_HTTP_TIMEOUT
:
143 return "timeout reached";
145 return "EOF reached";
146 case EVREQ_HTTP_INVALID_HEADER
:
147 return "error while reading header, or invalid header";
148 case EVREQ_HTTP_BUFFER_ERROR
:
149 return "error encountered while reading or writing";
150 case EVREQ_HTTP_REQUEST_CANCEL
:
151 return "request was canceled";
152 case EVREQ_HTTP_DATA_TOO_LONG
:
153 return "response body is larger than allowed";
160 static void http_request_done(struct evhttp_request
*req
, void *ctx
)
162 HTTPReply
*reply
= static_cast<HTTPReply
*>(ctx
);
165 /* If req is NULL, it means an error occurred while connecting: the
166 * error code will have been passed to http_error_cb.
172 reply
->status
= evhttp_request_get_response_code(req
);
174 struct evbuffer
*buf
= evhttp_request_get_input_buffer(req
);
177 size_t size
= evbuffer_get_length(buf
);
178 const char *data
= (const char*)evbuffer_pullup(buf
, size
);
180 reply
->body
= std::string(data
, size
);
181 evbuffer_drain(buf
, size
);
185 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
186 static void http_error_cb(enum evhttp_request_error err
, void *ctx
)
188 HTTPReply
*reply
= static_cast<HTTPReply
*>(ctx
);
193 UniValue
CallRPC(const std::string
& strMethod
, const UniValue
& params
)
196 // In preference order, we choose the following for the port:
198 // 2. port in -rpcconnect (ie following : in ipv4 or ]: in ipv6)
199 // 3. default port for chain
200 int port
= BaseParams().RPCPort();
201 SplitHostPort(GetArg("-rpcconnect", DEFAULT_RPCCONNECT
), port
, host
);
202 port
= GetArg("-rpcport", port
);
205 raii_event_base base
= obtain_event_base();
207 // Synchronously look up hostname
208 raii_evhttp_connection evcon
= obtain_evhttp_connection_base(base
.get(), host
, port
);
209 evhttp_connection_set_timeout(evcon
.get(), GetArg("-rpcclienttimeout", DEFAULT_HTTP_CLIENT_TIMEOUT
));
212 raii_evhttp_request req
= obtain_evhttp_request(http_request_done
, (void*)&response
);
214 throw std::runtime_error("create http request failed");
215 #if LIBEVENT_VERSION_NUMBER >= 0x02010300
216 evhttp_request_set_error_cb(req
.get(), http_error_cb
);
220 std::string strRPCUserColonPass
;
221 if (GetArg("-rpcpassword", "") == "") {
222 // Try fall back to cookie-based authentication if no password is provided
223 if (!GetAuthCookie(&strRPCUserColonPass
)) {
224 throw std::runtime_error(strprintf(
225 _("Could not locate RPC credentials. No authentication cookie could be found, and no rpcpassword is set in the configuration file (%s)"),
226 GetConfigFile(GetArg("-conf", BITCOIN_CONF_FILENAME
)).string().c_str()));
230 strRPCUserColonPass
= GetArg("-rpcuser", "") + ":" + GetArg("-rpcpassword", "");
233 struct evkeyvalq
* output_headers
= evhttp_request_get_output_headers(req
.get());
234 assert(output_headers
);
235 evhttp_add_header(output_headers
, "Host", host
.c_str());
236 evhttp_add_header(output_headers
, "Connection", "close");
237 evhttp_add_header(output_headers
, "Authorization", (std::string("Basic ") + EncodeBase64(strRPCUserColonPass
)).c_str());
239 // Attach request data
240 std::string strRequest
= JSONRPCRequestObj(strMethod
, params
, 1).write() + "\n";
241 struct evbuffer
* output_buffer
= evhttp_request_get_output_buffer(req
.get());
242 assert(output_buffer
);
243 evbuffer_add(output_buffer
, strRequest
.data(), strRequest
.size());
245 // check if we should use a special wallet endpoint
246 std::string endpoint
= "/";
247 std::string walletName
= GetArg("-rpcwallet", "");
248 if (!walletName
.empty()) {
249 char *encodedURI
= evhttp_uriencode(walletName
.c_str(), walletName
.size(), false);
251 endpoint
= "/wallet/"+ std::string(encodedURI
);
255 throw CConnectionFailed("uri-encode failed");
258 int r
= evhttp_make_request(evcon
.get(), req
.get(), EVHTTP_REQ_POST
, endpoint
.c_str());
259 req
.release(); // ownership moved to evcon in above call
261 throw CConnectionFailed("send http request failed");
264 event_base_dispatch(base
.get());
266 if (response
.status
== 0)
267 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
));
268 else if (response
.status
== HTTP_UNAUTHORIZED
)
269 throw std::runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
270 else if (response
.status
>= 400 && response
.status
!= HTTP_BAD_REQUEST
&& response
.status
!= HTTP_NOT_FOUND
&& response
.status
!= HTTP_INTERNAL_SERVER_ERROR
)
271 throw std::runtime_error(strprintf("server returned HTTP error %d", response
.status
));
272 else if (response
.body
.empty())
273 throw std::runtime_error("no response from server");
276 UniValue
valReply(UniValue::VSTR
);
277 if (!valReply
.read(response
.body
))
278 throw std::runtime_error("couldn't parse reply from server");
279 const UniValue
& reply
= valReply
.get_obj();
281 throw std::runtime_error("expected reply to have result, error and id properties");
286 int CommandLineRPC(int argc
, char *argv
[])
288 std::string strPrint
;
292 while (argc
> 1 && IsSwitchChar(argv
[1][0])) {
296 std::vector
<std::string
> args
= std::vector
<std::string
>(&argv
[1], &argv
[argc
]);
297 if (GetBoolArg("-stdin", false)) {
298 // Read one arg per line from stdin and append
300 while (std::getline(std::cin
,line
))
301 args
.push_back(line
);
304 throw std::runtime_error("too few parameters (need at least command)");
305 std::string strMethod
= args
[0];
306 args
.erase(args
.begin()); // Remove trailing method name from arguments vector
309 if(GetBoolArg("-named", DEFAULT_NAMED
)) {
310 params
= RPCConvertNamedValues(strMethod
, args
);
312 params
= RPCConvertValues(strMethod
, args
);
315 // Execute and handle connection failures with -rpcwait
316 const bool fWait
= GetBoolArg("-rpcwait", false);
319 const UniValue reply
= CallRPC(strMethod
, params
);
322 const UniValue
& result
= find_value(reply
, "result");
323 const UniValue
& error
= find_value(reply
, "error");
325 if (!error
.isNull()) {
327 int code
= error
["code"].get_int();
328 if (fWait
&& code
== RPC_IN_WARMUP
)
329 throw CConnectionFailed("server in warmup");
330 strPrint
= "error: " + error
.write();
332 if (error
.isObject())
334 UniValue errCode
= find_value(error
, "code");
335 UniValue errMsg
= find_value(error
, "message");
336 strPrint
= errCode
.isNull() ? "" : "error code: "+errCode
.getValStr()+"\n";
339 strPrint
+= "error message:\n"+errMsg
.get_str();
341 if (errCode
.isNum() && errCode
.get_int() == RPC_WALLET_NOT_SPECIFIED
) {
342 strPrint
+= "\nTry adding \"-rpcwallet=<filename>\" option to bitcoin-cli command line.";
349 else if (result
.isStr())
350 strPrint
= result
.get_str();
352 strPrint
= result
.write(2);
354 // Connection succeeded, no need to retry.
357 catch (const CConnectionFailed
&) {
365 catch (const boost::thread_interrupted
&) {
368 catch (const std::exception
& e
) {
369 strPrint
= std::string("error: ") + e
.what();
373 PrintExceptionContinue(NULL
, "CommandLineRPC()");
377 if (strPrint
!= "") {
378 fprintf((nRet
== 0 ? stdout
: stderr
), "%s\n", strPrint
.c_str());
383 int main(int argc
, char* argv
[])
386 if (!SetupNetworking()) {
387 fprintf(stderr
, "Error: Initializing networking failed\n");
392 int ret
= AppInitRPC(argc
, argv
);
393 if (ret
!= CONTINUE_EXECUTION
)
396 catch (const std::exception
& e
) {
397 PrintExceptionContinue(&e
, "AppInitRPC()");
400 PrintExceptionContinue(NULL
, "AppInitRPC()");
404 int ret
= EXIT_FAILURE
;
406 ret
= CommandLineRPC(argc
, argv
);
408 catch (const std::exception
& e
) {
409 PrintExceptionContinue(&e
, "CommandLineRPC()");
411 PrintExceptionContinue(NULL
, "CommandLineRPC()");