Starting and stopping a Bitcoin Core node

2251    for (const std::string& strBind : args.GetArgs("-whitebind")) {
2252        NetWhitebindPermissions whitebind;
2253        bilingual_str error;
2254        if (!NetWhitebindPermissions::TryParse(strBind, whitebind, error)) return InitError(error);
2255        connOptions.vWhiteBinds.push_back(whitebind);
2256    }
2257
2258    // If the user did not specify -bind= or -whitebind= then we bind
2259    // on any address - 0.0.0.0 (IPv4) and :: (IPv6).
2260    connOptions.bind_on_any = args.GetArgs("-bind").empty() && args.GetArgs("-whitebind").empty();
2261
2262    // Emit a warning if a bad port is given to -port= but only if -bind and -whitebind are not
2263    // given, because if they are, then -port= is ignored.
2264    if (connOptions.bind_on_any && args.IsArgSet("-port")) {
2265        const uint16_t port_arg = args.GetIntArg("-port", 0);
2266        if (IsBadPort(port_arg)) {
2267            InitWarning(BadPortWarning("-port", port_arg));
2268        }
2269    }
2270
2271    CService onion_service_target;
2272    if (!connOptions.onion_binds.empty()) {
2273        onion_service_target = connOptions.onion_binds.front();
2274    } else if (!connOptions.vBinds.empty()) {
2275        onion_service_target = connOptions.vBinds.front();
2276    } else {
2277        onion_service_target = DefaultOnionServiceTarget(default_bind_port_onion);
2278        connOptions.onion_binds.push_back(onion_service_target);
2279    }
2280
2281    if (listenonion) {
2282        if (connOptions.onion_binds.size() > 1) {
2283            InitWarning(strprintf(_("More than one onion bind address is provided. Using %s "
2284                                    "for the automatically created Tor onion service."),
2285                                  onion_service_target.ToStringAddrPort()));
2286        }
2287        node.tor_controller = std::make_unique<TorController>(gArgs.GetArg("-torcontrol", DEFAULT_TOR_CONTROL), onion_service_target);
2288    }
2289
2290    bool should_discover = connOptions.bind_on_any;
2291    if (!should_discover) {
2292        for (const auto& bind : connOptions.vBinds) {
2293            if (bind.IsBindAny()) {
2294                should_discover = true;
2295                break;
2296            }
2297        }
2298    }
2299
2300    if (!should_discover) {
2301        for (const auto& whitebind : connOptions.vWhiteBinds) {
2302            if (whitebind.m_service.IsBindAny()) {
2303                should_discover = true;
2304                break;
2305            }
2306        }
2307    }
2308
2309    if (should_discover) {
2310        // Only add all IP addresses of the machine if we would be listening on
2311        // any address - 0.0.0.0 (IPv4) and :: (IPv6).
2312        Discover();
2313    }
2314
2315    for (const auto& net : args.GetArgs("-whitelist")) {
2316        NetWhitelistPermissions subnet;
2317        ConnectionDirection connection_direction;
2318        bilingual_str error;
2319        if (!NetWhitelistPermissions::TryParse(net, subnet, connection_direction, error)) return InitError(error);
2320        if (connection_direction & ConnectionDirection::In) {
2321            connOptions.vWhitelistedRangeIncoming.push_back(subnet);
2322        }
2323        if (connection_direction & ConnectionDirection::Out) {
2324            connOptions.vWhitelistedRangeOutgoing.push_back(subnet);
2325        }
2326    }
2327
2328    connOptions.vSeedNodes = args.GetArgs("-seednode");
2329
2330    const auto connect = args.GetArgs("-connect");
2331    if (!connect.empty() || args.IsArgNegated("-connect")) {
2332        // Do not initiate other outgoing connections when connecting to trusted
2333        // nodes, or when -noconnect is specified.
2334        connOptions.m_use_addrman_outgoing = false;
2335
2336        if (connect.size() != 1 || connect[0] != "0") {
2337            connOptions.m_specified_outgoing = connect;
2338        }
2339        if (!connOptions.m_specified_outgoing.empty() && !connOptions.vSeedNodes.empty()) {
2340            LogInfo("-seednode is ignored when -connect is used");
2341        }
2342
2343        if (args.IsArgSet("-dnsseed") && args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED) && args.IsArgSet("-proxy")) {
2344            LogInfo("-dnsseed is ignored when -connect is used and -proxy is specified");
2345        }
2346    }
2347
2348    const std::string& i2psam_arg = args.GetArg("-i2psam", "");
2349    if (!i2psam_arg.empty()) {
2350        const std::optional<CService> addr{Lookup(i2psam_arg, 7656, fNameLookup)};
2351        if (!addr.has_value() || !addr->IsValid()) {
2352            return InitError(strprintf(_("Invalid -i2psam address or hostname: '%s'"), i2psam_arg));
2353        }
2354        SetProxy(NET_I2P, Proxy{addr.value()});
2355    } else {
2356        if (!onlynets.empty() && g_reachable_nets.Contains(NET_I2P)) {
2357            return InitError(
2358                _("Outbound connections restricted to i2p (-onlynet=i2p) but "
2359                  "-i2psam is not provided"));
2360        }
2361        g_reachable_nets.Remove(NET_I2P);
2362    }
2363
2364    connOptions.m_i2p_accept_incoming = args.GetBoolArg("-i2pacceptincoming", DEFAULT_I2P_ACCEPT_INCOMING);
2365
2366    if (auto conflict = CheckBindingConflicts(connOptions)) {
2367        return InitError(strprintf(
2368            _("Duplicate binding configuration for address %s. "
2369                "Please check your -bind, -bind=...=onion and -whitebind settings."),
2370                    conflict->ToStringAddrPort()));
2371    }
2372
2373    if (args.GetBoolArg("-privatebroadcast", DEFAULT_PRIVATE_BROADCAST)) {
2374        // If -listenonion is set, then NET_ONION may not be reachable now
2375        // but may become reachable later, thus only error here if it is not
2376        // reachable and will not become reachable for sure.
2377        const bool onion_may_become_reachable{listenonion && (!args.IsArgSet("-onlynet") || onlynet_used_with_onion)};
2378        if (!g_reachable_nets.Contains(NET_I2P) &&
2379            !g_reachable_nets.Contains(NET_ONION) &&
2380            !onion_may_become_reachable) {
2381            return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2382                               "but none of Tor or I2P networks is reachable"));
2383        }
2384        if (!connOptions.m_use_addrman_outgoing) {
2385            return InitError(_("Private broadcast of own transactions requested (-privatebroadcast), "
2386                               "but -connect is also configured. They are incompatible because the "
2387                               "private broadcast needs to open new connections to randomly "
2388                               "chosen Tor or I2P peers. Consider using -maxconnections=0 -addnode=... "
2389                               "instead"));
2390        }
2391        if (!proxyRandomize && (g_reachable_nets.Contains(NET_ONION) || onion_may_become_reachable)) {
2392            InitWarning(_("Private broadcast of own transactions requested (-privatebroadcast) and "
2393                          "-proxyrandomize is disabled. Tor circuits for private broadcast connections "
2394                          "may be correlated to other connections over Tor. To reduce this risk, set "
2395                          "-proxyrandomize=1."));
2396        }
2397    }
2398
2399    if (!node.connman->Start(scheduler, connOptions)) {
2400        return false;
2401    }
2402
2403    // ********************************************************* Step 13: finished
2404
2405    // At this point, the RPC is "started", but still in warmup, which means it
2406    // cannot yet be called. Before we make it callable, we need to make sure
2407    // that the RPC's view of the best block is valid and consistent with
2408    // ChainstateManager's active tip.
2409    SetRPCWarmupFinished();
2410
2411    uiInterface.InitMessage(_("Done loading"));
2412
2413    for (const auto& client : node.chain_clients) {
2414        client->start(scheduler);
2415    }
2416
2417    BanMan* banman = node.banman.get();
2418    scheduler.scheduleEvery([banman]{
2419        banman->DumpBanlist();
2420    }, DUMP_BANS_INTERVAL);
2421
2422    if (node.peerman) node.peerman->StartScheduledTasks(scheduler);
2423
2424#if HAVE_SYSTEM
2425    StartupNotify(args);
2426#endif
2427
2428    return true;
2429}
2430
2431bool StartIndexBackgroundSync(NodeContext& node)
2432{
2433    ChainstateManager& chainman = *Assert(node.chainman);
2434    const Chainstate& chainstate = WITH_LOCK(::cs_main, return chainman.ValidatedChainstate());
2435    const CChain& index_chain = chainstate.m_chain;
2436    const int current_height = WITH_LOCK(::cs_main, return index_chain.Height());
2437
2438    // Skip checking data availability if we have not synced any blocks yet
2439    if (current_height > 0) {
2440        // Before starting index sync, verify that all required block data is available
2441        // on disk from each index's current sync position up to the chain tip.
2442        //
2443        // This is done separately for undo and block data: First we verify block + undo
2444        // data existence from tip down to the lowest height required by any index that
2445        // needs undo data (e.g., coinstatsindex, blockfilterindex). Then, if any
2446        // block-only index needs to sync from a lower height than previously covered,
2447        // verify block data existence down to that lower height.
2448        //
2449        // This avoids checking undo data for blocks where no index requires it,
2450        // though currently block and undo data availability are synchronized on disk
2451        // under normal circumstances.
2452        std::optional<const CBlockIndex*> block_start;
2453        std::string block_start_name;
2454        std::optional<const CBlockIndex*> undo_start;
2455        std::string undo_start_name;
2456
2457        for (const auto& index : node.indexes) {
2458            const IndexSummary& summary = index->GetSummary();
2459            if (summary.synced) continue;
2460
2461            // Get the last common block between the index best block and the active chain
2462            const CBlockIndex* pindex = nullptr;
2463            {
2464                LOCK(::cs_main);
2465                pindex = chainman.m_blockman.LookupBlockIndex(summary.best_block_hash);
2466                if (!pindex) {
2467                    LogWarning("Failed to find block manager entry for best block %s from %s, falling back to genesis for index sync",
2468                        summary.best_block_hash.ToString(), summary.name);
2469                } else if (!index_chain.Contains(*pindex)) {
2470                    pindex = index_chain.FindFork(*pindex);
2471                }
2472            }
2473            if (!pindex) {
2474                pindex = index_chain.Genesis();
2475            }
2476
2477            bool need_undo = index->CustomOptions().connect_undo_data;
2478            auto& op_start_index = need_undo ? undo_start : block_start;
2479            auto& name_index = need_undo ? undo_start_name : block_start_name;
2480
2481            if (op_start_index && pindex->nHeight >= op_start_index.value()->nHeight) continue;
2482            op_start_index = pindex;
2483            name_index = summary.name;
2484        }
2485
2486        // Verify all blocks needed to sync to current tip are present including undo data.
2487        if (undo_start) {
2488            LOCK(::cs_main);
2489            if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(undo_start.value()), BlockStatus{BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO})) {
2490                return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data (including undo data). Please disable the index or reindex (which will download the whole blockchain again)", undo_start_name)));
2491            }
2492        }
2493
2494        // Verify all blocks needed to sync to current tip are present unless we already checked all of them above.
2495        if (block_start && !(undo_start && undo_start.value()->nHeight <= block_start.value()->nHeight)) {
2496            LOCK(::cs_main);
2497            if (!chainman.m_blockman.CheckBlockDataAvailability(*index_chain.Tip(), *Assert(block_start.value()), BlockStatus{BLOCK_HAVE_DATA})) {
2498                return InitError(Untranslated(strprintf("%s best block of the index goes beyond pruned data. Please disable the index or reindex (which will download the whole blockchain again)", block_start_name)));
2499            }
2500        }