Inside Bitcoin

501                auto flags = label->textInteractionFlags();
502                label->setTextInteractionFlags(Qt::NoTextInteraction);
503                label->setTextInteractionFlags(flags);
504            }
505        }
506    }
507
508    return QObject::eventFilter(watched, event);
509}
510
511#ifdef WIN32
512fs::path static StartupShortcutPath()
513{
514    ChainType chain = gArgs.GetChainType();
515    if (chain == ChainType::MAIN)
516        return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin.lnk";
517    if (chain == ChainType::TESTNET) // Remove this special case when testnet CBaseChainParams::DataDir() is incremented to "testnet4"
518        return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin (testnet).lnk";
519    return GetSpecialFolderPath(CSIDL_STARTUP) / fs::u8path(strprintf("Bitcoin (%s).lnk", ChainTypeToString(chain)));
520}
521
522bool GetStartOnSystemStartup()
523{
524    // check for Bitcoin*.lnk
525    return fs::exists(StartupShortcutPath());
526}
527
528bool SetStartOnSystemStartup(bool fAutoStart)
529{
530    // If the shortcut exists already, remove it for updating
531    fs::remove(StartupShortcutPath());
532
533    if (fAutoStart)
534    {
535        CoInitialize(nullptr);
536
537        // Get a pointer to the IShellLink interface.
538        IShellLinkW* psl = nullptr;
539        HRESULT hres = CoCreateInstance(CLSID_ShellLink, nullptr,
540            CLSCTX_INPROC_SERVER, IID_IShellLinkW,
541            reinterpret_cast<void**>(&psl));
542
543        if (SUCCEEDED(hres))
544        {
545            // Get the current executable path
546            WCHAR pszExePath[MAX_PATH];
547            GetModuleFileNameW(nullptr, pszExePath, ARRAYSIZE(pszExePath));
548
549            // Start client minimized
550            QString strArgs = "-min";
551            // Set -testnet /-regtest options
552            strArgs += QString::fromStdString(strprintf(" -chain=%s", gArgs.GetChainTypeString()));
553
554            // Set the path to the shortcut target
555            psl->SetPath(pszExePath);
556            PathRemoveFileSpecW(pszExePath);
557            psl->SetWorkingDirectory(pszExePath);
558            psl->SetShowCmd(SW_SHOWMINNOACTIVE);
559            psl->SetArguments(strArgs.toStdWString().c_str());
560
561            // Query IShellLink for the IPersistFile interface for
562            // saving the shortcut in persistent storage.
563            IPersistFile* ppf = nullptr;
564            hres = psl->QueryInterface(IID_IPersistFile, reinterpret_cast<void**>(&ppf));
565            if (SUCCEEDED(hres))
566            {
567                // Save the link by calling IPersistFile::Save.
568                hres = ppf->Save(StartupShortcutPath().wstring().c_str(), TRUE);
569                ppf->Release();
570                psl->Release();
571                CoUninitialize();
572                return true;
573            }
574            psl->Release();
575        }
576        CoUninitialize();
577        return false;
578    }
579    return true;
580}
581#elif defined(Q_OS_LINUX)
582
583// Follow the Desktop Application Autostart Spec:
584// https://specifications.freedesktop.org/autostart-spec/autostart-spec-latest.html
585
586fs::path static GetAutostartDir()
587{
588    char* pszConfigHome = getenv("XDG_CONFIG_HOME");
589    if (pszConfigHome) return fs::path(pszConfigHome) / "autostart";
590    char* pszHome = getenv("HOME");
591    if (pszHome) return fs::path(pszHome) / ".config" / "autostart";
592    return fs::path();
593}
594
595fs::path static GetAutostartFilePath()
596{
597    ChainType chain = gArgs.GetChainType();
598    if (chain == ChainType::MAIN)
599        return GetAutostartDir() / "bitcoin.desktop";
600    return GetAutostartDir() / fs::u8path(strprintf("bitcoin-%s.desktop", ChainTypeToString(chain)));
601}
602
603bool GetStartOnSystemStartup()
604{
605    std::ifstream optionFile{GetAutostartFilePath().std_path()};
606    if (!optionFile.good())
607        return false;
608    // Scan through file for "Hidden=true":
609    std::string line;
610    while (!optionFile.eof())
611    {
612        getline(optionFile, line);
613        if (line.find("Hidden") != std::string::npos &&
614            line.find("true") != std::string::npos)
615            return false;
616    }
617    optionFile.close();
618
619    return true;
620}
621
622bool SetStartOnSystemStartup(bool fAutoStart)
623{
624    if (!fAutoStart)
625        fs::remove(GetAutostartFilePath());
626    else
627    {
628        char pszExePath[MAX_PATH+1];
629        ssize_t r = readlink("/proc/self/exe", pszExePath, sizeof(pszExePath));
630        if (r == -1 || r > MAX_PATH) {
631            return false;
632        }
633        pszExePath[r] = '\0';
634
635        fs::create_directories(GetAutostartDir());
636
637        std::ofstream optionFile{GetAutostartFilePath().std_path(), std::ios_base::out | std::ios_base::trunc};
638        if (!optionFile.good())
639            return false;
640        ChainType chain = gArgs.GetChainType();
641        // Write a bitcoin.desktop file to the autostart directory:
642        optionFile << "[Desktop Entry]\n";
643        optionFile << "Type=Application\n";
644        if (chain == ChainType::MAIN)
645            optionFile << "Name=Bitcoin\n";
646        else
647            optionFile << strprintf("Name=Bitcoin (%s)\n", ChainTypeToString(chain));
648        optionFile << "Exec=" << pszExePath << strprintf(" -min -chain=%s\n", ChainTypeToString(chain));
649        optionFile << "Terminal=false\n";
650        optionFile << "Hidden=false\n";
651        optionFile.close();
652    }
653    return true;
654}
655
656#else
657
658bool GetStartOnSystemStartup() { return false; }
659bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
660
661#endif
662
663void setClipboard(const QString& str)
664{
665    QClipboard* clipboard = QApplication::clipboard();
666    clipboard->setText(str, QClipboard::Clipboard);
667    if (clipboard->supportsSelection()) {
668        clipboard->setText(str, QClipboard::Selection);
669    }
670}
671
672fs::path QStringToPath(const QString &path)
673{
674    return fs::u8path(path.toStdString());
675}
676
677QString PathToQString(const fs::path &path)
678{
679    return QString::fromStdString(path.utf8string());
680}
681
682QString NetworkToQString(Network net)
683{
684    switch (net) {
685    case NET_UNROUTABLE: return QObject::tr("Unroutable");
686    //: Name of IPv4 network in peer info
687    case NET_IPV4: return QObject::tr("IPv4", "network name");
688    //: Name of IPv6 network in peer info
689    case NET_IPV6: return QObject::tr("IPv6", "network name");
690    //: Name of Tor network in peer info
691    case NET_ONION: return QObject::tr("Onion", "network name");
692    //: Name of I2P network in peer info
693    case NET_I2P: return QObject::tr("I2P", "network name");
694    //: Name of CJDNS network in peer info
695    case NET_CJDNS: return QObject::tr("CJDNS", "network name");
696    case NET_INTERNAL: return "Internal";  // should never actually happen
697    case NET_MAX: assert(false);
698    } // no default case, so the compiler can warn about missing cases
699    assert(false);
700}
701
702QString ConnectionTypeToQString(ConnectionType conn_type, bool prepend_direction)
703{
704    QString prefix;
705    if (prepend_direction) {
706        prefix = (conn_type == ConnectionType::INBOUND) ?
707                     /*: An inbound connection from a peer. An inbound connection
708                         is a connection initiated by a peer. */
709                     QObject::tr("Inbound") :
710                     /*: An outbound connection to a peer. An outbound connection
711                         is a connection initiated by us. */
712                     QObject::tr("Outbound") + " ";
713    }
714    switch (conn_type) {
715    case ConnectionType::INBOUND: return prefix;
716    //: Peer connection type that relays all network information.
717    case ConnectionType::OUTBOUND_FULL_RELAY: return prefix + QObject::tr("Full Relay");
718    /*: Peer connection type that relays network information about
719        blocks and not transactions or addresses. */
720    case ConnectionType::BLOCK_RELAY: return prefix + QObject::tr("Block Relay");
721    //: Peer connection type established manually through one of several methods.
722    case ConnectionType::MANUAL: return prefix + QObject::tr("Manual");
723    //: Short-lived peer connection type that tests the aliveness of known addresses.
724    case ConnectionType::FEELER: return prefix + QObject::tr("Feeler");
725    //: Short-lived peer connection type that solicits known addresses from a peer.
726    case ConnectionType::ADDR_FETCH: return prefix + QObject::tr("Address Fetch");
727    //: Short-lived peer connection type that is used for broadcasting privacy-sensitive data.
728    case ConnectionType::PRIVATE_BROADCAST: return prefix + QObject::tr("Private Broadcast");
729    } // no default case, so the compiler can warn about missing cases
730    assert(false);
731}
732
733QString formatDurationStr(std::chrono::nanoseconds dur)
734{
735    const auto d{std::chrono::duration_cast<std::chrono::days>(dur)};
736    const auto h{std::chrono::duration_cast<std::chrono::hours>(dur - d)};
737    const auto m{std::chrono::duration_cast<std::chrono::minutes>(dur - d - h)};
738    const auto s{std::chrono::duration_cast<std::chrono::seconds>(dur - d - h - m)};
739    QStringList str_list;
740    if (auto d2{d.count()}) str_list.append(QObject::tr("%1 d").arg(d2));
741    if (auto h2{h.count()}) str_list.append(QObject::tr("%1 h").arg(h2));
742    if (auto m2{m.count()}) str_list.append(QObject::tr("%1 m").arg(m2));
743    const auto s2{s.count()};
744    if (s2 || str_list.empty()) str_list.append(QObject::tr("%1 s").arg(s2));
745    return str_list.join(" ");
746}
747
748QString FormatPeerAge(NodeClock::time_point connected)
749{
750    const auto age{NodeClock::now() - connected};