protocol_block_out_106.cpp

/**
 * Copyright (c) 2011-2026 libbitcoin developers (see AUTHORS)
 *
 * 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/node/protocols/protocol_block_out_106.hpp>

#include <chrono>
#include <bitcoin/node/define.hpp>

namespace libbitcoin {
namespace node {

#define CLASS protocol_block_out_106

using namespace system;
using namespace network;
using namespace std::chrono;
using namespace std::placeholders;

BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED)
BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR)

// start/stop
// ----------------------------------------------------------------------------

void protocol_block_out_106::start() NOEXCEPT
{
    BC_ASSERT(stranded());

    if (started())
        return;

    // Events subscription is asynchronous, events may be missed.
    subscribe_events(BIND(handle_event, _1, _2, _3));
    SUBSCRIBE_CHANNEL(get_data, handle_receive_get_data, _1, _2);
    SUBSCRIBE_CHANNEL(get_blocks, handle_receive_get_blocks, _1, _2);
    protocol_peer::start();
}

void protocol_block_out_106::stopping(const code& ec) NOEXCEPT
{
    // Unsubscriber race is ok.
    BC_ASSERT(stranded());
    unsubscribe_events();
    protocol_peer::stopping(ec);
}

// handle events (block)
// ----------------------------------------------------------------------------

bool protocol_block_out_106::handle_event(const code&, chase event_,
    event_value value) NOEXCEPT
{
    // Do not pass ec to stopped as it is not a call status.
    if (stopped() || superseded())
        return false;

    switch (event_)
    {
        case chase::block:
        {
            // value is organized block pk.
            BC_ASSERT(std::holds_alternative<header_t>(value));
            POST(do_announce, std::get<header_t>(value));
            break;
        }
        default:
        {
            break;
        }
    }

    return true;
}

// Outbound (block).
// ----------------------------------------------------------------------------

bool protocol_block_out_106::superseded() const NOEXCEPT
{
    return false;
}

bool protocol_block_out_106::do_announce(header_t link) NOEXCEPT
{
    BC_ASSERT(stranded());
    if (stopped())
        return false;

    // Don't announce to peer that announced to us.
    const auto hash = archive().get_header_key(link);
    if (was_announced(hash))
        return true;

    if (hash == null_hash)
    {
        ////stop(fault(system::error::not_found));
        LOGF("Organized block not found.");
        return true;
    }

    // bip144: get_data uses witness type_id but inv does not.
    const inventory inv{ { { type_id::block, hash } } };
    SEND(inv, handle_send, _1);
    return true;
}

// Inbound (get_blocks).
// ----------------------------------------------------------------------------

bool protocol_block_out_106::handle_receive_get_blocks(const code& ec,
    const get_blocks::cptr& message) NOEXCEPT
{
    BC_ASSERT(stranded());
    if (stopped(ec))
        return false;

    LOGP("Get blocks above " << encode_hash(message->start_hash())
        << " from [" << opposite() << "].");

    SEND(create_inventory(*message), handle_send, _1);
    return true;
}

// Inbound (get_data).
// ----------------------------------------------------------------------------

bool protocol_block_out_106::handle_receive_get_data(const code& ec,
    const get_data::cptr& message) NOEXCEPT
{
    BC_ASSERT(stranded());
    if (stopped(ec))
        return false;

    if (!node_witness_ && message->any_witness())
    {
        LOGR("Unsupported witness get_data from [" << opposite() << "].");
        stop(network::error::protocol_violation);
        return false;
    }

    const auto size = message->count(get_data::selector::blocks);
    if (is_zero(size))
        return true;

    const auto total = ceilinged_add(backlog_.size(), size);
    if (total > messages::peer::max_inventory)
    {
        LOGR("Blocks requested (" << total << ") exceeds inv limit ["
            << opposite() << "].");
        stop(network::error::protocol_violation);
        return false;
    }

    // Satoshi sends overlapping get_data requests, but assumes that the
    // recipient is blocking *all traffic* until the previous is completed.
    // So to prevent frequent drops of satoshi peers, and not let one protocol
    // block all others, we must accumulate the requests into a backlog. If the
    // backlog exceeds the *individual* message limit we drop the peer.
    const auto idle = backlog_.empty();
    if (!allow_overlapped_ && !idle)
    {
        LOGR("Overlapping block requests [" << opposite() << "].");
        stop(network::error::protocol_violation);
        return false;
    }

    // Append the new inventory the request queue.
    merge_inventory(message->items);

    // Bump the idle async send loop if no pending send.
    if (idle)
        send_block(error::success);

    return true;
}

// Outbound (block).
// ----------------------------------------------------------------------------

void protocol_block_out_106::send_block(const code& ec) NOEXCEPT
{
    BC_ASSERT(stranded());
    if (stopped(ec))
        return;

    if (backlog_.empty()) return;
    const auto& item = backlog_.front();
    const auto witness = item.is_witness_type();
    if (!node_witness_ && witness)
    {
        LOGR("Unsupported witness get_data from [" << opposite() << "].");
        stop(network::error::protocol_violation);
        return;
    }

    const auto& query = archive();
    const auto start = logger::now();
    const auto ptr = query.get_block(query.to_header(item.hash), witness);
    if (!ptr)
    {
        LOGR("Requested block " << encode_hash(item.hash) << " from ["
            << opposite() << "] not found.");

        // This block could not have been advertised to the peer.
        stop(system::error::not_found);
        return;
    }

    backlog_.pop_front();
    span<microseconds>(events::block_usecs, start);
    SEND(messages::peer::block{ ptr }, send_block, _1);
}

// utilities
// ----------------------------------------------------------------------------

void protocol_block_out_106::merge_inventory(
    const inventory_items& items) NOEXCEPT
{
    for (const auto& item: items)
        if (item.is_block())
            backlog_.push_back(item);
}

protocol_block_out_106::inventory protocol_block_out_106::create_inventory(
    const get_blocks& locator) const NOEXCEPT
{
    // Empty response implies complete (success).
    if (!is_current(true))
        return {};

    return inventory::factory
    (
        archive().get_blocks(locator.start_hashes, locator.stop_hash,
            messages::peer::max_get_blocks), type_id::block
    );
}

BC_POP_WARNING()
BC_POP_WARNING()

} // namespace node
} // namespace libbitcoin