Inside Bitcoin

251                            if (stack.size())
252                                add_to_current_stack(curarg);
253                            else
254                                strResult = curarg;
255                        }
256                        curarg.clear();
257                        // assume eating space state
258                        state = STATE_EATING_SPACES;
259                }
260                if (breakParsing)
261                    break;
262                [[fallthrough]];
263            }
264            case STATE_ARGUMENT: // In or after argument
265            case STATE_EATING_SPACES_IN_ARG:
266            case STATE_EATING_SPACES_IN_BRACKETS:
267            case STATE_EATING_SPACES: // Handle runs of whitespace
268                switch(ch)
269            {
270                case '"': state = STATE_DOUBLEQUOTED; break;
271                case '\'': state = STATE_SINGLEQUOTED; break;
272                case '\\': state = STATE_ESCAPE_OUTER; break;
273                case '(': case ')': case '\n':
274                    if (state == STATE_EATING_SPACES_IN_ARG)
275                        throw std::runtime_error("Invalid Syntax");
276                    if (state == STATE_ARGUMENT)
277                    {
278                        if (ch == '(' && stack.size() && stack.back().size() > 0)
279                        {
280                            if (nDepthInsideSensitive) {
281                                ++nDepthInsideSensitive;
282                            }
283                            stack.emplace_back();
284                        }
285
286                        // don't allow commands after executed commands on baselevel
287                        if (!stack.size())
288                            throw std::runtime_error("Invalid Syntax");
289
290                        add_to_current_stack(curarg);
291                        curarg.clear();
292                        state = STATE_EATING_SPACES_IN_BRACKETS;
293                    }
294                    if ((ch == ')' || ch == '\n') && stack.size() > 0 && stack.back().size() > 0)
295                    {
296                        if (fExecute) {
297                            // Convert argument list to JSON objects in method-dependent way,
298                            // and pass it along with the method name to the dispatcher.
299                            UniValue params = RPCConvertValues(stack.back()[0], std::vector<std::string>(stack.back().begin() + 1, stack.back().end()));
300                            std::string method = stack.back()[0];
301                            std::string uri;
302                            if (!wallet_name.isEmpty()) {
303                                QByteArray encodedName = QUrl::toPercentEncoding(wallet_name);
304                                uri = "/wallet/"+std::string(encodedName.constData(), encodedName.length());
305                            }
306                            assert(node);
307                            lastResult = node->executeRpc(method, params, uri);
308                        }
309
310                        command_parsed = true;
311                        state = STATE_COMMAND_EXECUTED;
312                        curarg.clear();
313                    }
314                    break;
315                case ' ': case ',': case '\t':
316                    if(state == STATE_EATING_SPACES_IN_ARG && curarg.empty() && ch == ',')
317                        throw std::runtime_error("Invalid Syntax");
318
319                    else if(state == STATE_ARGUMENT) // Space ends argument
320                    {
321                        add_to_current_stack(curarg);
322                        curarg.clear();
323                    }
324                    if ((state == STATE_EATING_SPACES_IN_BRACKETS || state == STATE_ARGUMENT) && ch == ',')
325                    {
326                        state = STATE_EATING_SPACES_IN_ARG;
327                        break;
328                    }
329                    state = STATE_EATING_SPACES;
330                    break;
331                default: curarg += ch; state = STATE_ARGUMENT;
332            }
333                break;
334            case STATE_SINGLEQUOTED: // Single-quoted string
335                switch(ch)
336            {
337                case '\'': state = STATE_ARGUMENT; break;
338                default: curarg += ch;
339            }
340                break;
341            case STATE_DOUBLEQUOTED: // Double-quoted string
342                switch(ch)
343            {
344                case '"': state = STATE_ARGUMENT; break;
345                case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break;
346                default: curarg += ch;
347            }
348                break;
349            case STATE_ESCAPE_OUTER: // '\' outside quotes
350                curarg += ch; state = STATE_ARGUMENT;
351                break;
352            case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
353                if(ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
354                curarg += ch; state = STATE_DOUBLEQUOTED;
355                break;
356        }
357    }
358    if (pstrFilteredOut) {
359        if (STATE_COMMAND_EXECUTED == state) {
360            assert(!stack.empty());
361            close_out_params();
362        }
363        *pstrFilteredOut = strCommand;
364        for (auto i = filter_ranges.rbegin(); i != filter_ranges.rend(); ++i) {
365            pstrFilteredOut->replace(i->first, i->second - i->first, "(…)");
366        }
367    }
368    switch(state) // final state
369    {
370        case STATE_COMMAND_EXECUTED:
371            if (lastResult.isStr())
372                strResult = lastResult.get_str();
373            else
374                strResult = lastResult.write(2);
375            [[fallthrough]];
376        case STATE_ARGUMENT:
377            return true;
378        case STATE_EATING_SPACES:
379            // Reaching this state without ever parsing a command means the line
380            // held no command name (e.g. ")", "()", "(", ","); treat it as invalid.
381            return command_parsed;
382        default: // ERROR to end in one of the other states
383            return false;
384    }
385}
386
387void RPCExecutor::request(const QString &command, const QString& wallet_name)
388{
389    try
390    {
391        std::string result;
392        std::string executableCommand = command.toStdString() + "\n";
393
394        // Catch the console-only-help command before RPC call is executed and reply with help text as-if a RPC reply.
395        if(executableCommand == "help-console\n") {
396            Q_EMIT reply(RPCConsole::CMD_REPLY, QString(("\n"
397                "This console accepts RPC commands using the standard syntax.\n"
398                "   example:    getblockhash 0\n\n"
399
400                "This console can also accept RPC commands using the parenthesized syntax.\n"
401                "   example:    getblockhash(0)\n\n"
402
403                "Commands may be nested when specified with the parenthesized syntax.\n"
404                "   example:    getblock(getblockhash(0) 1)\n\n"
405
406                "A space or a comma can be used to delimit arguments for either syntax.\n"
407                "   example:    getblockhash 0\n"
408                "               getblockhash,0\n\n"
409
410                "Named results can be queried with a non-quoted key string in brackets using the parenthesized syntax.\n"
411                "   example:    getblock(getblockhash(0) 1)[tx]\n\n"
412
413                "Results without keys can be queried with an integer in brackets using the parenthesized syntax.\n"
414                "   example:    getblock(getblockhash(0),1)[tx][0]\n\n")));
415            return;
416        }
417        if (!RPCConsole::RPCExecuteCommandLine(m_node, result, executableCommand, nullptr, wallet_name)) {
418            Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
419            return;
420        }
421
422        Q_EMIT reply(RPCConsole::CMD_REPLY, QString::fromStdString(result));
423    }
424    catch (UniValue& objError)
425    {
426        try // Nice formatting for standard-format error
427        {
428            int code = objError.find_value("code").getInt<int>();
429            std::string message = objError.find_value("message").get_str();
430            Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
431        }
432        catch (const std::runtime_error&) // raised when converting to invalid type, i.e. missing code or message
433        {   // Show raw JSON object
434            Q_EMIT reply(RPCConsole::CMD_ERROR, QString::fromStdString(objError.write()));
435        }
436    }
437    catch (const std::exception& e)
438    {
439        Q_EMIT reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
440    }
441}
442
443RPCConsole::RPCConsole(interfaces::Node& node, const PlatformStyle *_platformStyle, QWidget *parent) :
444    QWidget(parent),
445    m_node(node),
446    ui(new Ui::RPCConsole),
447    platformStyle(_platformStyle)
448{
449    ui->setupUi(this);
450    QSettings settings;
451#ifdef ENABLE_WALLET
452    if (WalletModel::isWalletEnabled()) {
453        // RPCConsole widget is a window.
454        if (!restoreGeometry(settings.value("RPCConsoleWindowGeometry").toByteArray())) {
455            // Restore failed (perhaps missing setting), center the window
456            move(QGuiApplication::primaryScreen()->availableGeometry().center() - frameGeometry().center());
457        }
458        ui->splitter->restoreState(settings.value("RPCConsoleWindowPeersTabSplitterSizes").toByteArray());
459    } else
460#endif // ENABLE_WALLET
461    {
462        // RPCConsole is a child widget.
463        ui->splitter->restoreState(settings.value("RPCConsoleWidgetPeersTabSplitterSizes").toByteArray());
464    }
465
466    m_peer_widget_header_state = settings.value("PeersTabPeerHeaderState").toByteArray();
467    m_banlist_widget_header_state = settings.value("PeersTabBanlistHeaderState").toByteArray();
468
469    constexpr QChar nonbreaking_hyphen(8209);
470    const std::vector<QString> CONNECTION_TYPE_DOC{
471        //: Explanatory text for an inbound peer connection.
472        tr("Inbound: initiated by peer"),
473        /*: Explanatory text for an outbound peer connection that
474            relays all network information. This is the default behavior for
475            outbound connections. */
476        tr("Outbound Full Relay: default"),
477        /*: Explanatory text for an outbound peer connection that relays
478            network information about blocks and not transactions or addresses. */
479        tr("Outbound Block Relay: does not relay transactions or addresses"),
480        /*: Explanatory text for an outbound peer connection that was
481            established manually through one of several methods. The numbered
482            arguments are stand-ins for the methods available to establish
483            manual connections. */
484        tr("Outbound Manual: added using RPC %1 or %2/%3 configuration options")
485            .arg("addnode")
486            .arg(QString(nonbreaking_hyphen) + "addnode")
487            .arg(QString(nonbreaking_hyphen) + "connect"),
488        /*: Explanatory text for a short-lived outbound peer connection that
489            is used to test the aliveness of known addresses. */
490        tr("Outbound Feeler: short-lived, for testing addresses"),
491        /*: Explanatory text for a short-lived outbound peer connection that is used
492            to request addresses from a peer. */
493        tr("Outbound Address Fetch: short-lived, for soliciting addresses"),
494        /*: Explanatory text for a short-lived outbound peer connection that is used
495            to broadcast privacy-sensitive data (like our transactions). */
496        tr("Private broadcast: short-lived, for broadcasting privacy-sensitive transactions")};
497    const QString connection_types_list{"<ul><li>" + Join(CONNECTION_TYPE_DOC, QString("</li><li>")) + "</li></ul>"};
498    ui->peerConnectionTypeLabel->setToolTip(ui->peerConnectionTypeLabel->toolTip().arg(connection_types_list));
499    const std::vector<QString> TRANSPORT_TYPE_DOC{
500        //: Explanatory text for "detecting" transport type.