Bitcoin Core 30.99.0
P2P Digital Currency
bitcoin.cpp
Go to the documentation of this file.
1// Copyright (c) 2025 The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <bitcoin-build-config.h> // IWYU pragma: keep
6
7#include <clientversion.h>
8#include <common/args.h>
9#include <util/fs.h>
10#include <util/exec.h>
11#include <util/strencodings.h>
12#include <util/translation.h>
13
14#include <iostream>
15#include <string>
16#include <tinyformat.h>
17#include <vector>
18
20
21static constexpr auto HELP_USAGE = R"(Usage: %s [OPTIONS] COMMAND...
22
23Options:
24 -m, --multiprocess Run multiprocess binaries bitcoin-node, bitcoin-gui.
25 -M, --monolithic Run monolithic binaries bitcoind, bitcoin-qt. (Default behavior)
26 -v, --version Show version information
27 -h, --help Show full help message
28
29Commands:
30 gui [ARGS] Start GUI, equivalent to running 'bitcoin-qt [ARGS]' or 'bitcoin-gui [ARGS]'.
31 node [ARGS] Start node, equivalent to running 'bitcoind [ARGS]' or 'bitcoin-node [ARGS]'.
32 rpc [ARGS] Call RPC method, equivalent to running 'bitcoin-cli -named [ARGS]'.
33 wallet [ARGS] Call wallet command, equivalent to running 'bitcoin-wallet [ARGS]'.
34 tx [ARGS] Manipulate hex-encoded transactions, equivalent to running 'bitcoin-tx [ARGS]'.
35 help Show full help message.
36)";
37
38static constexpr auto HELP_FULL = R"(
39Additional less commonly used commands:
40 bench [ARGS] Run bench command, equivalent to running 'bench_bitcoin [ARGS]'.
41 chainstate [ARGS] Run bitcoin kernel chainstate util, equivalent to running 'bitcoin-chainstate [ARGS]'.
42 test [ARGS] Run unit tests, equivalent to running 'test_bitcoin [ARGS]'.
43 test-gui [ARGS] Run GUI unit tests, equivalent to running 'test_bitcoin-qt [ARGS]'.
44)";
45
46static constexpr auto HELP_SHORT = R"(
47Run '%s help' to see additional commands (e.g. for testing and debugging).
48)";
49
51 std::optional<bool> use_multiprocess;
52 bool show_version{false};
53 bool show_help{false};
54 std::string_view command;
55 std::vector<const char*> args;
56};
57
58CommandLine ParseCommandLine(int argc, char* argv[]);
60static void ExecCommand(const std::vector<const char*>& args, std::string_view argv0);
61
62int main(int argc, char* argv[])
63{
64 try {
65 CommandLine cmd{ParseCommandLine(argc, argv)};
66 if (cmd.show_version) {
67 tfm::format(std::cout, "%s version %s\n%s", CLIENT_NAME, FormatFullVersion(), FormatParagraph(LicenseInfo()));
68 return EXIT_SUCCESS;
69 }
70
71 std::string exe_name{fs::PathToString(fs::PathFromString(argv[0]).filename())};
72 std::vector<const char*> args;
73 if (cmd.show_help || cmd.command.empty()) {
74 tfm::format(std::cout, HELP_USAGE, exe_name);
75 if (cmd.show_help) {
76 tfm::format(std::cout, HELP_FULL);
77 return EXIT_SUCCESS;
78 } else {
79 tfm::format(std::cout, HELP_SHORT, exe_name);
80 return EXIT_FAILURE;
81 }
82 } else if (cmd.command == "gui") {
83 args.emplace_back(UseMultiprocess(cmd) ? "bitcoin-gui" : "bitcoin-qt");
84 } else if (cmd.command == "node") {
85 args.emplace_back(UseMultiprocess(cmd) ? "bitcoin-node" : "bitcoind");
86 } else if (cmd.command == "rpc") {
87 args.emplace_back("bitcoin-cli");
88 // Since "bitcoin rpc" is a new interface that doesn't need to be
89 // backward compatible, enable -named by default so it is convenient
90 // for callers to use a mix of named and unnamed parameters. Callers
91 // can override this by specifying -nonamed, but should not need to
92 // unless they are passing string values containing '=' characters
93 // as unnamed parameters.
94 args.emplace_back("-named");
95 } else if (cmd.command == "wallet") {
96 args.emplace_back("bitcoin-wallet");
97 } else if (cmd.command == "tx") {
98 args.emplace_back("bitcoin-tx");
99 } else if (cmd.command == "bench") {
100 args.emplace_back("bench_bitcoin");
101 } else if (cmd.command == "chainstate") {
102 args.emplace_back("bitcoin-chainstate");
103 } else if (cmd.command == "test") {
104 args.emplace_back("test_bitcoin");
105 } else if (cmd.command == "test-gui") {
106 args.emplace_back("test_bitcoin-qt");
107 } else if (cmd.command == "util") {
108 args.emplace_back("bitcoin-util");
109 } else {
110 throw std::runtime_error(strprintf("Unrecognized command: '%s'", cmd.command));
111 }
112 if (!args.empty()) {
113 args.insert(args.end(), cmd.args.begin(), cmd.args.end());
114 ExecCommand(args, argv[0]);
115 }
116 } catch (const std::exception& e) {
117 tfm::format(std::cerr, "Error: %s\nTry '%s --help' for more information.\n", e.what(), argv[0]);
118 return EXIT_FAILURE;
119 }
120 return EXIT_SUCCESS;
121}
122
123CommandLine ParseCommandLine(int argc, char* argv[])
124{
126 cmd.args.reserve(argc);
127 for (int i = 1; i < argc; ++i) {
128 std::string_view arg = argv[i];
129 if (!cmd.command.empty()) {
130 cmd.args.emplace_back(argv[i]);
131 } else if (arg == "-m" || arg == "--multiprocess") {
132 cmd.use_multiprocess = true;
133 } else if (arg == "-M" || arg == "--monolithic") {
134 cmd.use_multiprocess = false;
135 } else if (arg == "-v" || arg == "--version") {
136 cmd.show_version = true;
137 } else if (arg == "-h" || arg == "--help" || arg == "help") {
138 cmd.show_help = true;
139 } else if (arg.starts_with("-")) {
140 throw std::runtime_error(strprintf("Unknown option: %s", arg));
141 } else if (!arg.empty()) {
142 cmd.command = arg;
143 }
144 }
145 return cmd;
146}
147
149{
150 // If -m or -M options were explicitly specified, there is no need to
151 // further parse arguments to determine which to use.
152 if (cmd.use_multiprocess) return *cmd.use_multiprocess;
153
156 std::string error_message;
157 auto argv{cmd.args};
158 argv.insert(argv.begin(), nullptr);
159 if (!args.ParseParameters(argv.size(), argv.data(), error_message)) {
160 tfm::format(std::cerr, "Warning: failed to parse subcommand command line options: %s\n", error_message);
161 }
162 if (!args.ReadConfigFiles(error_message, true)) {
163 tfm::format(std::cerr, "Warning: failed to parse subcommand config: %s\n", error_message);
164 }
166
167 // If any -ipc* options are set these need to be processed by a
168 // multiprocess-capable binary.
169 return args.IsArgSet("-ipcbind") || args.IsArgSet("-ipcconnect") || args.IsArgSet("-ipcfd");
170}
171
184//
190static void ExecCommand(const std::vector<const char*>& args, std::string_view wrapper_argv0)
191{
192 // Construct argument string for execvp
193 std::vector<const char*> exec_args{args};
194 exec_args.emplace_back(nullptr);
195
196 // Try to call ExecVp with given exe path.
197 auto try_exec = [&](fs::path exe_path, bool allow_notfound = true) {
198 std::string exe_path_str{fs::PathToString(exe_path)};
199 exec_args[0] = exe_path_str.c_str();
200 if (util::ExecVp(exec_args[0], (char*const*)exec_args.data()) == -1) {
201 if (allow_notfound && errno == ENOENT) return false;
202 throw std::system_error(errno, std::system_category(), strprintf("execvp failed to execute '%s'", exec_args[0]));
203 }
204 throw std::runtime_error("execvp returned unexpectedly");
205 };
206
207 // Get the wrapper executable path.
208 const fs::path wrapper_path{util::GetExePath(wrapper_argv0)};
209
210 // Try to resolve any symlinks and figure out the directory containing the wrapper executable.
211 std::error_code ec;
212 fs::path wrapper_dir{fs::weakly_canonical(wrapper_path, ec)};
213 if (wrapper_dir.empty()) wrapper_dir = wrapper_path; // Restore previous path if weakly_canonical failed.
214 wrapper_dir = wrapper_dir.parent_path();
215
216 // Get path of the executable to be invoked.
217 const fs::path arg0{fs::PathFromString(args[0])};
218
219 // Decide whether to fall back to the operating system to search for the
220 // specified executable. Avoid doing this if it looks like the wrapper
221 // executable was invoked by path, rather than by search, to avoid
222 // unintentionally launching system executables in a local build.
223 // (https://github.com/bitcoin/bitcoin/pull/31375#discussion_r1861814807)
224 const bool fallback_os_search{!fs::PathFromString(std::string{wrapper_argv0}).has_parent_path()};
225
226 // If wrapper is installed in a bin/ directory, look for target executable
227 // in libexec/
228 (wrapper_dir.filename() == "bin" && try_exec(fs::path{wrapper_dir.parent_path()} / "libexec" / arg0.filename())) ||
229#ifdef WIN32
230 // Otherwise check the "daemon" subdirectory in a windows install.
231 (!wrapper_dir.empty() && try_exec(wrapper_dir / "daemon" / arg0.filename())) ||
232#endif
233 // Otherwise look for target executable next to current wrapper
234 (!wrapper_dir.empty() && try_exec(wrapper_dir / arg0.filename(), fallback_os_search)) ||
235 // Otherwise just look on the system path.
236 (fallback_os_search && try_exec(arg0.filename(), false));
237}
const auto cmd
return EXIT_SUCCESS
int main(int argc, char *argv[])
Definition: bitcoin.cpp:62
static constexpr auto HELP_FULL
Definition: bitcoin.cpp:38
static constexpr auto HELP_SHORT
Definition: bitcoin.cpp:46
static void ExecCommand(const std::vector< const char * > &args, std::string_view argv0)
Execute the specified bitcoind, bitcoin-qt or other command line in args using src,...
Definition: bitcoin.cpp:190
const TranslateFn G_TRANSLATION_FUN
Translate string to current locale using Qt.
Definition: bitcoin.cpp:19
bool UseMultiprocess(const CommandLine &cmd)
Definition: bitcoin.cpp:148
static constexpr auto HELP_USAGE
Definition: bitcoin.cpp:21
CommandLine ParseCommandLine(int argc, char *argv[])
Definition: bitcoin.cpp:123
ArgsManager & args
Definition: bitcoind.cpp:282
@ ALLOW_ANY
disable validation
Definition: args.h:106
std::string GetChainTypeString() const
Returns the appropriate chain type string from the program arguments.
Definition: args.cpp:796
bool ParseParameters(int argc, const char *const argv[], std::string &error)
Definition: args.cpp:179
void SetDefaultFlags(std::optional< unsigned int >)
Set default flags to return for an unknown arg.
Definition: args.cpp:272
void SelectConfigNetwork(const std::string &network)
Select the network in use.
Definition: args.cpp:173
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
Definition: args.cpp:377
bool ReadConfigFiles(std::string &error, bool ignore_invalid_keys=false)
Definition: config.cpp:122
std::string FormatFullVersion()
std::string LicenseInfo()
Returns licensing information (for -version)
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:151
static path PathFromString(const std::string &string)
Convert byte string to path object.
Definition: fs.h:174
void format(std::ostream &out, FormatStringCheck< sizeof...(Args)> fmt, const Args &... args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1079
int ExecVp(const char *file, char *const argv[])
Cross-platform wrapper for POSIX execvp function.
Definition: exec.cpp:21
fs::path GetExePath(std::string_view argv0)
Return path to current executable assuming it was invoked with argv0.
Definition: exec.cpp:40
std::string_view command
Definition: bitcoin.cpp:54
bool show_version
Definition: bitcoin.cpp:52
std::vector< const char * > args
Definition: bitcoin.cpp:55
bool show_help
Definition: bitcoin.cpp:53
std::optional< bool > use_multiprocess
Definition: bitcoin.cpp:51
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
std::function< std::string(const char *)> TranslateFn
Translate a message to the native language of the user.
Definition: translation.h:16
std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
Format a paragraph of text to a fixed width, adding spaces for indentation to any added line.