Bitcoin Core 29.99.0
P2P Digital Currency
rpcconsole.cpp
Go to the documentation of this file.
1// Copyright (c) 2011-2022 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 <qt/rpcconsole.h>
8#include <qt/forms/ui_debugwindow.h>
9
10#include <chainparams.h>
11#include <common/system.h>
12#include <interfaces/node.h>
14#include <qt/bantablemodel.h>
15#include <qt/clientmodel.h>
16#include <qt/guiutil.h>
18#include <qt/platformstyle.h>
19#ifdef ENABLE_WALLET
20#include <qt/walletmodel.h>
21#endif // ENABLE_WALLET
22#include <rpc/client.h>
23#include <rpc/server.h>
24#include <util/strencodings.h>
25#include <util/string.h>
26#include <util/time.h>
27#include <util/threadnames.h>
28
29#include <univalue.h>
30
31#include <QAbstractButton>
32#include <QAbstractItemModel>
33#include <QDateTime>
34#include <QFont>
35#include <QKeyEvent>
36#include <QKeySequence>
37#include <QLatin1String>
38#include <QLocale>
39#include <QMenu>
40#include <QMessageBox>
41#include <QScreen>
42#include <QScrollBar>
43#include <QSettings>
44#include <QString>
45#include <QStringList>
46#include <QStyledItemDelegate>
47#include <QTime>
48#include <QTimer>
49#include <QVariant>
50
51#include <chrono>
52
53using util::Join;
54
55const int CONSOLE_HISTORY = 50;
57const QSize FONT_RANGE(4, 40);
58const char fontSizeSettingsKey[] = "consoleFontSize";
59
60const struct {
61 const char *url;
62 const char *source;
63} ICON_MAPPING[] = {
64 {"cmd-request", ":/icons/tx_input"},
65 {"cmd-reply", ":/icons/tx_output"},
66 {"cmd-error", ":/icons/tx_output"},
67 {"misc", ":/icons/tx_inout"},
68 {nullptr, nullptr}
69};
70
71namespace {
72
73// don't add private key handling cmd's to the history
74const QStringList historyFilter = QStringList()
75 << "signmessagewithprivkey"
76 << "signrawtransactionwithkey"
77 << "walletpassphrase"
78 << "walletpassphrasechange"
79 << "encryptwallet";
80
81}
82
83/* Object for executing console RPC commands in a separate thread.
84*/
85class RPCExecutor : public QObject
86{
87 Q_OBJECT
88public:
90
91public Q_SLOTS:
92 void request(const QString &command, const WalletModel* wallet_model);
93
94Q_SIGNALS:
95 void reply(int category, const QString &command);
96
97private:
99};
100
104class QtRPCTimerBase: public QObject, public RPCTimerBase
105{
106 Q_OBJECT
107public:
108 QtRPCTimerBase(std::function<void()>& _func, int64_t millis):
109 func(_func)
110 {
111 timer.setSingleShot(true);
112 connect(&timer, &QTimer::timeout, [this]{ func(); });
113 timer.start(millis);
114 }
115 ~QtRPCTimerBase() = default;
116private:
117 QTimer timer;
118 std::function<void()> func;
119};
120
122{
123public:
125 const char *Name() override { return "Qt"; }
126 RPCTimerBase* NewTimer(std::function<void()>& func, int64_t millis) override
127 {
128 return new QtRPCTimerBase(func, millis);
129 }
130};
131
132class PeerIdViewDelegate : public QStyledItemDelegate
133{
134 Q_OBJECT
135public:
136 explicit PeerIdViewDelegate(QObject* parent = nullptr)
137 : QStyledItemDelegate(parent) {}
138
139 QString displayText(const QVariant& value, const QLocale& locale) const override
140 {
141 // Additional spaces should visually separate right-aligned content
142 // from the next column to the right.
143 return value.toString() + QLatin1String(" ");
144 }
145};
146
147#include <qt/rpcconsole.moc>
148
169bool RPCConsole::RPCParseCommandLine(interfaces::Node* node, std::string &strResult, const std::string &strCommand, const bool fExecute, std::string * const pstrFilteredOut, const WalletModel* wallet_model)
170{
171 std::vector< std::vector<std::string> > stack;
172 stack.emplace_back();
173
174 enum CmdParseState
175 {
176 STATE_EATING_SPACES,
177 STATE_EATING_SPACES_IN_ARG,
178 STATE_EATING_SPACES_IN_BRACKETS,
179 STATE_ARGUMENT,
180 STATE_SINGLEQUOTED,
181 STATE_DOUBLEQUOTED,
182 STATE_ESCAPE_OUTER,
183 STATE_ESCAPE_DOUBLEQUOTED,
184 STATE_COMMAND_EXECUTED,
185 STATE_COMMAND_EXECUTED_INNER
186 } state = STATE_EATING_SPACES;
187 std::string curarg;
188 UniValue lastResult;
189 unsigned nDepthInsideSensitive = 0;
190 size_t filter_begin_pos = 0, chpos;
191 std::vector<std::pair<size_t, size_t>> filter_ranges;
192
193 auto add_to_current_stack = [&](const std::string& strArg) {
194 if (stack.back().empty() && (!nDepthInsideSensitive) && historyFilter.contains(QString::fromStdString(strArg), Qt::CaseInsensitive)) {
195 nDepthInsideSensitive = 1;
196 filter_begin_pos = chpos;
197 }
198 // Make sure stack is not empty before adding something
199 if (stack.empty()) {
200 stack.emplace_back();
201 }
202 stack.back().push_back(strArg);
203 };
204
205 auto close_out_params = [&]() {
206 if (nDepthInsideSensitive) {
207 if (!--nDepthInsideSensitive) {
208 assert(filter_begin_pos);
209 filter_ranges.emplace_back(filter_begin_pos, chpos);
210 filter_begin_pos = 0;
211 }
212 }
213 stack.pop_back();
214 };
215
216 std::string strCommandTerminated = strCommand;
217 if (strCommandTerminated.back() != '\n')
218 strCommandTerminated += "\n";
219 for (chpos = 0; chpos < strCommandTerminated.size(); ++chpos)
220 {
221 char ch = strCommandTerminated[chpos];
222 switch(state)
223 {
224 case STATE_COMMAND_EXECUTED_INNER:
225 case STATE_COMMAND_EXECUTED:
226 {
227 bool breakParsing = true;
228 switch(ch)
229 {
230 case '[': curarg.clear(); state = STATE_COMMAND_EXECUTED_INNER; break;
231 default:
232 if (state == STATE_COMMAND_EXECUTED_INNER)
233 {
234 if (ch != ']')
235 {
236 // append char to the current argument (which is also used for the query command)
237 curarg += ch;
238 break;
239 }
240 if (curarg.size() && fExecute)
241 {
242 // if we have a value query, query arrays with index and objects with a string key
243 UniValue subelement;
244 if (lastResult.isArray())
245 {
246 const auto parsed{ToIntegral<size_t>(curarg)};
247 if (!parsed) {
248 throw std::runtime_error("Invalid result query");
249 }
250 subelement = lastResult[parsed.value()];
251 }
252 else if (lastResult.isObject())
253 subelement = lastResult.find_value(curarg);
254 else
255 throw std::runtime_error("Invalid result query"); //no array or object: abort
256 lastResult = subelement;
257 }
258
259 state = STATE_COMMAND_EXECUTED;
260 break;
261 }
262 // don't break parsing when the char is required for the next argument
263 breakParsing = false;
264
265 // pop the stack and return the result to the current command arguments
266 close_out_params();
267
268 // don't stringify the json in case of a string to avoid doublequotes
269 if (lastResult.isStr())
270 curarg = lastResult.get_str();
271 else
272 curarg = lastResult.write(2);
273
274 // if we have a non empty result, use it as stack argument otherwise as general result
275 if (curarg.size())
276 {
277 if (stack.size())
278 add_to_current_stack(curarg);
279 else
280 strResult = curarg;
281 }
282 curarg.clear();
283 // assume eating space state
284 state = STATE_EATING_SPACES;
285 }
286 if (breakParsing)
287 break;
288 [[fallthrough]];
289 }
290 case STATE_ARGUMENT: // In or after argument
291 case STATE_EATING_SPACES_IN_ARG:
292 case STATE_EATING_SPACES_IN_BRACKETS:
293 case STATE_EATING_SPACES: // Handle runs of whitespace
294 switch(ch)
295 {
296 case '"': state = STATE_DOUBLEQUOTED; break;
297 case '\'': state = STATE_SINGLEQUOTED; break;
298 case '\\': state = STATE_ESCAPE_OUTER; break;
299 case '(': case ')': case '\n':
300 if (state == STATE_EATING_SPACES_IN_ARG)
301 throw std::runtime_error("Invalid Syntax");
302 if (state == STATE_ARGUMENT)
303 {
304 if (ch == '(' && stack.size() && stack.back().size() > 0)
305 {
306 if (nDepthInsideSensitive) {
307 ++nDepthInsideSensitive;
308 }
309 stack.emplace_back();
310 }
311
312 // don't allow commands after executed commands on baselevel
313 if (!stack.size())
314 throw std::runtime_error("Invalid Syntax");
315
316 add_to_current_stack(curarg);
317 curarg.clear();
318 state = STATE_EATING_SPACES_IN_BRACKETS;
319 }
320 if ((ch == ')' || ch == '\n') && stack.size() > 0)
321 {
322 if (fExecute) {
323 // Convert argument list to JSON objects in method-dependent way,
324 // and pass it along with the method name to the dispatcher.
325 UniValue params = RPCConvertValues(stack.back()[0], std::vector<std::string>(stack.back().begin() + 1, stack.back().end()));
326 std::string method = stack.back()[0];
327 std::string uri;
328#ifdef ENABLE_WALLET
329 if (wallet_model) {
330 QByteArray encodedName = QUrl::toPercentEncoding(wallet_model->getWalletName());
331 uri = "/wallet/"+std::string(encodedName.constData(), encodedName.length());
332 }
333#endif
334 assert(node);
335 lastResult = node->executeRpc(method, params, uri);
336 }
337
338 state = STATE_COMMAND_EXECUTED;
339 curarg.clear();
340 }
341 break;
342 case ' ': case ',': case '\t':
343 if(state == STATE_EATING_SPACES_IN_ARG && curarg.empty() && ch == ',')
344 throw std::runtime_error("Invalid Syntax");
345
346 else if(state == STATE_ARGUMENT) // Space ends argument
347 {
348 add_to_current_stack(curarg);
349 curarg.clear();
350 }
351 if ((state == STATE_EATING_SPACES_IN_BRACKETS || state == STATE_ARGUMENT) && ch == ',')
352 {
353 state = STATE_EATING_SPACES_IN_ARG;
354 break;
355 }
356 state = STATE_EATING_SPACES;
357 break;
358 default: curarg += ch; state = STATE_ARGUMENT;
359 }
360 break;
361 case STATE_SINGLEQUOTED: // Single-quoted string
362 switch(ch)
363 {
364 case '\'': state = STATE_ARGUMENT; break;
365 default: curarg += ch;
366 }
367 break;
368 case STATE_DOUBLEQUOTED: // Double-quoted string
369 switch(ch)
370 {
371 case '"': state = STATE_ARGUMENT; break;
372 case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break;
373 default: curarg += ch;
374 }
375 break;
376 case STATE_ESCAPE_OUTER: // '\' outside quotes
377 curarg += ch; state = STATE_ARGUMENT;
378 break;
379 case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
380 if(ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
381 curarg += ch; state = STATE_DOUBLEQUOTED;
382 break;
383 }
384 }
385 if (pstrFilteredOut) {
386 if (STATE_COMMAND_EXECUTED == state) {
387 assert(!stack.empty());
388 close_out_params();
389 }
390 *pstrFilteredOut = strCommand;
391 for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
392 pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
393 }
394 }
395 switch(state) // final state
396 {
397 case STATE_COMMAND_EXECUTED:
398 if (lastResult.isStr())
399 strResult = lastResult.get_str();
400 else
401 strResult = lastResult.write(2);
402 [[fallthrough]];
403 case STATE_ARGUMENT:
404 case STATE_EATING_SPACES:
405 return true;
406 default: // ERROR to end in one of the other states
407 return false;
408 }
409}
410
411void RPCExecutor::request(const QString &command, const WalletModel* wallet_model)
412{
413 try
414 {
415 std::string result;
416 std::string executableCommand = command.toStdString() + "\n";
417
418 // Catch the console-only-help command before RPC call is executed and reply with help text as-if a RPC reply.
419 if(executableCommand == "help-console\n") {
420 Q_EMIT reply(RPCConsole::CMD_REPLY, QString(("\n"
421 "This console accepts RPC commands using the standard syntax.\n"
422 " example: getblockhash 0\n\n"
423
424 "This console can also accept RPC commands using the parenthesized syntax.\n"
425 " example: getblockhash(0)\n\n"
426
427 "Commands may be nested when specified with the parenthesized syntax.\n"
428 " example: getblock(getblockhash(0) 1)\n\n"
429
430 "A space or a comma can be used to delimit arguments for either syntax.\n"
431 " example: getblockhash 0\n"
432 " getblockhash,0\n\n"
433
434 "Named results can be queried with a non-quoted key string in brackets using the parenthesized syntax.\n"
435 " example: getblock(getblockhash(0) 1)[tx]\n\n"
436
437 "Results without keys can be queried with an integer in brackets using the parenthesized syntax.\n"
438 " example: getblock(getblockhash(0),1)[tx][0]\n\n")));
439 return;
440 }
441 if (!RPCConsole::RPCExecuteCommandLine(m_node, result, executableCommand, nullptr, wallet_model)) {
442 Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
443 return;
444 }
445
446 Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
447 }
448 catch (UniValue& objError)
449 {
450 try // Nice formatting for standard-format error
451 {
452 int code = objError.find_value("code").getInt<int>();
453 std::string message = objError.find_value("message").get_str();
454 Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
455 }
456 catch (const std::runtime_error&) // raised when converting to invalid type, i.e. missing code or message
457 { // Show raw JSON object
458 Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(objError.write()));
459 }
460 }
461 catch (const std::exception& e)
462 {
463 Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
464 }
465}
466
467RPCConsole::RPCConsole(interfaces::Node& node, const PlatformStyle *_platformStyle, QWidget *parent) :
468 QWidget(parent),
469 m_node(node),
470 ui(new Ui::RPCConsole),
471 platformStyle(_platformStyle)
472{
473 ui->setupUi(this);
474 QSettings settings;
475#ifdef ENABLE_WALLET
477 // RPCConsole widget is a window.
478 if (!restoreGeometry(settings.value("RPCConsoleWindowGeometry").toByteArray())) {
479 // Restore failed (perhaps missing setting), center the window
480 move(QGuiApplication::primaryScreen()->availableGeometry().center() - frameGeometry().center());
481 }
482 ui->splitter->restoreState(settings.value("RPCConsoleWindowPeersTabSplitterSizes").toByteArray());
483 } else
484#endif // ENABLE_WALLET
485 {
486 // RPCConsole is a child widget.
487 ui->splitter->restoreState(settings.value("RPCConsoleWidgetPeersTabSplitterSizes").toByteArray());
488 }
489
490 m_peer_widget_header_state = settings.value("PeersTabPeerHeaderState").toByteArray();
491 m_banlist_widget_header_state = settings.value("PeersTabBanlistHeaderState").toByteArray();
492
493 constexpr QChar nonbreaking_hyphen(8209);
494 const std::vector<QString> CONNECTION_TYPE_DOC{
495 //: Explanatory text for an inbound peer connection.
496 tr("Inbound: initiated by peer"),
497 /*: Explanatory text for an outbound peer connection that
498 relays all network information. This is the default behavior for
499 outbound connections. */
500 tr("Outbound Full Relay: default"),
501 /*: Explanatory text for an outbound peer connection that relays
502 network information about blocks and not transactions or addresses. */
503 tr("Outbound Block Relay: does not relay transactions or addresses"),
504 /*: Explanatory text for an outbound peer connection that was
505 established manually through one of several methods. The numbered
506 arguments are stand-ins for the methods available to establish
507 manual connections. */
508 tr("Outbound Manual: added using RPC %1 or %2/%3 configuration options")
509 .arg("addnode")
510 .arg(QString(nonbreaking_hyphen) + "addnode")
511 .arg(QString(nonbreaking_hyphen) + "connect"),
512 /*: Explanatory text for a short-lived outbound peer connection that
513 is used to test the aliveness of known addresses. */
514 tr("Outbound Feeler: short-lived, for testing addresses"),
515 /*: Explanatory text for a short-lived outbound peer connection that is used
516 to request addresses from a peer. */
517 tr("Outbound Address Fetch: short-lived, for soliciting addresses")};
518 const QString connection_types_list{"<ul><li>" + Join(CONNECTION_TYPE_DOC, QString("</li><li>")) + "</li></ul>"};
519 ui->peerConnectionTypeLabel->setToolTip(ui->peerConnectionTypeLabel->toolTip().arg(connection_types_list));
520 const std::vector<QString> TRANSPORT_TYPE_DOC{
521 //: Explanatory text for "detecting" transport type.
522 tr("detecting: peer could be v1 or v2"),
523 //: Explanatory text for v1 transport type.
524 tr("v1: unencrypted, plaintext transport protocol"),
525 //: Explanatory text for v2 transport type.
526 tr("v2: BIP324 encrypted transport protocol")};
527 const QString transport_types_list{"<ul><li>" + Join(TRANSPORT_TYPE_DOC, QString("</li><li>")) + "</li></ul>"};
528 ui->peerTransportTypeLabel->setToolTip(ui->peerTransportTypeLabel->toolTip().arg(transport_types_list));
529 const QString hb_list{"<ul><li>\""
530 + ts.to + "\" – " + tr("we selected the peer for high bandwidth relay") + "</li><li>\""
531 + ts.from + "\" – " + tr("the peer selected us for high bandwidth relay") + "</li><li>\""
532 + ts.no + "\" – " + tr("no high bandwidth relay selected") + "</li></ul>"};
533 ui->peerHighBandwidthLabel->setToolTip(ui->peerHighBandwidthLabel->toolTip().arg(hb_list));
534 ui->dataDir->setToolTip(ui->dataDir->toolTip().arg(QString(nonbreaking_hyphen) + "datadir"));
535 ui->blocksDir->setToolTip(ui->blocksDir->toolTip().arg(QString(nonbreaking_hyphen) + "blocksdir"));
536 ui->openDebugLogfileButton->setToolTip(ui->openDebugLogfileButton->toolTip().arg(CLIENT_NAME));
537
539 ui->openDebugLogfileButton->setIcon(platformStyle->SingleColorIcon(":/icons/export"));
540 }
541 ui->clearButton->setIcon(platformStyle->SingleColorIcon(":/icons/remove"));
542
543 ui->fontBiggerButton->setIcon(platformStyle->SingleColorIcon(":/icons/fontbigger"));
544 //: Main shortcut to increase the RPC console font size.
545 ui->fontBiggerButton->setShortcut(tr("Ctrl++"));
546 //: Secondary shortcut to increase the RPC console font size.
547 GUIUtil::AddButtonShortcut(ui->fontBiggerButton, tr("Ctrl+="));
548
549 ui->fontSmallerButton->setIcon(platformStyle->SingleColorIcon(":/icons/fontsmaller"));
550 //: Main shortcut to decrease the RPC console font size.
551 ui->fontSmallerButton->setShortcut(tr("Ctrl+-"));
552 //: Secondary shortcut to decrease the RPC console font size.
553 GUIUtil::AddButtonShortcut(ui->fontSmallerButton, tr("Ctrl+_"));
554
555 ui->promptIcon->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/prompticon")));
556
557 // Install event filter for up and down arrow
558 ui->lineEdit->installEventFilter(this);
559 ui->lineEdit->setMaxLength(16 * 1024 * 1024);
560 ui->messagesWidget->installEventFilter(this);
561
562 connect(ui->hidePeersDetailButton, &QAbstractButton::clicked, this, &RPCConsole::clearSelectedNode);
563 connect(ui->clearButton, &QAbstractButton::clicked, [this] { clear(); });
564 connect(ui->fontBiggerButton, &QAbstractButton::clicked, this, &RPCConsole::fontBigger);
565 connect(ui->fontSmallerButton, &QAbstractButton::clicked, this, &RPCConsole::fontSmaller);
566 connect(ui->btnClearTrafficGraph, &QPushButton::clicked, ui->trafficGraph, &TrafficGraphWidget::clear);
567
568 // disable the wallet selector by default
569 ui->WalletSelector->setVisible(false);
570 ui->WalletSelectorLabel->setVisible(false);
571
572 // Register RPC timer interface
574 // avoid accidentally overwriting an existing, non QTThread
575 // based timer interface
577
580
581 consoleFontSize = settings.value(fontSizeSettingsKey, QFont().pointSize()).toInt();
582 clear();
583
585
587}
588
590{
591 QSettings settings;
592#ifdef ENABLE_WALLET
594 // RPCConsole widget is a window.
595 settings.setValue("RPCConsoleWindowGeometry", saveGeometry());
596 settings.setValue("RPCConsoleWindowPeersTabSplitterSizes", ui->splitter->saveState());
597 } else
598#endif // ENABLE_WALLET
599 {
600 // RPCConsole is a child widget.
601 settings.setValue("RPCConsoleWidgetPeersTabSplitterSizes", ui->splitter->saveState());
602 }
603
604 settings.setValue("PeersTabPeerHeaderState", m_peer_widget_header_state);
605 settings.setValue("PeersTabBanlistHeaderState", m_banlist_widget_header_state);
606
608 delete rpcTimerInterface;
609 delete ui;
610}
611
612bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
613{
614 if(event->type() == QEvent::KeyPress) // Special key handling
615 {
616 QKeyEvent *keyevt = static_cast<QKeyEvent*>(event);
617 int key = keyevt->key();
618 Qt::KeyboardModifiers mod = keyevt->modifiers();
619 switch(key)
620 {
621 case Qt::Key_Up: if(obj == ui->lineEdit) { browseHistory(-1); return true; } break;
622 case Qt::Key_Down: if(obj == ui->lineEdit) { browseHistory(1); return true; } break;
623 case Qt::Key_PageUp: /* pass paging keys to messages widget */
624 case Qt::Key_PageDown:
625 if (obj == ui->lineEdit) {
626 QApplication::sendEvent(ui->messagesWidget, keyevt);
627 return true;
628 }
629 break;
630 case Qt::Key_Return:
631 case Qt::Key_Enter:
632 // forward these events to lineEdit
633 if (obj == autoCompleter->popup()) {
634 QApplication::sendEvent(ui->lineEdit, keyevt);
635 autoCompleter->popup()->hide();
636 return true;
637 }
638 break;
639 default:
640 // Typing in messages widget brings focus to line edit, and redirects key there
641 // Exclude most combinations and keys that emit no text, except paste shortcuts
642 if(obj == ui->messagesWidget && (
643 (!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) ||
644 ((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
645 ((mod & Qt::ShiftModifier) && key == Qt::Key_Insert)))
646 {
647 ui->lineEdit->setFocus();
648 QApplication::sendEvent(ui->lineEdit, keyevt);
649 return true;
650 }
651 }
652 }
653 return QWidget::eventFilter(obj, event);
654}
655
656void RPCConsole::setClientModel(ClientModel *model, int bestblock_height, int64_t bestblock_date, double verification_progress)
657{
658 clientModel = model;
659
660 bool wallet_enabled{false};
661#ifdef ENABLE_WALLET
662 wallet_enabled = WalletModel::isWalletEnabled();
663#endif // ENABLE_WALLET
664 if (model && !wallet_enabled) {
665 // Show warning, for example if this is a prerelease version
668 }
669
670 ui->trafficGraph->setClientModel(model);
672 // Keep up to date with client
675
676 setNumBlocks(bestblock_height, QDateTime::fromSecsSinceEpoch(bestblock_date), verification_progress, SyncType::BLOCK_SYNC);
678
681
683 updateTrafficStats(node.getTotalBytesRecv(), node.getTotalBytesSent());
685
687
688 // set up peer table
689 ui->peerWidget->setModel(model->peerTableSortProxy());
690 ui->peerWidget->verticalHeader()->hide();
691 ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
692 ui->peerWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
693 ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
694
695 if (!ui->peerWidget->horizontalHeader()->restoreState(m_peer_widget_header_state)) {
696 ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH);
697 ui->peerWidget->setColumnWidth(PeerTableModel::Subversion, SUBVERSION_COLUMN_WIDTH);
698 ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
699 }
700 ui->peerWidget->horizontalHeader()->setSectionResizeMode(PeerTableModel::Age, QHeaderView::ResizeToContents);
701 ui->peerWidget->horizontalHeader()->setStretchLastSection(true);
702 ui->peerWidget->setItemDelegateForColumn(PeerTableModel::NetNodeId, new PeerIdViewDelegate(this));
703
704 // create peer table context menu
705 peersTableContextMenu = new QMenu(this);
706 //: Context menu action to copy the address of a peer.
707 peersTableContextMenu->addAction(tr("&Copy address"), [this] {
708 GUIUtil::copyEntryData(ui->peerWidget, PeerTableModel::Address, Qt::DisplayRole);
709 });
710 peersTableContextMenu->addSeparator();
711 peersTableContextMenu->addAction(tr("&Disconnect"), this, &RPCConsole::disconnectSelectedNode);
712 peersTableContextMenu->addAction(ts.ban_for + " " + tr("1 &hour"), [this] { banSelectedNode(60 * 60); });
713 peersTableContextMenu->addAction(ts.ban_for + " " + tr("1 d&ay"), [this] { banSelectedNode(60 * 60 * 24); });
714 peersTableContextMenu->addAction(ts.ban_for + " " + tr("1 &week"), [this] { banSelectedNode(60 * 60 * 24 * 7); });
715 peersTableContextMenu->addAction(ts.ban_for + " " + tr("1 &year"), [this] { banSelectedNode(60 * 60 * 24 * 365); });
716 connect(ui->peerWidget, &QTableView::customContextMenuRequested, this, &RPCConsole::showPeersTableContextMenu);
717
718 // peer table signal handling - update peer details when selecting new node
719 connect(ui->peerWidget->selectionModel(), &QItemSelectionModel::selectionChanged, this, &RPCConsole::updateDetailWidget);
720 connect(model->getPeerTableModel(), &QAbstractItemModel::dataChanged, [this] { updateDetailWidget(); });
721
722 // set up ban table
723 ui->banlistWidget->setModel(model->getBanTableModel());
724 ui->banlistWidget->verticalHeader()->hide();
725 ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
726 ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
727 ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
728
729 if (!ui->banlistWidget->horizontalHeader()->restoreState(m_banlist_widget_header_state)) {
730 ui->banlistWidget->setColumnWidth(BanTableModel::Address, BANSUBNET_COLUMN_WIDTH);
731 ui->banlistWidget->setColumnWidth(BanTableModel::Bantime, BANTIME_COLUMN_WIDTH);
732 }
733 ui->banlistWidget->horizontalHeader()->setSectionResizeMode(BanTableModel::Address, QHeaderView::ResizeToContents);
734 ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
735
736 // create ban table context menu
737 banTableContextMenu = new QMenu(this);
738 /*: Context menu action to copy the IP/Netmask of a banned peer.
739 IP/Netmask is the combination of a peer's IP address and its Netmask.
740 For IP address, see: https://en.wikipedia.org/wiki/IP_address. */
741 banTableContextMenu->addAction(tr("&Copy IP/Netmask"), [this] {
742 GUIUtil::copyEntryData(ui->banlistWidget, BanTableModel::Address, Qt::DisplayRole);
743 });
744 banTableContextMenu->addSeparator();
745 banTableContextMenu->addAction(tr("&Unban"), this, &RPCConsole::unbanSelectedNode);
746 connect(ui->banlistWidget, &QTableView::customContextMenuRequested, this, &RPCConsole::showBanTableContextMenu);
747
748 // ban table signal handling - clear peer details when clicking a peer in the ban table
749 connect(ui->banlistWidget, &QTableView::clicked, this, &RPCConsole::clearSelectedNode);
750 // ban table signal handling - ensure ban table is shown or hidden (if empty)
751 connect(model->getBanTableModel(), &BanTableModel::layoutChanged, this, &RPCConsole::showOrHideBanTableIfRequired);
753
754 // Provide initial values
755 ui->clientVersion->setText(model->formatFullVersion());
756 ui->clientUserAgent->setText(model->formatSubVersion());
757 ui->dataDir->setText(model->dataDir());
758 ui->blocksDir->setText(model->blocksDir());
759 ui->startupTime->setText(model->formatClientStartupTime());
760 ui->networkName->setText(QString::fromStdString(Params().GetChainTypeString()));
761
762 //Setup autocomplete and attach it
763 QStringList wordList;
764 std::vector<std::string> commandList = m_node.listRpcCommands();
765 for (size_t i = 0; i < commandList.size(); ++i)
766 {
767 wordList << commandList[i].c_str();
768 wordList << ("help " + commandList[i]).c_str();
769 }
770
771 wordList << "help-console";
772 wordList.sort();
773 autoCompleter = new QCompleter(wordList, this);
774 autoCompleter->setModelSorting(QCompleter::CaseSensitivelySortedModel);
775 // ui->lineEdit is initially disabled because running commands is only
776 // possible from now on.
777 ui->lineEdit->setEnabled(true);
778 ui->lineEdit->setCompleter(autoCompleter);
779 autoCompleter->popup()->installEventFilter(this);
780 // Start thread to execute RPC commands.
782 }
783 if (!model) {
784 // Client model is being set to 0, this means shutdown() is about to be called.
785 thread.quit();
786 thread.wait();
787 }
788}
789
790#ifdef ENABLE_WALLET
791void RPCConsole::addWallet(WalletModel * const walletModel)
792{
793 // use name for text and wallet model for internal data object (to allow to move to a wallet id later)
794 ui->WalletSelector->addItem(walletModel->getDisplayName(), QVariant::fromValue(walletModel));
795 if (ui->WalletSelector->count() == 2) {
796 // First wallet added, set to default to match wallet RPC behavior
797 ui->WalletSelector->setCurrentIndex(1);
798 }
799 if (ui->WalletSelector->count() > 2) {
800 ui->WalletSelector->setVisible(true);
801 ui->WalletSelectorLabel->setVisible(true);
802 }
803}
804
805void RPCConsole::removeWallet(WalletModel * const walletModel)
806{
807 ui->WalletSelector->removeItem(ui->WalletSelector->findData(QVariant::fromValue(walletModel)));
808 if (ui->WalletSelector->count() == 2) {
809 ui->WalletSelector->setVisible(false);
810 ui->WalletSelectorLabel->setVisible(false);
811 }
812}
813
814void RPCConsole::setCurrentWallet(WalletModel* const wallet_model)
815{
816 QVariant data = QVariant::fromValue(wallet_model);
817 ui->WalletSelector->setCurrentIndex(ui->WalletSelector->findData(data));
818}
819#endif
820
821static QString categoryClass(int category)
822{
823 switch(category)
824 {
825 case RPCConsole::CMD_REQUEST: return "cmd-request"; break;
826 case RPCConsole::CMD_REPLY: return "cmd-reply"; break;
827 case RPCConsole::CMD_ERROR: return "cmd-error"; break;
828 default: return "misc";
829 }
830}
831
833{
835}
836
838{
840}
841
842void RPCConsole::setFontSize(int newSize)
843{
844 QSettings settings;
845
846 //don't allow an insane font size
847 if (newSize < FONT_RANGE.width() || newSize > FONT_RANGE.height())
848 return;
849
850 // temp. store the console content
851 QString str = ui->messagesWidget->toHtml();
852
853 // replace font tags size in current content
854 str.replace(QString("font-size:%1pt").arg(consoleFontSize), QString("font-size:%1pt").arg(newSize));
855
856 // store the new font size
857 consoleFontSize = newSize;
858 settings.setValue(fontSizeSettingsKey, consoleFontSize);
859
860 // clear console (reset icon sizes, default stylesheet) and re-add the content
861 float oldPosFactor = 1.0 / ui->messagesWidget->verticalScrollBar()->maximum() * ui->messagesWidget->verticalScrollBar()->value();
862 clear(/*keep_prompt=*/true);
863 ui->messagesWidget->setHtml(str);
864 ui->messagesWidget->verticalScrollBar()->setValue(oldPosFactor * ui->messagesWidget->verticalScrollBar()->maximum());
865}
866
867void RPCConsole::clear(bool keep_prompt)
868{
869 ui->messagesWidget->clear();
870 if (!keep_prompt) ui->lineEdit->clear();
871 ui->lineEdit->setFocus();
872
873 // Add smoothly scaled icon images.
874 // (when using width/height on an img, Qt uses nearest instead of linear interpolation)
875 for(int i=0; ICON_MAPPING[i].url; ++i)
876 {
877 ui->messagesWidget->document()->addResource(
878 QTextDocument::ImageResource,
879 QUrl(ICON_MAPPING[i].url),
880 platformStyle->SingleColorImage(ICON_MAPPING[i].source).scaled(QSize(consoleFontSize*2, consoleFontSize*2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
881 }
882
883 // Set default style sheet
884#ifdef Q_OS_MACOS
885 QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont(/*use_embedded_font=*/true));
886#else
887 QFontInfo fixedFontInfo(GUIUtil::fixedPitchFont());
888#endif
889 ui->messagesWidget->document()->setDefaultStyleSheet(
890 QString(
891 "table { }"
892 "td.time { color: #808080; font-size: %2; padding-top: 3px; } "
893 "td.message { font-family: %1; font-size: %2; white-space:pre-wrap; } "
894 "td.cmd-request { color: #006060; } "
895 "td.cmd-error { color: red; } "
896 ".secwarning { color: red; }"
897 "b { color: #006060; } "
898 ).arg(fixedFontInfo.family(), QString("%1pt").arg(consoleFontSize))
899 );
900
901 static const QString welcome_message =
902 /*: RPC console welcome message.
903 Placeholders %7 and %8 are style tags for the warning content, and
904 they are not space separated from the rest of the text intentionally. */
905 tr("Welcome to the %1 RPC console.\n"
906 "Use up and down arrows to navigate history, and %2 to clear screen.\n"
907 "Use %3 and %4 to increase or decrease the font size.\n"
908 "Type %5 for an overview of available commands.\n"
909 "For more information on using this console, type %6.\n"
910 "\n"
911 "%7WARNING: Scammers have been active, telling users to type"
912 " commands here, stealing their wallet contents. Do not use this console"
913 " without fully understanding the ramifications of a command.%8")
914 .arg(CLIENT_NAME,
915 "<b>" + ui->clearButton->shortcut().toString(QKeySequence::NativeText) + "</b>",
916 "<b>" + ui->fontBiggerButton->shortcut().toString(QKeySequence::NativeText) + "</b>",
917 "<b>" + ui->fontSmallerButton->shortcut().toString(QKeySequence::NativeText) + "</b>",
918 "<b>help</b>",
919 "<b>help-console</b>",
920 "<span class=\"secwarning\">",
921 "<span>");
922
923 message(CMD_REPLY, welcome_message, true);
924}
925
926void RPCConsole::keyPressEvent(QKeyEvent *event)
927{
928 if (windowType() != Qt::Widget && GUIUtil::IsEscapeOrBack(event->key())) {
929 close();
930 }
931}
932
934{
935 if (e->type() == QEvent::PaletteChange) {
936 ui->clearButton->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/remove")));
937 ui->fontBiggerButton->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/fontbigger")));
938 ui->fontSmallerButton->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/fontsmaller")));
939 ui->promptIcon->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/prompticon")));
940
941 for (int i = 0; ICON_MAPPING[i].url; ++i) {
942 ui->messagesWidget->document()->addResource(
943 QTextDocument::ImageResource,
944 QUrl(ICON_MAPPING[i].url),
945 platformStyle->SingleColorImage(ICON_MAPPING[i].source).scaled(QSize(consoleFontSize * 2, consoleFontSize * 2), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
946 }
947 }
948
949 QWidget::changeEvent(e);
950}
951
952void RPCConsole::message(int category, const QString &message, bool html)
953{
954 QTime time = QTime::currentTime();
955 QString timeString = time.toString();
956 QString out;
957 out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
958 out += "<td class=\"icon\" width=\"32\"><img src=\"" + categoryClass(category) + "\"></td>";
959 out += "<td class=\"message " + categoryClass(category) + "\" valign=\"middle\">";
960 if(html)
961 out += message;
962 else
964 out += "</td></tr></table>";
965 ui->messagesWidget->append(out);
966}
967
969{
970 if (!clientModel) return;
971 QString connections = QString::number(clientModel->getNumConnections()) + " (";
972 connections += tr("In:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
973 connections += tr("Out:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";
974
976 connections += " (" + tr("Network activity disabled") + ")";
977 }
978
979 ui->numberOfConnections->setText(connections);
980
981 QString local_addresses;
982 std::map<CNetAddr, LocalServiceInfo> hosts = clientModel->getNetLocalAddresses();
983 for (const auto& [addr, info] : hosts) {
984 local_addresses += QString::fromStdString(addr.ToStringAddr());
985 if (!addr.IsI2P()) local_addresses += ":" + QString::number(info.nPort);
986 local_addresses += ", ";
987 }
988 local_addresses.chop(2); // remove last ", "
989 if (local_addresses.isEmpty()) local_addresses = tr("None");
990
991 ui->localAddresses->setText(local_addresses);
992}
993
995{
996 if (!clientModel)
997 return;
998
1000}
1001
1002void RPCConsole::setNetworkActive(bool networkActive)
1003{
1005}
1006
1007void RPCConsole::setNumBlocks(int count, const QDateTime& blockDate, double nVerificationProgress, SyncType synctype)
1008{
1009 if (synctype == SyncType::BLOCK_SYNC) {
1010 ui->numberOfBlocks->setText(QString::number(count));
1011 ui->lastBlockTime->setText(blockDate.toString());
1012 }
1013}
1014
1015void RPCConsole::setMempoolSize(long numberOfTxs, size_t dynUsage, size_t maxUsage)
1016{
1017 ui->mempoolNumberTxs->setText(QString::number(numberOfTxs));
1018
1019 const auto cur_usage_str = dynUsage < 1000000 ?
1020 QObject::tr("%1 kB").arg(dynUsage / 1000.0, 0, 'f', 2) :
1021 QObject::tr("%1 MB").arg(dynUsage / 1000000.0, 0, 'f', 2);
1022 const auto max_usage_str = QObject::tr("%1 MB").arg(maxUsage / 1000000.0, 0, 'f', 2);
1023
1024 ui->mempoolSize->setText(cur_usage_str + " / " + max_usage_str);
1025}
1026
1028{
1029 QString cmd = ui->lineEdit->text().trimmed();
1030
1031 if (cmd.isEmpty()) {
1032 return;
1033 }
1034
1035 std::string strFilteredCmd;
1036 try {
1037 std::string dummy;
1038 if (!RPCParseCommandLine(nullptr, dummy, cmd.toStdString(), false, &strFilteredCmd)) {
1039 // Failed to parse command, so we cannot even filter it for the history
1040 throw std::runtime_error("Invalid command line");
1041 }
1042 } catch (const std::exception& e) {
1043 QMessageBox::critical(this, "Error", QString("Error: ") + QString::fromStdString(e.what()));
1044 return;
1045 }
1046
1047 // A special case allows to request shutdown even a long-running command is executed.
1048 if (cmd == QLatin1String("stop")) {
1049 std::string dummy;
1050 RPCExecuteCommandLine(m_node, dummy, cmd.toStdString());
1051 return;
1052 }
1053
1054 if (m_is_executing) {
1055 return;
1056 }
1057
1058 ui->lineEdit->clear();
1059
1060 WalletModel* wallet_model{nullptr};
1061#ifdef ENABLE_WALLET
1062 wallet_model = ui->WalletSelector->currentData().value<WalletModel*>();
1063
1064 if (m_last_wallet_model != wallet_model) {
1065 if (wallet_model) {
1066 message(CMD_REQUEST, tr("Executing command using \"%1\" wallet").arg(wallet_model->getWalletName()));
1067 } else {
1068 message(CMD_REQUEST, tr("Executing command without any wallet"));
1069 }
1070 m_last_wallet_model = wallet_model;
1071 }
1072#endif // ENABLE_WALLET
1073
1074 message(CMD_REQUEST, QString::fromStdString(strFilteredCmd));
1075 //: A console message indicating an entered command is currently being executed.
1076 message(CMD_REPLY, tr("Executing…"));
1077 m_is_executing = true;
1078
1079 QMetaObject::invokeMethod(m_executor, [this, cmd, wallet_model] {
1080 m_executor->request(cmd, wallet_model);
1081 });
1082
1083 cmd = QString::fromStdString(strFilteredCmd);
1084
1085 // Remove command, if already in history
1086 history.removeOne(cmd);
1087 // Append command to history
1088 history.append(cmd);
1089 // Enforce maximum history size
1090 while (history.size() > CONSOLE_HISTORY) {
1091 history.removeFirst();
1092 }
1093 // Set pointer to end of history
1094 historyPtr = history.size();
1095
1096 // Scroll console view to end
1097 scrollToEnd();
1098}
1099
1101{
1102 // store current text when start browsing through the history
1103 if (historyPtr == history.size()) {
1104 cmdBeforeBrowsing = ui->lineEdit->text();
1105 }
1106
1107 historyPtr += offset;
1108 if(historyPtr < 0)
1109 historyPtr = 0;
1110 if(historyPtr > history.size())
1111 historyPtr = history.size();
1112 QString cmd;
1113 if(historyPtr < history.size())
1114 cmd = history.at(historyPtr);
1115 else if (!cmdBeforeBrowsing.isNull()) {
1117 }
1118 ui->lineEdit->setText(cmd);
1119}
1120
1122{
1124 m_executor->moveToThread(&thread);
1125
1126 // Replies from executor object must go to this object
1127 connect(m_executor, &RPCExecutor::reply, this, [this](int category, const QString& command) {
1128 // Remove "Executing…" message.
1129 ui->messagesWidget->undo();
1130 message(category, command);
1131 scrollToEnd();
1132 m_is_executing = false;
1133 });
1134
1135 // Make sure executor object is deleted in its own thread
1136 connect(&thread, &QThread::finished, m_executor, &RPCExecutor::deleteLater);
1137
1138 // Default implementation of QThread::run() simply spins up an event loop in the thread,
1139 // which is what we want.
1140 thread.start();
1141 QTimer::singleShot(0, m_executor, []() {
1142 util::ThreadRename("qt-rpcconsole");
1143 });
1144}
1145
1147{
1148 if (ui->tabWidget->widget(index) == ui->tab_console) {
1149 ui->lineEdit->setFocus();
1150 }
1151}
1152
1154{
1156}
1157
1159{
1160 QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
1161 scrollbar->setValue(scrollbar->maximum());
1162}
1163
1165{
1166 const int multiplier = 5; // each position on the slider represents 5 min
1167 int mins = value * multiplier;
1169}
1170
1172{
1173 ui->trafficGraph->setGraphRange(std::chrono::minutes{mins});
1174 ui->lblGraphRange->setText(GUIUtil::formatDurationStr(std::chrono::minutes{mins}));
1175}
1176
1177void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
1178{
1179 ui->lblBytesIn->setText(GUIUtil::formatBytes(totalBytesIn));
1180 ui->lblBytesOut->setText(GUIUtil::formatBytes(totalBytesOut));
1181}
1182
1184{
1185 const QList<QModelIndex> selected_peers = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
1186 if (!clientModel || !clientModel->getPeerTableModel() || selected_peers.size() != 1) {
1187 ui->peersTabRightPanel->hide();
1188 ui->peerHeading->setText(tr("Select a peer to view detailed information."));
1189 return;
1190 }
1191 const auto stats = selected_peers.first().data(PeerTableModel::StatsRole).value<CNodeCombinedStats*>();
1192 // update the detail ui with latest node information
1193 QString peerAddrDetails(QString::fromStdString(stats->nodeStats.m_addr_name) + " ");
1194 peerAddrDetails += tr("(peer: %1)").arg(QString::number(stats->nodeStats.nodeid));
1195 if (!stats->nodeStats.addrLocal.empty())
1196 peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(stats->nodeStats.addrLocal));
1197 ui->peerHeading->setText(peerAddrDetails);
1198 QString bip152_hb_settings;
1199 if (stats->nodeStats.m_bip152_highbandwidth_to) bip152_hb_settings = ts.to;
1200 if (stats->nodeStats.m_bip152_highbandwidth_from) bip152_hb_settings += (bip152_hb_settings.isEmpty() ? ts.from : QLatin1Char('/') + ts.from);
1201 if (bip152_hb_settings.isEmpty()) bip152_hb_settings = ts.no;
1202 ui->peerHighBandwidth->setText(bip152_hb_settings);
1203 const auto time_now{GetTime<std::chrono::seconds>()};
1204 ui->peerConnTime->setText(GUIUtil::formatDurationStr(time_now - stats->nodeStats.m_connected));
1205 ui->peerLastBlock->setText(TimeDurationField(time_now, stats->nodeStats.m_last_block_time));
1206 ui->peerLastTx->setText(TimeDurationField(time_now, stats->nodeStats.m_last_tx_time));
1207 ui->peerLastSend->setText(TimeDurationField(time_now, stats->nodeStats.m_last_send));
1208 ui->peerLastRecv->setText(TimeDurationField(time_now, stats->nodeStats.m_last_recv));
1209 ui->peerBytesSent->setText(GUIUtil::formatBytes(stats->nodeStats.nSendBytes));
1210 ui->peerBytesRecv->setText(GUIUtil::formatBytes(stats->nodeStats.nRecvBytes));
1211 ui->peerPingTime->setText(GUIUtil::formatPingTime(stats->nodeStats.m_last_ping_time));
1212 ui->peerMinPing->setText(GUIUtil::formatPingTime(stats->nodeStats.m_min_ping_time));
1213 if (stats->nodeStats.nVersion) {
1214 ui->peerVersion->setText(QString::number(stats->nodeStats.nVersion));
1215 }
1216 if (!stats->nodeStats.cleanSubVer.empty()) {
1217 ui->peerSubversion->setText(QString::fromStdString(stats->nodeStats.cleanSubVer));
1218 }
1219 ui->peerConnectionType->setText(GUIUtil::ConnectionTypeToQString(stats->nodeStats.m_conn_type, /*prepend_direction=*/true));
1220 ui->peerTransportType->setText(QString::fromStdString(TransportTypeAsString(stats->nodeStats.m_transport_type)));
1221 if (stats->nodeStats.m_transport_type == TransportProtocolType::V2) {
1222 ui->peerSessionIdLabel->setVisible(true);
1223 ui->peerSessionId->setVisible(true);
1224 ui->peerSessionId->setText(QString::fromStdString(stats->nodeStats.m_session_id));
1225 } else {
1226 ui->peerSessionIdLabel->setVisible(false);
1227 ui->peerSessionId->setVisible(false);
1228 }
1229 ui->peerNetwork->setText(GUIUtil::NetworkToQString(stats->nodeStats.m_network));
1230 if (stats->nodeStats.m_permission_flags == NetPermissionFlags::None) {
1231 ui->peerPermissions->setText(ts.na);
1232 } else {
1233 QStringList permissions;
1234 for (const auto& permission : NetPermissions::ToStrings(stats->nodeStats.m_permission_flags)) {
1235 permissions.append(QString::fromStdString(permission));
1236 }
1237 ui->peerPermissions->setText(permissions.join(" & "));
1238 }
1239 ui->peerMappedAS->setText(stats->nodeStats.m_mapped_as != 0 ? QString::number(stats->nodeStats.m_mapped_as) : ts.na);
1240
1241 // This check fails for example if the lock was busy and
1242 // nodeStateStats couldn't be fetched.
1243 if (stats->fNodeStateStatsAvailable) {
1244 ui->timeoffset->setText(GUIUtil::formatTimeOffset(Ticks<std::chrono::seconds>(stats->nodeStateStats.time_offset)));
1245 ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStateStats.their_services));
1246 // Sync height is init to -1
1247 if (stats->nodeStateStats.nSyncHeight > -1) {
1248 ui->peerSyncHeight->setText(QString("%1").arg(stats->nodeStateStats.nSyncHeight));
1249 } else {
1250 ui->peerSyncHeight->setText(ts.unknown);
1251 }
1252 // Common height is init to -1
1253 if (stats->nodeStateStats.nCommonHeight > -1) {
1254 ui->peerCommonHeight->setText(QString("%1").arg(stats->nodeStateStats.nCommonHeight));
1255 } else {
1256 ui->peerCommonHeight->setText(ts.unknown);
1257 }
1258 ui->peerHeight->setText(QString::number(stats->nodeStateStats.m_starting_height));
1259 ui->peerPingWait->setText(GUIUtil::formatPingTime(stats->nodeStateStats.m_ping_wait));
1260 ui->peerAddrRelayEnabled->setText(stats->nodeStateStats.m_addr_relay_enabled ? ts.yes : ts.no);
1261 ui->peerAddrProcessed->setText(QString::number(stats->nodeStateStats.m_addr_processed));
1262 ui->peerAddrRateLimited->setText(QString::number(stats->nodeStateStats.m_addr_rate_limited));
1263 ui->peerRelayTxes->setText(stats->nodeStateStats.m_relay_txs ? ts.yes : ts.no);
1264 }
1265
1266 ui->hidePeersDetailButton->setIcon(platformStyle->SingleColorIcon(QStringLiteral(":/icons/remove")));
1267 ui->peersTabRightPanel->show();
1268}
1269
1270void RPCConsole::resizeEvent(QResizeEvent *event)
1271{
1272 QWidget::resizeEvent(event);
1273}
1274
1275void RPCConsole::showEvent(QShowEvent *event)
1276{
1277 QWidget::showEvent(event);
1278
1280 return;
1281
1282 // start PeerTableModel auto refresh
1284}
1285
1286void RPCConsole::hideEvent(QHideEvent *event)
1287{
1288 // It is too late to call QHeaderView::saveState() in ~RPCConsole(), as all of
1289 // the columns of QTableView child widgets will have zero width at that moment.
1290 m_peer_widget_header_state = ui->peerWidget->horizontalHeader()->saveState();
1291 m_banlist_widget_header_state = ui->banlistWidget->horizontalHeader()->saveState();
1292
1293 QWidget::hideEvent(event);
1294
1296 return;
1297
1298 // stop PeerTableModel auto refresh
1300}
1301
1303{
1304 QModelIndex index = ui->peerWidget->indexAt(point);
1305 if (index.isValid())
1306 peersTableContextMenu->exec(QCursor::pos());
1307}
1308
1310{
1311 QModelIndex index = ui->banlistWidget->indexAt(point);
1312 if (index.isValid())
1313 banTableContextMenu->exec(QCursor::pos());
1314}
1315
1317{
1318 // Get selected peer addresses
1319 QList<QModelIndex> nodes = GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId);
1320 for(int i = 0; i < nodes.count(); i++)
1321 {
1322 // Get currently selected peer address
1323 NodeId id = nodes.at(i).data().toLongLong();
1324 // Find the node, disconnect it and clear the selected node
1325 if(m_node.disconnectById(id))
1327 }
1328}
1329
1331{
1332 if (!clientModel)
1333 return;
1334
1335 for (const QModelIndex& peer : GUIUtil::getEntryData(ui->peerWidget, PeerTableModel::NetNodeId)) {
1336 // Find possible nodes, ban it and clear the selected node
1337 const auto stats = peer.data(PeerTableModel::StatsRole).value<CNodeCombinedStats*>();
1338 if (stats) {
1339 m_node.ban(stats->nodeStats.addr, bantime);
1340 m_node.disconnectByAddress(stats->nodeStats.addr);
1341 }
1342 }
1345}
1346
1348{
1349 if (!clientModel)
1350 return;
1351
1352 // Get selected ban addresses
1353 QList<QModelIndex> nodes = GUIUtil::getEntryData(ui->banlistWidget, BanTableModel::Address);
1354 BanTableModel* ban_table_model{clientModel->getBanTableModel()};
1355 bool unbanned{false};
1356 for (const auto& node_index : nodes) {
1357 unbanned |= ban_table_model->unban(node_index);
1358 }
1359 if (unbanned) {
1360 ban_table_model->refresh();
1361 }
1362}
1363
1365{
1366 ui->peerWidget->selectionModel()->clearSelection();
1367 cachedNodeids.clear();
1369}
1370
1372{
1373 if (!clientModel)
1374 return;
1375
1376 bool visible = clientModel->getBanTableModel()->shouldShow();
1377 ui->banlistWidget->setVisible(visible);
1378 ui->banHeading->setVisible(visible);
1379}
1380
1382{
1383 ui->tabWidget->setCurrentIndex(int(tabType));
1384}
1385
1386QString RPCConsole::tabTitle(TabTypes tab_type) const
1387{
1388 return ui->tabWidget->tabText(int(tab_type));
1389}
1390
1391QKeySequence RPCConsole::tabShortcut(TabTypes tab_type) const
1392{
1393 switch (tab_type) {
1394 case TabTypes::INFO: return QKeySequence(tr("Ctrl+I"));
1395 case TabTypes::CONSOLE: return QKeySequence(tr("Ctrl+T"));
1396 case TabTypes::GRAPH: return QKeySequence(tr("Ctrl+N"));
1397 case TabTypes::PEERS: return QKeySequence(tr("Ctrl+P"));
1398 } // no default case, so the compiler can warn about missing cases
1399
1400 assert(false);
1401}
1402
1403void RPCConsole::updateAlerts(const QString& warnings)
1404{
1405 this->ui->label_alerts->setVisible(!warnings.isEmpty());
1406 this->ui->label_alerts->setText(warnings);
1407}
1408
1410{
1411 const ChainType chain = Params().GetChainType();
1412 if (chain == ChainType::MAIN) return;
1413
1414 const QString chainType = QString::fromStdString(Params().GetChainTypeString());
1415 const QString title = tr("Node window - [%1]").arg(chainType);
1416 this->setWindowTitle(title);
1417}
node::NodeContext m_node
Definition: bitcoin-gui.cpp:42
const auto cmd
const auto command
const CChainParams & Params()
Return the currently selected parameters.
ChainType
Definition: chaintype.h:11
Qt model providing information about banned peers, similar to the "getpeerinfo" RPC call.
Definition: bantablemodel.h:44
bool unban(const QModelIndex &index)
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:103
Model for Bitcoin network client.
Definition: clientmodel.h:57
void bytesChanged(quint64 totalBytesIn, quint64 totalBytesOut)
QString blocksDir() const
QString getStatusBarWarnings() const
Return warnings to be displayed in status bar.
std::map< CNetAddr, LocalServiceInfo > getNetLocalAddresses() const
PeerTableModel * getPeerTableModel()
PeerTableSortProxy * peerTableSortProxy()
void numConnectionsChanged(int count)
QString formatClientStartupTime() const
int getNumConnections(unsigned int flags=CONNECTIONS_ALL) const
Return number of connections, default is in- and outbound (total)
Definition: clientmodel.cpp:84
BanTableModel * getBanTableModel()
void numBlocksChanged(int count, const QDateTime &blockDate, double nVerificationProgress, SyncType header, SynchronizationState sync_state)
void alertsChanged(const QString &warnings)
void mempoolSizeChanged(long count, size_t mempoolSizeInBytes, size_t mempoolMaxSizeInBytes)
QString dataDir() const
QString formatFullVersion() const
QString formatSubVersion() const
void networkActiveChanged(bool networkActive)
interfaces::Node & node() const
Definition: clientmodel.h:66
static std::vector< std::string > ToStrings(NetPermissionFlags flags)
QString displayText(const QVariant &value, const QLocale &locale) const override
Definition: rpcconsole.cpp:139
PeerIdViewDelegate(QObject *parent=nullptr)
Definition: rpcconsole.cpp:136
QIcon SingleColorIcon(const QString &filename) const
Colorize an icon (given filename) with the icon color.
bool getImagesOnButtons() const
Definition: platformstyle.h:21
QImage SingleColorImage(const QString &filename) const
Colorize an image (given filename) with the icon color.
Class for handling RPC timers (used for e.g.
Definition: rpcconsole.cpp:105
std::function< void()> func
Definition: rpcconsole.cpp:118
QtRPCTimerBase(std::function< void()> &_func, int64_t millis)
Definition: rpcconsole.cpp:108
~QtRPCTimerBase()=default
const char * Name() override
Implementation name.
Definition: rpcconsole.cpp:125
RPCTimerBase * NewTimer(std::function< void()> &func, int64_t millis) override
Factory function for timers.
Definition: rpcconsole.cpp:126
~QtRPCTimerInterface()=default
Local Bitcoin RPC console.
Definition: rpcconsole.h:42
QMenu * peersTableContextMenu
Definition: rpcconsole.h:170
RPCConsole(interfaces::Node &node, const PlatformStyle *platformStyle, QWidget *parent)
Definition: rpcconsole.cpp:467
struct RPCConsole::TranslatedStrings ts
void browseHistory(int offset)
Go forward or back in history.
QByteArray m_banlist_widget_header_state
Definition: rpcconsole.h:179
void fontSmaller()
Definition: rpcconsole.cpp:837
RPCTimerInterface * rpcTimerInterface
Definition: rpcconsole.h:169
QString TimeDurationField(std::chrono::seconds time_now, std::chrono::seconds time_at_event) const
Helper for the output of a time duration field.
Definition: rpcconsole.h:185
void on_lineEdit_returnPressed()
QStringList history
Definition: rpcconsole.h:164
void message(int category, const QString &msg)
Append the message to the message widget.
Definition: rpcconsole.h:115
void setFontSize(int newSize)
Definition: rpcconsole.cpp:842
void updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
update traffic statistics
void setTrafficGraphRange(int mins)
static bool RPCParseCommandLine(interfaces::Node *node, std::string &strResult, const std::string &strCommand, bool fExecute, std::string *const pstrFilteredOut=nullptr, const WalletModel *wallet_model=nullptr)
Split shell command line into a list of arguments and optionally execute the command(s).
Definition: rpcconsole.cpp:169
const PlatformStyle *const platformStyle
Definition: rpcconsole.h:168
void setMempoolSize(long numberOfTxs, size_t dynUsage, size_t maxUsage)
Set size (number of transactions and memory usage) of the mempool in the UI.
void updateDetailWidget()
show detailed information on ui about selected node
void showEvent(QShowEvent *event) override
void resizeEvent(QResizeEvent *event) override
static bool RPCExecuteCommandLine(interfaces::Node &node, std::string &strResult, const std::string &strCommand, std::string *const pstrFilteredOut=nullptr, const WalletModel *wallet_model=nullptr)
Definition: rpcconsole.h:50
QString tabTitle(TabTypes tab_type) const
void updateNetworkState()
Update UI with latest network info from model.
Definition: rpcconsole.cpp:968
void clear(bool keep_prompt=false)
Definition: rpcconsole.cpp:867
void disconnectSelectedNode()
Disconnect a selected node on the Peers tab.
@ BANTIME_COLUMN_WIDTH
Definition: rpcconsole.h:157
@ ADDRESS_COLUMN_WIDTH
Definition: rpcconsole.h:153
@ SUBVERSION_COLUMN_WIDTH
Definition: rpcconsole.h:154
@ PING_COLUMN_WIDTH
Definition: rpcconsole.h:155
@ BANSUBNET_COLUMN_WIDTH
Definition: rpcconsole.h:156
QCompleter * autoCompleter
Definition: rpcconsole.h:173
void hideEvent(QHideEvent *event) override
QKeySequence tabShortcut(TabTypes tab_type) const
void showPeersTableContextMenu(const QPoint &point)
Show custom context menu on Peers tab.
QList< NodeId > cachedNodeids
Definition: rpcconsole.h:167
bool m_is_executing
Definition: rpcconsole.h:177
interfaces::Node & m_node
Definition: rpcconsole.h:161
void unbanSelectedNode()
Unban a selected node on the Bans tab.
void updateAlerts(const QString &warnings)
void clearSelectedNode()
clear the selected node
void on_sldGraphRange_valueChanged(int value)
change the time range of the network traffic graph
int consoleFontSize
Definition: rpcconsole.h:172
void setNumConnections(int count)
Set number of connections shown in the UI.
Definition: rpcconsole.cpp:994
void setNumBlocks(int count, const QDateTime &blockDate, double nVerificationProgress, SyncType synctype)
Set number of blocks and last block date shown in the UI.
ClientModel * clientModel
Definition: rpcconsole.h:163
void banSelectedNode(int bantime)
Ban a selected node on the Peers tab.
int historyPtr
Definition: rpcconsole.h:165
void scrollToEnd()
Scroll console view to end.
void keyPressEvent(QKeyEvent *) override
Definition: rpcconsole.cpp:926
void on_tabWidget_currentChanged(int index)
Ui::RPCConsole *const ui
Definition: rpcconsole.h:162
void startExecutor()
void setNetworkActive(bool networkActive)
Set network state shown in the UI.
void updateWindowTitle()
void fontBigger()
Definition: rpcconsole.cpp:832
QString cmdBeforeBrowsing
Definition: rpcconsole.h:166
virtual bool eventFilter(QObject *obj, QEvent *event) override
Definition: rpcconsole.cpp:612
void on_openDebugLogfileButton_clicked()
open the debug.log from the current datadir
void showBanTableContextMenu(const QPoint &point)
Show custom context menu on Bans tab.
void setClientModel(ClientModel *model=nullptr, int bestblock_height=0, int64_t bestblock_date=0, double verification_progress=0.0)
Definition: rpcconsole.cpp:656
void setTabFocus(enum TabTypes tabType)
set which tab has the focus (is visible)
QByteArray m_peer_widget_header_state
Definition: rpcconsole.h:178
void changeEvent(QEvent *e) override
Definition: rpcconsole.cpp:933
WalletModel * m_last_wallet_model
Definition: rpcconsole.h:176
void showOrHideBanTableIfRequired()
Hides ban table if no bans are present.
RPCExecutor * m_executor
Definition: rpcconsole.h:175
QMenu * banTableContextMenu
Definition: rpcconsole.h:171
QThread thread
Definition: rpcconsole.h:174
void reply(int category, const QString &command)
RPCExecutor(interfaces::Node &node)
Definition: rpcconsole.cpp:89
interfaces::Node & m_node
Definition: rpcconsole.cpp:98
void request(const QString &command, const WalletModel *wallet_model)
Definition: rpcconsole.cpp:411
Opaque base class for timers returned by NewTimerFunc.
Definition: server.h:43
RPC timer "driver".
Definition: server.h:52
void push_back(UniValue val)
Definition: univalue.cpp:104
const std::string & get_str() const
bool isArray() const
Definition: univalue.h:85
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:233
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
bool isStr() const
Definition: univalue.h:83
Int getInt() const
Definition: univalue.h:138
bool isObject() const
Definition: univalue.h:86
Interface to Bitcoin wallet from Qt view code.
Definition: walletmodel.h:48
QString getDisplayName() const
static bool isWalletEnabled()
QString getWalletName() const
Top-level interface for a bitcoin node (bitcoind process).
Definition: node.h:71
virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface *iface)=0
Set RPC timer interface if unset.
virtual bool disconnectById(NodeId id)=0
Disconnect node by id.
virtual bool ban(const CNetAddr &net_addr, int64_t ban_time_offset)=0
Ban node.
virtual std::vector< std::string > listRpcCommands()=0
List rpc commands.
virtual void rpcUnsetTimerInterface(RPCTimerInterface *iface)=0
Unset RPC timer interface.
virtual bool getNetworkActive()=0
Get network active.
virtual bool disconnectByAddress(const CNetAddr &net_addr)=0
Disconnect node by address.
UniValue RPCConvertValues(const std::string &strMethod, const std::vector< std::string > &strParams)
Convert positional arguments to command-specific RPC representation.
Definition: client.cpp:356
SyncType
Definition: clientmodel.h:42
@ CONNECTIONS_IN
Definition: clientmodel.h:50
@ CONNECTIONS_OUT
Definition: clientmodel.h:51
std::string TransportTypeAsString(TransportProtocolType transport_type)
Convert TransportProtocolType enum to a string value.
@ V2
BIP324 protocol.
QString NetworkToQString(Network net)
Convert enum Network to QString.
Definition: guiutil.cpp:687
QString HtmlEscape(const QString &str, bool fMultiLine)
Definition: guiutil.cpp:249
QList< QModelIndex > getEntryData(const QAbstractItemView *view, int column)
Return a field of the currently selected entry as a QString.
Definition: guiutil.cpp:277
QFont fixedPitchFont(bool use_embedded_font)
Definition: guiutil.cpp:100
QString formatBytes(uint64_t bytes)
Definition: guiutil.cpp:824
QString formatDurationStr(std::chrono::seconds dur)
Convert seconds into a QString with days, hours, mins, secs.
Definition: guiutil.cpp:736
void AddButtonShortcut(QAbstractButton *button, const QKeySequence &shortcut)
Connects an additional shortcut to a QAbstractButton.
Definition: guiutil.cpp:144
void handleCloseWindowShortcut(QWidget *w)
Definition: guiutil.cpp:431
void copyEntryData(const QAbstractItemView *view, int column, int role)
Copy a field of the currently selected entry of a view to the clipboard.
Definition: guiutil.cpp:264
QString formatPingTime(std::chrono::microseconds ping_time)
Format a CNodeStats.m_last_ping_time into a user-readable string or display N/A, if 0.
Definition: guiutil.cpp:775
void openDebugLogfile()
Definition: guiutil.cpp:436
QString ConnectionTypeToQString(ConnectionType conn_type, bool prepend_direction)
Convert enum ConnectionType to QString.
Definition: guiutil.cpp:707
QString formatServicesStr(quint64 mask)
Format CNodeStats.nServices bitmask into a user-readable string.
Definition: guiutil.cpp:761
QString formatTimeOffset(int64_t time_offset)
Format a CNodeStateStats.time_offset into a user-readable string.
Definition: guiutil.cpp:782
bool IsEscapeOrBack(int key)
Definition: guiutil.h:408
Definition: messages.h:20
void ThreadRename(const std::string &)
Rename a thread both in terms of an internal (in-memory) name as well as its system thread name.
Definition: threadnames.cpp:55
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:192
int64_t NodeId
Definition: net.h:97
const std::vector< std::string > CONNECTION_TYPE_DOC
Definition: net.cpp:42
const std::vector< std::string > TRANSPORT_TYPE_DOC
Definition: net.cpp:51
const int INITIAL_TRAFFIC_GRAPH_MINS
Definition: rpcconsole.cpp:56
const struct @8 ICON_MAPPING[]
const QSize FONT_RANGE(4, 40)
const int CONSOLE_HISTORY
Definition: rpcconsole.cpp:55
static QString categoryClass(int category)
Definition: rpcconsole.cpp:821
const char fontSizeSettingsKey[]
Definition: rpcconsole.cpp:58
const char * url
Definition: rpcconsole.cpp:61
const char * source
Definition: rpcconsole.cpp:62
static int count
assert(!tx.IsCoinBase())