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 <rpc/server.h>
9
10#include <common/args.h>
11#include <common/system.h>
12#include <logging.h>
13#include <node/context.h>
14#include <rpc/protocol.h>
15#include <rpc/server_util.h>
16#include <rpc/util.h>
17#include <sync.h>
18#include <tinyformat.h>
19#include <util/check.h>
20#include <util/fs.h>
21#include <util/overloaded.h>
22#include <util/strencodings.h>
23#include <util/string.h>
24#include <util/time.h>
25
26#include <algorithm>
27#include <atomic>
28#include <cstddef>
29#include <exception>
30#include <list>
31#include <mutex>
32#include <optional>
33#include <set>
34#include <span>
35#include <string_view>
36#include <unordered_map>
37#include <unordered_set>
38#include <variant>
39
40using util::SplitString;
41
42static GlobalMutex g_rpc_warmup_mutex;
43static std::atomic<bool> g_rpc_running{false};
44static bool fRPCInWarmup GUARDED_BY(g_rpc_warmup_mutex) = true;
45static std::string rpcWarmupStatus GUARDED_BY(g_rpc_warmup_mutex) = "RPC server started";
46static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& request, UniValue& result, bool last_handler);
47
48struct RPCCommandExecutionInfo
49{
50    std::string method;
51    SteadyClock::time_point start;
52};
53
54struct RPCServerInfo
55{
56    Mutex mutex;
57    std::list<RPCCommandExecutionInfo> active_commands GUARDED_BY(mutex);
58};
59
60static RPCServerInfo g_rpc_server_info;
61
62struct RPCCommandExecution
63{
64    std::list<RPCCommandExecutionInfo>::iterator it;
65    explicit RPCCommandExecution(const std::string& method)
66    {
67        LOCK(g_rpc_server_info.mutex);
68        it = g_rpc_server_info.active_commands.insert(g_rpc_server_info.active_commands.end(), {method, SteadyClock::now()});
69    }
70    ~RPCCommandExecution()
71    {
72        LOCK(g_rpc_server_info.mutex);
73        g_rpc_server_info.active_commands.erase(it);
74    }
75};
76
77std::string CRPCTable::help(std::string_view strCommand, const JSONRPCRequest& helpreq) const
78{
79    std::string strRet;
80    std::string category;
81    std::set<intptr_t> setDone;
82    std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
83    vCommands.reserve(mapCommands.size());
84
85    for (const auto& entry : mapCommands)
86        vCommands.emplace_back(entry.second.front()->category + entry.first, entry.second.front());
87    std::ranges::sort(vCommands);
88
89    JSONRPCRequest jreq = helpreq;
90    jreq.mode = JSONRPCRequest::GET_HELP;
91    jreq.params = UniValue();
92
93    for (const auto& [_, pcmd] : vCommands) {
94        std::string strMethod = pcmd->name;
95        if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
96            continue;
97        jreq.strMethod = strMethod;
98        try
99        {
100            UniValue unused_result;
101            if (setDone.insert(pcmd->unique_id).second)
102                pcmd->actor(jreq, unused_result, /*last_handler=*/true);
103        } catch (const HelpResult& e) {
104            std::string strHelp{e.what()};
105            if (strCommand == "")
106            {
107                if (strHelp.find('\n') != std::string::npos)
108                    strHelp = strHelp.substr(0, strHelp.find('\n'));
109
110                if (category != pcmd->category)
111                {
112                    if (!category.empty())
113                        strRet += "\n";
114                    category = pcmd->category;
115                    strRet += "== " + Capitalize(category) + " ==\n";
116                }
117            }
118            strRet += strHelp + "\n";
119        }
120    }
121    if (strRet == "")
122        strRet = strprintf("help: unknown command: %s\n", strCommand);
123    strRet = strRet.substr(0,strRet.size()-1);
124    return strRet;
125}
126
127static RPCMethod help()
128{
129    return RPCMethod{
130        "help",
131        "List all commands, or get help for a specified command.\n",
132        {
133            {"command", RPCArg::Type::STR, RPCArg::DefaultHint{"all commands"}, "The command to get help on"},
134        },
135        {
136            RPCResult{RPCResult::Type::STR, "", "The help text"},
137            RPCResult{RPCResult::Type::ANY, "", "The command conversions. (Hidden in dump_all_command_conversions)", /*inner=*/{},
138                      RPCResultOptions{
139                          .print_elision = HelpElisionSkip{},
140                      }},
141        },
142        RPCExamples{""},
143        [](const RPCMethod& self, const JSONRPCRequest& jsonRequest) -> UniValue
144        {
145            auto command{self.MaybeArg<std::string_view>("command")};
146            if (command == "dump_all_command_conversions") {
147                // Used for testing only, undocumented
148                return tableRPC.dumpArgMap(jsonRequest);
149            }
150
151            return tableRPC.help(command.value_or(""), jsonRequest);
152        },
153    };
154}
155
156static RPCMethod stop()
157{
158    static const std::string RESULT{CLIENT_NAME " stopping"};
159    return RPCMethod{
160        "stop",
161    // Also accept the hidden 'wait' integer argument (milliseconds)
162    // For instance, 'stop 1000' makes the call wait 1 second before returning
163    // to the client (intended for testing)
164        "Request a graceful shutdown of " CLIENT_NAME ".",
165                {
166                    {"wait", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "how long to wait in ms", RPCArgOptions{.hidden=true}},
167                },
168                RPCResult{RPCResult::Type::STR, "", "A string with the content '" + RESULT + "'"},
169                RPCExamples{""},
170        [](const RPCMethod& self, const JSONRPCRequest& jsonRequest) -> UniValue
171{
172    // Event loop will exit after current HTTP requests have been handled, so
173    // this reply will get back to the client.
174    CHECK_NONFATAL((CHECK_NONFATAL(EnsureAnyNodeContext(jsonRequest.context).shutdown_request))());
175    if (jsonRequest.params[0].isNum()) {
176        UninterruptibleSleep(std::chrono::milliseconds{jsonRequest.params[0].getInt<int>()});
177    }
178    return RESULT;
179},
180    };
181}
182
183static RPCMethod uptime()
184{
185    return RPCMethod{
186        "uptime",
187        "Returns the total uptime of the server.\n",
188                            {},
189                            RPCResult{
190                                RPCResult::Type::NUM, "", "The number of seconds that the server has been running"
191                            },
192                RPCExamples{
193                    HelpExampleCli("uptime", "")
194                + HelpExampleRpc("uptime", "")
195                },
196        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
197{
198    return TicksSeconds(GetUptime());
199}
200    };
201}
202
203static RPCMethod getrpcinfo()
204{
205    return RPCMethod{
206        "getrpcinfo",
207        "Returns details of the RPC server.\n",
208                {},
209                RPCResult{
210                    RPCResult::Type::OBJ, "", "",
211                    {
212                        {RPCResult::Type::ARR, "active_commands", "All active commands",
213                        {
214                            {RPCResult::Type::OBJ, "", "Information about an active command",
215                            {
216                                 {RPCResult::Type::STR, "method", "The name of the RPC command"},
217                                 {RPCResult::Type::NUM, "duration", "The running time in microseconds"},
218                            }},
219                        }},
220                        {RPCResult::Type::STR, "logpath", "The complete file path to the debug log"},
221                    }
222                },
223                RPCExamples{
224                    HelpExampleCli("getrpcinfo", "")
225                + HelpExampleRpc("getrpcinfo", "")},
226        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
227{
228    LOCK(g_rpc_server_info.mutex);
229    UniValue active_commands(UniValue::VARR);
230    for (const RPCCommandExecutionInfo& info : g_rpc_server_info.active_commands) {
231        UniValue entry(UniValue::VOBJ);
232        entry.pushKV("method", info.method);
233        entry.pushKV("duration", Ticks<std::chrono::microseconds>(SteadyClock::now() - info.start));
234        active_commands.push_back(std::move(entry));
235    }
236
237    UniValue result(UniValue::VOBJ);
238    result.pushKV("active_commands", std::move(active_commands));
239
240    const std::string path = LogInstance().m_file_path.utf8string();
241    UniValue log_path(UniValue::VSTR, path);
242    result.pushKV("logpath", std::move(log_path));
243
244    return result;
245}
246    };
247}
248
249namespace {
250UniValue OpenRPCArgSchema(const RPCArg& arg, bool include_hidden, bool in_skip_type_check);