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