session_seed.cpp

/**
 * Copyright (c) 2011-2026 libbitcoin developers
 *
 * This file is part of libbitcoin.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <bitcoin/network/sessions/session_seed.hpp>

#include <bitcoin/network/config/config.hpp>
#include <bitcoin/network/log/log.hpp>
#include <bitcoin/network/net.hpp>
#include <bitcoin/network/protocols/protocols.hpp>
#include <bitcoin/network/sessions/session_peer.hpp>

namespace libbitcoin {
namespace network {

#define CLASS session_seed

using namespace system;
using namespace std::placeholders;

// Bind throws (ok).
// Shared pointers required in handler parameters so closures control lifetime.
BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR)
BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED)
BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)

session_seed::session_seed(net& network, uint64_t identifier) NOEXCEPT
  : session_peer(network, identifier, network.network_settings().outbound),
    tracker<session_seed>(network)
{
}

// Properties.
// ----------------------------------------------------------------------------

const session_seed::options_t& session_seed::options() const NOEXCEPT
{
    return static_cast<const options_t&>(session_peer::options());
}

bool session_seed::seeding() const NOEXCEPT
{
    BC_ASSERT(stranded());
    return seeding_;
}

steady_clock::time_point session_seed::completed() const NOEXCEPT
{
    BC_ASSERT(stranded());
    return completed_;
}

// Start/stop sequence.
// ----------------------------------------------------------------------------

void session_seed::start(result_handler&& handler) NOEXCEPT
{
    BC_ASSERT(stranded());

    // Seeding is allowed even with !enable_address configured.

    if (is_zero(network_settings().outbound.connections) ||
        is_zero(network_settings().outbound.connect_batch_size))
    {
        LOGN("Bypassed seeding because outbound connections disabled.");
        handler(error::success);
        unsubscribe_close();
        return;
    }

    if (address_count() >= network_settings().outbound.minimum_address_count())
    {
        LOGN("Bypassed seeding because of sufficient (" << address_count()
            << " of " << network_settings().outbound.minimum_address_count()
            << ") address quantity.");
        handler(error::success);
        unsubscribe_close();
        return;
    }

    if (is_zero(network_settings().outbound.host_pool_capacity))
    {
        LOGN("Cannot seed because no address pool capacity configured.");
        handler(error::seeding_unsuccessful);
        unsubscribe_close();
        return;
    }

    if (network_settings().outbound.seeds.empty())
    {
        LOGN("Cannot seed because no seeds configured");
        handler(error::seeding_unsuccessful);
        unsubscribe_close();
        return;
    }

    session_peer::start(BIND(handle_started, _1, std::move(handler)));
}

void session_seed::handle_started(const code& ec,
    const result_handler& handler) NOEXCEPT
{
    BC_ASSERT(stranded());

    if (ec)
    {
        handler(ec);
        unsubscribe_close();
        return;
    }

    const auto seeds = network_settings().outbound.seeds.size();
    const auto required = network_settings().outbound.minimum_address_count();

    LOGN("Seeding because of insufficient ("
        << address_count() << " of " << required << ") address quantity.");

    // Bogus warning, this pointer is copied into std::bind().
    BC_PUSH_WARNING(NO_UNUSED_LOCAL_SMART_PTR)
    const auto racer = std::make_shared<race>(seeds, required);
    BC_POP_WARNING()

    seeding_ = true;

    // Invoke sufficient on count, invoke complete with all seeds stopped.
    racer->start(move_copy(handler), BIND(stop_seed, _1));

    size_t slot{};
    for (const auto& seed: network_settings().outbound.seeds)
    {
        const auto connector = create_seed_connector(slot++);
        subscribe_stop([=](const code&) NOEXCEPT
        {
            connector->stop();
            return false;
        });

        start_seed(error::success, seed, connector,
            BIND(handle_connect, _1, _2, seed, racer));
    }
}

// Seed sequence.
// ----------------------------------------------------------------------------

// Attempt to connect one seed.
void session_seed::start_seed(const code&, const config::endpoint& seed,
    const connector::ptr& connector, const socket_handler& handler) NOEXCEPT
{
    BC_ASSERT(stranded());
    LOGN("Connecting to seed [" << seed << "]");

    // Guard restartable connector (shutdown delay).
    if (stopped())
    {
        handler(error::service_stopped, nullptr);
        return;
    }

    connector->connect(seed, move_copy(handler));
}

void session_seed::handle_connect(const code& ec, const socket::ptr& socket,
    const config::endpoint& LOG_ONLY(seed), const race::ptr& racer) NOEXCEPT
{
    BC_ASSERT(stranded());

    if (ec)
    {
        BC_ASSERT_MSG(!socket || socket->stopped(), "unexpected socket");
        LOGN("Failed to connect seed address [" << seed << "] " << ec.message());
        racer->finish(address_count());
        return;
    }

    const auto channel = create_channel(socket);
    std::dynamic_pointer_cast<channel_peer>(channel)->set_quiet();

    start_channel(channel,
        BIND(handle_channel_start, _1, channel),
        BIND(handle_channel_stop, _1, channel, racer));
}

void session_seed::attach_handshake(const channel::ptr& channel,
    result_handler&& handler) NOEXCEPT
{
    BC_ASSERT_MSG(channel->stranded(), "channel strand");
    BC_ASSERT_MSG(!channel->held(), "gate held before attach");

    // Tx relay is always disabled for seeding.
    using namespace messages::peer;
    constexpr auto relay = false;

    // Protocol must pause the channel after receiving version and verack.
    const auto self = shared_from_this();
    const auto reject = network_settings().enable_reject;
    const auto address_v2 = network_settings().enable_address_v2;

    // Address v2 can be disabled, independent of version.
    if (is_configured(level::bip155) && address_v2)
        channel->attach<protocol_version_70016>(self, relay,
            reject)->shake(std::move(handler));

    // Protocol versions are cumulative, but reject is deprecated.
    else if (is_configured(level::bip61) && reject)
        channel->attach<protocol_version_70002>(self, relay,
            reject)->shake(std::move(handler));

    else if (is_configured(level::bip37))
        channel->attach<protocol_version_70001>(self,
            relay)->shake(std::move(handler));

    else if (is_configured(level::version_message))
        channel->attach<protocol_version_106>(
            self)->shake(std::move(handler));
}

void session_seed::handle_channel_start(const code& ec,
    const channel::ptr& LOG_ONLY(channel)) NOEXCEPT
{
    BC_ASSERT(stranded());

    if (ec)
    {
        LOGN("Seed start [" << channel->endpoint() << "] " << ec.message());
    }
}

void session_seed::attach_protocols(const channel::ptr& channel) NOEXCEPT
{
    BC_ASSERT_MSG(channel->stranded(), "channel strand");

    using namespace messages::peer;
    const auto self = shared_from_this();
    const auto alert = network_settings().enable_alert;
    const auto reject = network_settings().enable_reject;
    const auto address_v2 = network_settings().enable_address_v2;
    const auto peer = std::dynamic_pointer_cast<channel_peer>(channel);

    // Alert is deprecated, independent of version.
    if (peer->is_negotiated(level::alert_message) && alert)
        channel->attach<protocol_alert_311>(self)->start();

    // Reject is deprecated, independent of version.
    if (peer->is_negotiated(level::bip61) && reject)
        channel->attach<protocol_reject_70002>(self)->start();

    if (peer->is_negotiated(level::bip31))
        channel->attach<protocol_ping_60001>(self)->start();
    else if (peer->is_negotiated(level::version_message))
        channel->attach<protocol_ping_106>(self)->start();

    // Seed protocol stops upon completion, causing session removal.
    if (peer->is_negotiated(level::bip155) && address_v2)
    {
        channel->attach<protocol_seed_70016>(self)->start();
    }
    else if (peer->is_negotiated(level::get_address_message))
    {
        channel->attach<protocol_seed_209>(self)->start();
    }
    else if (peer->is_negotiated(level::version_message))
    {
        ////channel->attach<protocol_seed_106>(self)->start();
    }
}

void session_seed::handle_channel_stop(const code& LOG_ONLY(ec),
    const channel::ptr& LOG_ONLY(channel), const race::ptr& racer) NOEXCEPT
{
    BC_ASSERT(stranded());
    LOGN("Seed stop [" << channel->endpoint() << "] " << ec.message());
    racer->finish(address_count());
}

void session_seed::stop_seed(const code&) NOEXCEPT
{
    BC_ASSERT(stranded());

    LOGN("Seed session complete.");
    completed_ = steady_clock::now();
    seeding_ = false;
    unsubscribe_close();
}

BC_POP_WARNING()
BC_POP_WARNING()
BC_POP_WARNING()

} // namespace network
} // namespace libbitcoin