Branch data Line data Source code
1 : : // Copyright (c) 2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present 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 : : #include <bitcoin-build-config.h> // IWYU pragma: keep
7 : :
8 : : #include <chainparams.h>
9 : : #include <httpserver.h>
10 : : #include <index/blockfilterindex.h>
11 : : #include <index/coinstatsindex.h>
12 : : #include <index/txindex.h>
13 : : #include <interfaces/chain.h>
14 : : #include <interfaces/echo.h>
15 : : #include <interfaces/init.h>
16 : : #include <interfaces/ipc.h>
17 : : #include <kernel/cs_main.h>
18 : : #include <logging.h>
19 : : #include <node/context.h>
20 : : #include <rpc/server.h>
21 : : #include <rpc/server_util.h>
22 : : #include <rpc/util.h>
23 : : #include <scheduler.h>
24 : : #include <tinyformat.h>
25 : : #include <univalue.h>
26 : : #include <util/any.h>
27 : : #include <util/check.h>
28 : : #include <util/time.h>
29 : :
30 : : #include <cstdint>
31 : : #ifdef HAVE_MALLOC_INFO
32 : : #include <malloc.h>
33 : : #endif
34 : : #include <string_view>
35 : :
36 : : using node::NodeContext;
37 : :
38 : 88 : static RPCHelpMan setmocktime()
39 : : {
40 : 88 : return RPCHelpMan{
41 : 88 : "setmocktime",
42 [ + - ]: 176 : "Set the local time to given timestamp (-regtest only)\n",
43 : : {
44 [ + - ]: 176 : {"timestamp", RPCArg::Type::NUM, RPCArg::Optional::NO, UNIX_EPOCH_TIME + "\n"
45 [ + - ]: 88 : "Pass 0 to go back to using the system time."},
46 : : },
47 [ + - + - : 176 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - + - ]
48 [ + - + - ]: 264 : RPCExamples{""},
49 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
50 : : {
51 [ # # ]: 0 : if (!Params().IsMockableChain()) {
52 [ # # ]: 0 : throw std::runtime_error("setmocktime is for regression testing (-regtest mode) only");
53 : : }
54 : :
55 : : // For now, don't change mocktime if we're in the middle of validation, as
56 : : // this could have an effect on mempool time-based eviction, as well as
57 : : // IsCurrentForFeeEstimation() and IsInitialBlockDownload().
58 : : // TODO: figure out the right way to synchronize around mocktime, and
59 : : // ensure all call sites of GetTime() are accessing this safely.
60 : 0 : LOCK(cs_main);
61 : :
62 [ # # # # ]: 0 : const int64_t time{request.params[0].getInt<int64_t>()};
63 : 0 : constexpr int64_t max_time{Ticks<std::chrono::seconds>(std::chrono::nanoseconds::max())};
64 [ # # ]: 0 : if (time < 0 || time > max_time) {
65 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Mocktime must be in the range [0, %s], not %s.", max_time, time));
66 : : }
67 : :
68 [ # # ]: 0 : SetMockTime(time);
69 [ # # ]: 0 : const NodeContext& node_context{EnsureAnyNodeContext(request.context)};
70 [ # # ]: 0 : for (const auto& chain_client : node_context.chain_clients) {
71 [ # # ]: 0 : chain_client->setMockTime(time);
72 : : }
73 : :
74 [ # # ]: 0 : return UniValue::VNULL;
75 : 0 : },
76 [ + - + - : 440 : };
+ + - - ]
77 [ + - ]: 176 : }
78 : :
79 : 88 : static RPCHelpMan mockscheduler()
80 : : {
81 : 88 : return RPCHelpMan{
82 : 88 : "mockscheduler",
83 [ + - ]: 176 : "Bump the scheduler into the future (-regtest only)\n",
84 : : {
85 [ + - + - ]: 176 : {"delta_time", RPCArg::Type::NUM, RPCArg::Optional::NO, "Number of seconds to forward the scheduler into the future." },
86 : : },
87 [ + - + - : 176 : RPCResult{RPCResult::Type::NONE, "", ""},
+ - + - ]
88 [ + - + - ]: 264 : RPCExamples{""},
89 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
90 : : {
91 [ # # ]: 0 : if (!Params().IsMockableChain()) {
92 [ # # ]: 0 : throw std::runtime_error("mockscheduler is for regression testing (-regtest mode) only");
93 : : }
94 : :
95 : 0 : int64_t delta_seconds = request.params[0].getInt<int64_t>();
96 [ # # ]: 0 : if (delta_seconds <= 0 || delta_seconds > 3600) {
97 [ # # ]: 0 : throw std::runtime_error("delta_time must be between 1 and 3600 seconds (1 hr)");
98 : : }
99 : :
100 : 0 : const NodeContext& node_context{EnsureAnyNodeContext(request.context)};
101 : 0 : CHECK_NONFATAL(node_context.scheduler)->MockForward(std::chrono::seconds{delta_seconds});
102 : 0 : CHECK_NONFATAL(node_context.validation_signals)->SyncWithValidationInterfaceQueue();
103 [ # # ]: 0 : for (const auto& chain_client : node_context.chain_clients) {
104 : 0 : chain_client->schedulerMockForward(std::chrono::seconds(delta_seconds));
105 : : }
106 : :
107 : 0 : return UniValue::VNULL;
108 : : },
109 [ + - + - : 440 : };
+ + - - ]
110 [ + - ]: 176 : }
111 : :
112 : 0 : static UniValue RPCLockedMemoryInfo()
113 : : {
114 : 0 : LockedPool::Stats stats = LockedPoolManager::Instance().stats();
115 : 0 : UniValue obj(UniValue::VOBJ);
116 [ # # # # : 0 : obj.pushKV("used", uint64_t(stats.used));
# # ]
117 [ # # # # : 0 : obj.pushKV("free", uint64_t(stats.free));
# # ]
118 [ # # # # : 0 : obj.pushKV("total", uint64_t(stats.total));
# # ]
119 [ # # # # : 0 : obj.pushKV("locked", uint64_t(stats.locked));
# # ]
120 [ # # # # : 0 : obj.pushKV("chunks_used", uint64_t(stats.chunks_used));
# # ]
121 [ # # # # : 0 : obj.pushKV("chunks_free", uint64_t(stats.chunks_free));
# # ]
122 : 0 : return obj;
123 : 0 : }
124 : :
125 : : #ifdef HAVE_MALLOC_INFO
126 : 0 : static std::string RPCMallocInfo()
127 : : {
128 : 0 : char *ptr = nullptr;
129 : 0 : size_t size = 0;
130 : 0 : FILE *f = open_memstream(&ptr, &size);
131 [ # # ]: 0 : if (f) {
132 : 0 : malloc_info(0, f);
133 : 0 : fclose(f);
134 [ # # ]: 0 : if (ptr) {
135 : 0 : std::string rv(ptr, size);
136 : 0 : free(ptr);
137 : 0 : return rv;
138 : : }
139 : : }
140 : 0 : return "";
141 : : }
142 : : #endif
143 : :
144 : 88 : static RPCHelpMan getmemoryinfo()
145 : : {
146 : : /* Please, avoid using the word "pool" here in the RPC interface or help,
147 : : * as users will undoubtedly confuse it with the other "memory pool"
148 : : */
149 : 88 : return RPCHelpMan{"getmemoryinfo",
150 [ + - ]: 176 : "Returns an object containing information about memory usage.\n",
151 : : {
152 [ + - + - : 264 : {"mode", RPCArg::Type::STR, RPCArg::Default{"stats"}, "determines what kind of information is returned.\n"
+ - ]
153 : : " - \"stats\" returns general statistics about memory usage in the daemon.\n"
154 : : " - \"mallocinfo\" returns an XML string describing low-level heap state (only available if compiled with glibc)."},
155 : : },
156 : : {
157 [ + - ]: 88 : RPCResult{"mode \"stats\"",
158 [ + - + - ]: 176 : RPCResult::Type::OBJ, "", "",
159 : : {
160 [ + - + - ]: 176 : {RPCResult::Type::OBJ, "locked", "Information about locked memory manager",
161 : : {
162 [ + - + - ]: 176 : {RPCResult::Type::NUM, "used", "Number of bytes used"},
163 [ + - + - ]: 176 : {RPCResult::Type::NUM, "free", "Number of bytes available in current arenas"},
164 [ + - + - ]: 176 : {RPCResult::Type::NUM, "total", "Total number of bytes managed"},
165 [ + - + - ]: 176 : {RPCResult::Type::NUM, "locked", "Amount of bytes that succeeded locking. If this number is smaller than total, locking pages failed at some point and key data could be swapped to disk."},
166 [ + - + - ]: 176 : {RPCResult::Type::NUM, "chunks_used", "Number allocated chunks"},
167 [ + - + - ]: 176 : {RPCResult::Type::NUM, "chunks_free", "Number unused chunks"},
168 : : }},
169 : : }
170 [ + - + - : 1320 : },
+ + + + -
- - - ]
171 [ + - ]: 176 : RPCResult{"mode \"mallocinfo\"",
172 [ + - + - ]: 176 : RPCResult::Type::STR, "", "\"<malloc version=\"1\">...\""
173 : 88 : },
174 : : },
175 : 88 : RPCExamples{
176 [ + - + - : 176 : HelpExampleCli("getmemoryinfo", "")
+ - ]
177 [ + - + - : 352 : + HelpExampleRpc("getmemoryinfo", "")
+ - ]
178 [ + - ]: 88 : },
179 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
180 : : {
181 : 0 : auto mode{self.Arg<std::string_view>("mode")};
182 [ # # ]: 0 : if (mode == "stats") {
183 : 0 : UniValue obj(UniValue::VOBJ);
184 [ # # # # : 0 : obj.pushKV("locked", RPCLockedMemoryInfo());
# # ]
185 : 0 : return obj;
186 [ # # ]: 0 : } else if (mode == "mallocinfo") {
187 : : #ifdef HAVE_MALLOC_INFO
188 [ # # ]: 0 : return RPCMallocInfo();
189 : : #else
190 : : throw JSONRPCError(RPC_INVALID_PARAMETER, "mallocinfo mode not available");
191 : : #endif
192 : : } else {
193 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, tfm::format("unknown mode %s", mode));
194 : : }
195 : : },
196 [ + - + - : 880 : };
+ - + - +
+ + + - -
- - ]
197 [ + - + - : 968 : }
+ - + - +
- + - + -
+ - + - +
- - - -
- ]
198 : :
199 : 0 : static void EnableOrDisableLogCategories(UniValue cats, bool enable) {
200 : 0 : cats = cats.get_array();
201 [ # # # # ]: 0 : for (unsigned int i = 0; i < cats.size(); ++i) {
202 [ # # ]: 0 : std::string cat = cats[i].get_str();
203 : :
204 : 0 : bool success;
205 [ # # ]: 0 : if (enable) {
206 [ # # # # : 0 : success = LogInstance().EnableCategory(cat);
# # ]
207 : : } else {
208 [ # # # # : 0 : success = LogInstance().DisableCategory(cat);
# # ]
209 : : }
210 : :
211 [ # # ]: 0 : if (!success) {
212 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "unknown logging category " + cat);
213 : : }
214 : 0 : }
215 : 0 : }
216 : :
217 : 88 : static RPCHelpMan logging()
218 : : {
219 : 88 : return RPCHelpMan{"logging",
220 : : "Gets and sets the logging configuration.\n"
221 : : "When called without an argument, returns the list of categories with status that are currently being debug logged or not.\n"
222 : : "When called with arguments, adds or removes categories from debug logging and return the lists above.\n"
223 : : "The arguments are evaluated in order \"include\", \"exclude\".\n"
224 : : "If an item is both included and excluded, it will thus end up being excluded.\n"
225 [ + - + - : 176 : "The valid logging categories are: " + LogInstance().LogCategoriesString() + "\n"
+ - ]
226 : : "In addition, the following are available as category names with special meanings:\n"
227 : 88 : " - \"all\", \"1\" : represent all logging categories.\n"
228 : : ,
229 : : {
230 [ + - + - ]: 176 : {"include", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The categories to add to debug logging",
231 : : {
232 [ + - + - ]: 176 : {"include_category", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "the valid logging category"},
233 : : }},
234 [ + - + - ]: 176 : {"exclude", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The categories to remove from debug logging",
235 : : {
236 [ + - + - ]: 176 : {"exclude_category", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "the valid logging category"},
237 : : }},
238 : : },
239 [ + - ]: 176 : RPCResult{
240 [ + - + - ]: 176 : RPCResult::Type::OBJ_DYN, "", "keys are the logging categories, and values indicates its status",
241 : : {
242 [ + - + - ]: 176 : {RPCResult::Type::BOOL, "category", "if being debug logged or not. false:inactive, true:active"},
243 : : }
244 [ + - + - : 264 : },
+ + - - ]
245 : 88 : RPCExamples{
246 [ + - + - : 176 : HelpExampleCli("logging", "\"[\\\"all\\\"]\" \"[\\\"http\\\"]\"")
+ - ]
247 [ + - + - : 352 : + HelpExampleRpc("logging", "[\"all\"], [\"libevent\"]")
+ - + - ]
248 [ + - ]: 88 : },
249 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
250 : : {
251 : 0 : BCLog::CategoryMask original_log_categories = LogInstance().GetCategoryMask();
252 [ # # ]: 0 : if (request.params[0].isArray()) {
253 [ # # ]: 0 : EnableOrDisableLogCategories(request.params[0], true);
254 : : }
255 [ # # ]: 0 : if (request.params[1].isArray()) {
256 [ # # ]: 0 : EnableOrDisableLogCategories(request.params[1], false);
257 : : }
258 [ # # ]: 0 : BCLog::CategoryMask updated_log_categories = LogInstance().GetCategoryMask();
259 : 0 : BCLog::CategoryMask changed_log_categories = original_log_categories ^ updated_log_categories;
260 : :
261 : : // Update libevent logging if BCLog::LIBEVENT has changed.
262 [ # # ]: 0 : if (changed_log_categories & BCLog::LIBEVENT) {
263 : 0 : UpdateHTTPServerLogging(LogInstance().WillLogCategory(BCLog::LIBEVENT));
264 : : }
265 : :
266 : 0 : UniValue result(UniValue::VOBJ);
267 [ # # # # : 0 : for (const auto& logCatActive : LogInstance().LogCategoriesList()) {
# # ]
268 [ # # # # : 0 : result.pushKV(logCatActive.category, logCatActive.active);
# # ]
269 : 0 : }
270 : :
271 : 0 : return result;
272 : 0 : },
273 [ + - + - : 1056 : };
+ - + - +
+ + + + +
- - - - -
- ]
274 [ + - + - : 792 : }
+ - + - +
- - - ]
275 : :
276 : 176 : static RPCHelpMan echo(const std::string& name)
277 : : {
278 [ - + ]: 176 : return RPCHelpMan{
279 : : name,
280 : 176 : "Simply echo back the input arguments. This command is for testing.\n"
281 : : "\nIt will return an internal bug report when arg9='trigger_internal_bug' is passed.\n"
282 : : "\nThe difference between echo and echojson is that echojson has argument conversion enabled in the client-side table in "
283 : : "bitcoin-cli and the GUI. There is no server-side difference.",
284 : : {
285 [ + - + - : 352 : {"arg0", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
286 [ + - + - : 352 : {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
287 [ + - + - : 352 : {"arg2", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
288 [ + - + - : 352 : {"arg3", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
289 [ + - + - : 352 : {"arg4", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
290 [ + - + - : 352 : {"arg5", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
291 [ + - + - : 352 : {"arg6", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
292 [ + - + - : 352 : {"arg7", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
293 [ + - + - : 352 : {"arg8", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
294 [ + - + - : 352 : {"arg9", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "", RPCArgOptions{.skip_type_check = true}},
+ - ]
295 : : },
296 [ + - + - : 352 : RPCResult{RPCResult::Type::ANY, "", "Returns whatever was passed in"},
+ - + - ]
297 [ + - + - ]: 528 : RPCExamples{""},
298 : 176 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
299 : : {
300 [ # # ]: 0 : if (request.params[9].isStr()) {
301 : 0 : CHECK_NONFATAL(request.params[9].get_str() != "trigger_internal_bug");
302 : : }
303 : :
304 : 0 : return request.params;
305 : : },
306 [ + - + - : 2640 : };
+ - + + -
- ]
307 [ + - + - : 1760 : }
+ - + - +
- + - + -
+ - + - +
- - - ]
308 : :
309 [ + - ]: 176 : static RPCHelpMan echo() { return echo("echo"); }
310 [ + - ]: 176 : static RPCHelpMan echojson() { return echo("echojson"); }
311 : :
312 : 88 : static RPCHelpMan echoipc()
313 : : {
314 : 88 : return RPCHelpMan{
315 : 88 : "echoipc",
316 [ + - ]: 176 : "Echo back the input argument, passing it through a spawned process in a multiprocess build.\n"
317 : : "This command is for testing.\n",
318 [ + - + - ]: 176 : {{"arg", RPCArg::Type::STR, RPCArg::Optional::NO, "The string to echo",}},
319 [ + - + - : 176 : RPCResult{RPCResult::Type::STR, "echo", "The echoed string."},
+ - + - ]
320 [ + - + - : 176 : RPCExamples{HelpExampleCli("echo", "\"Hello world\"") +
+ - ]
321 [ + - + - : 352 : HelpExampleRpc("echo", "\"Hello world\"")},
+ - + - +
- ]
322 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
323 : 0 : interfaces::Init& local_init = *EnsureAnyNodeContext(request.context).init;
324 : 0 : std::unique_ptr<interfaces::Echo> echo;
325 [ # # # # ]: 0 : if (interfaces::Ipc* ipc = local_init.ipc()) {
326 : : // Spawn a new bitcoin-node process and call makeEcho to get a
327 : : // client pointer to a interfaces::Echo instance running in
328 : : // that process. This is just for testing. A slightly more
329 : : // realistic test spawning a different executable instead of
330 : : // the same executable would add a new bitcoin-echo executable,
331 : : // and spawn bitcoin-echo below instead of bitcoin-node. But
332 : : // using bitcoin-node avoids the need to build and install a
333 : : // new executable just for this one test.
334 [ # # ]: 0 : auto init = ipc->spawnProcess("bitcoin-node");
335 [ # # ]: 0 : echo = init->makeEcho();
336 [ # # # # ]: 0 : ipc->addCleanup(*echo, [init = init.release()] { delete init; });
337 : 0 : } else {
338 : : // IPC support is not available because this is a bitcoind
339 : : // process not a bitcoind-node process, so just create a local
340 : : // interfaces::Echo object and return it so the `echoipc` RPC
341 : : // method will work, and the python test calling `echoipc`
342 : : // can expect the same result.
343 [ # # ]: 0 : echo = local_init.makeEcho();
344 : : }
345 [ # # # # : 0 : return echo->echo(request.params[0].get_str());
# # # # ]
346 : 0 : },
347 [ + - + - : 440 : };
+ + - - ]
348 [ + - ]: 176 : }
349 : :
350 : 0 : static UniValue SummaryToJSON(const IndexSummary&& summary, std::string index_name)
351 : : {
352 : 0 : UniValue ret_summary(UniValue::VOBJ);
353 [ # # # # ]: 0 : if (!index_name.empty() && index_name != summary.name) return ret_summary;
354 : :
355 : 0 : UniValue entry(UniValue::VOBJ);
356 [ # # # # : 0 : entry.pushKV("synced", summary.synced);
# # ]
357 [ # # # # : 0 : entry.pushKV("best_block_height", summary.best_block_height);
# # ]
358 [ # # # # ]: 0 : ret_summary.pushKV(summary.name, std::move(entry));
359 : 0 : return ret_summary;
360 : 0 : }
361 : :
362 : 88 : static RPCHelpMan getindexinfo()
363 : : {
364 : 88 : return RPCHelpMan{
365 : 88 : "getindexinfo",
366 [ + - ]: 176 : "Returns the status of one or all available indices currently running in the node.\n",
367 : : {
368 [ + - + - ]: 176 : {"index_name", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "Filter results for an index with a specific name."},
369 : : },
370 [ + - ]: 176 : RPCResult{
371 [ + - + - ]: 176 : RPCResult::Type::OBJ_DYN, "", "", {
372 : : {
373 [ + - + - ]: 176 : RPCResult::Type::OBJ, "name", "The name of the index",
374 : : {
375 [ + - + - ]: 176 : {RPCResult::Type::BOOL, "synced", "Whether the index is synced or not"},
376 [ + - + - ]: 176 : {RPCResult::Type::NUM, "best_block_height", "The block height to which the index is synced"},
377 : : }
378 : : },
379 : : },
380 [ + - + - : 616 : },
+ - + + +
+ - - -
- ]
381 : 88 : RPCExamples{
382 [ + - + - : 176 : HelpExampleCli("getindexinfo", "")
+ - ]
383 [ + - + - : 352 : + HelpExampleRpc("getindexinfo", "")
+ - + - ]
384 [ + - + - : 352 : + HelpExampleCli("getindexinfo", "txindex")
+ - + - ]
385 [ + - + - : 352 : + HelpExampleRpc("getindexinfo", "txindex")
+ - + - ]
386 [ + - ]: 88 : },
387 : 88 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
388 : : {
389 : 0 : UniValue result(UniValue::VOBJ);
390 [ # # # # ]: 0 : const std::string index_name{self.MaybeArg<std::string_view>("index_name").value_or("")};
391 : :
392 [ # # ]: 0 : if (g_txindex) {
393 [ # # # # : 0 : result.pushKVs(SummaryToJSON(g_txindex->GetSummary(), index_name));
# # # # ]
394 : : }
395 : :
396 [ # # ]: 0 : if (g_coin_stats_index) {
397 [ # # # # : 0 : result.pushKVs(SummaryToJSON(g_coin_stats_index->GetSummary(), index_name));
# # # # ]
398 : : }
399 : :
400 [ # # ]: 0 : ForEachBlockFilterIndex([&result, &index_name](const BlockFilterIndex& index) {
401 [ # # # # : 0 : result.pushKVs(SummaryToJSON(index.GetSummary(), index_name));
# # # # ]
402 : 0 : });
403 : :
404 : 0 : return result;
405 : 0 : },
406 [ + - + - : 440 : };
+ + - - ]
407 [ + - + - : 440 : }
+ - + - -
- ]
408 : :
409 : 176 : void RegisterNodeRPCCommands(CRPCTable& t)
410 : : {
411 : 176 : static const CRPCCommand commands[]{
412 [ + - ]: 88 : {"control", &getmemoryinfo},
413 [ + - ]: 88 : {"control", &logging},
414 [ + - ]: 88 : {"util", &getindexinfo},
415 [ + - ]: 88 : {"hidden", &setmocktime},
416 [ + - ]: 88 : {"hidden", &mockscheduler},
417 [ + - ]: 88 : {"hidden", &echo},
418 [ + - ]: 88 : {"hidden", &echojson},
419 [ + - ]: 88 : {"hidden", &echoipc},
420 [ + + + - : 528 : };
+ - + - +
- + - + -
+ - + - +
- - - ]
421 [ + + ]: 1584 : for (const auto& c : commands) {
422 : 1408 : t.appendCommand(c.name, &c);
423 : : }
424 : 176 : }
|
