premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

improve type-safety of the severity parameter to peer_connection::disconnect()

This commit is contained in:
Arvid Norberg 2018-09-04 20:17:26 +02:00 committed by Arvid Norberg
parent 9b2f6042bb
commit fc7b61a6f3
16 changed files with 122 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/libtorrent/http_seed_connection.hpp
View File

@ -72,7 +72,8 @@ namespace libtorrent {
std::string const& url() const override { return m_url; }
void get_specific_peer_info(peer_info& p) const override;
void disconnect(error_code const& ec, operation_t op, int error = 0) override;
void disconnect(error_code const& ec, operation_t op
, disconnect_severity_t error = peer_connection_interface::normal) override;
void write_request(peer_request const& r) override;

3
include/libtorrent/peer_connection.hpp
View File

@ -65,6 +65,7 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/vector.hpp"
#include "libtorrent/disk_interface.hpp"
#include "libtorrent/piece_picker.hpp" // for picker_options_t
#include "libtorrent/units.hpp"
#include <ctime>
#include <algorithm>
@ -455,7 +456,7 @@ namespace aux {
// this will cause this peer_connection to be disconnected.
void disconnect(error_code const& ec
, operation_t op, int error = 0) override;
, operation_t op, disconnect_severity_t = peer_connection_interface::normal) override;
// called when a connect attempt fails (not when an
// established connection fails)

3
include/libtorrent/peer_connection_handle.hpp
View File

@ -79,7 +79,8 @@ struct TORRENT_EXPORT peer_connection_handle
tcp::endpoint const& remote() const;
tcp::endpoint local_endpoint() const;
void disconnect(error_code const& ec, operation_t op, int error = 0);
void disconnect(error_code const& ec, operation_t op
, disconnect_severity_t = peer_connection_interface::normal);
bool is_disconnecting() const;
bool is_connecting() const;
bool is_outgoing() const;

9
include/libtorrent/peer_connection_interface.hpp
View File

@ -38,19 +38,26 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/error_code.hpp"
#include "libtorrent/alert_types.hpp"
#include "libtorrent/operations.hpp" // for operation_t enum
#include "libtorrent/units.hpp"
namespace libtorrent {
struct torrent_peer;
class stat;
using disconnect_severity_t = aux::strong_typedef<std::uint8_t, struct disconnect_severity_tag>;
// TODO: make this interface smaller!
struct TORRENT_EXTRA_EXPORT peer_connection_interface
{
static constexpr disconnect_severity_t normal{0};
static constexpr disconnect_severity_t failure{1};
static constexpr disconnect_severity_t peer_error{2};
virtual tcp::endpoint const& remote() const = 0;
virtual tcp::endpoint local_endpoint() const = 0;
virtual void disconnect(error_code const& ec
, operation_t op, int error = 0) = 0;
, operation_t op, disconnect_severity_t = peer_connection_interface::normal) = 0;
virtual peer_id const& pid() const = 0;
virtual peer_id our_pid() const = 0;
virtual void set_holepunch_mode() = 0;

2
include/libtorrent/torrent.hpp
View File

@ -634,7 +634,7 @@ namespace libtorrent {
void retry_web_seed(peer_connection* p, boost::optional<seconds32> retry = boost::none);
void remove_web_seed_conn(peer_connection* p, error_code const& ec
, operation_t op, int error = 0);
, operation_t op, disconnect_severity_t error = peer_connection_interface::normal);
std::set<std::string> web_seeds(web_seed_entry::type_t type) const;

2
include/libtorrent/web_peer_connection.hpp
View File

@ -74,7 +74,7 @@ namespace libtorrent {
void get_specific_peer_info(peer_info& p) const override;
void disconnect(error_code const& ec
, operation_t op, int error = 0) override;
, operation_t op, disconnect_severity_t error = peer_connection_interface::normal) override;
void write_request(peer_request const& r) override;

80
src/bt_peer_connection.cpp
View File

@ -794,7 +794,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1)
{
disconnect(errors::invalid_choke, operation_t::bittorrent, 2);
disconnect(errors::invalid_choke, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -844,7 +844,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1)
{
disconnect(errors::invalid_unchoke, operation_t::bittorrent, 2);
disconnect(errors::invalid_unchoke, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -864,7 +864,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1)
{
disconnect(errors::invalid_interested, operation_t::bittorrent, 2);
disconnect(errors::invalid_interested, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -893,7 +893,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1)
{
disconnect(errors::invalid_not_interested, operation_t::bittorrent, 2);
disconnect(errors::invalid_not_interested, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -913,7 +913,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 5)
{
disconnect(errors::invalid_have, operation_t::bittorrent, 2);
disconnect(errors::invalid_have, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -945,7 +945,7 @@ namespace {
if (t->valid_metadata()
&& m_recv_buffer.packet_size() - 1 != (t->torrent_file().num_pieces() + CHAR_BIT - 1) / CHAR_BIT)
{
disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, 2);
disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, peer_error);
return;
}
@ -972,7 +972,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 13)
{
disconnect(errors::invalid_request, operation_t::bittorrent, 2);
disconnect(errors::invalid_request, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -1023,13 +1023,13 @@ namespace {
if (list_size > m_recv_buffer.packet_size() - 13)
{
disconnect(errors::invalid_hash_list, operation_t::bittorrent, 2);
disconnect(errors::invalid_hash_list, operation_t::bittorrent, peer_error);
return;
}
if (m_recv_buffer.packet_size() - 13 - list_size > t->block_size())
{
disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
disconnect(errors::packet_too_large, operation_t::bittorrent, peer_error);
return;
}
}
@ -1040,7 +1040,7 @@ namespace {
{
if (m_recv_buffer.packet_size() - 9 > t->block_size())
{
disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
disconnect(errors::packet_too_large, operation_t::bittorrent, peer_error);
return;
}
}
@ -1130,7 +1130,7 @@ namespace {
if (bdecode(recv_buffer.begin() + 13, recv_buffer.begin() + 13 + list_size
, hash_list, ec) != 0)
{
disconnect(errors::invalid_hash_piece, operation_t::bittorrent, 2);
disconnect(errors::invalid_hash_piece, operation_t::bittorrent, peer_error);
return;
}
@ -1138,7 +1138,7 @@ namespace {
// [ [node-index, hash], [node-index, hash], ... ]
if (hash_list.type() != bdecode_node::list_t)
{
disconnect(errors::invalid_hash_list, operation_t::bittorrent, 2);
disconnect(errors::invalid_hash_list, operation_t::bittorrent, peer_error);
return;
}
@ -1157,7 +1157,7 @@ namespace {
}
if (!nodes.empty() && !t->add_merkle_nodes(nodes, p.piece))
{
disconnect(errors::invalid_hash_piece, operation_t::bittorrent, 2);
disconnect(errors::invalid_hash_piece, operation_t::bittorrent, peer_error);
return;
}
}
@ -1177,7 +1177,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 13)
{
disconnect(errors::invalid_cancel, operation_t::bittorrent, 2);
disconnect(errors::invalid_cancel, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -1205,7 +1205,7 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() != 3)
{
disconnect(errors::invalid_dht_port, operation_t::bittorrent, 2);
disconnect(errors::invalid_dht_port, operation_t::bittorrent, peer_error);
return;
}
if (!m_recv_buffer.packet_finished()) return;
@ -1231,7 +1231,7 @@ namespace {
received_bytes(0, received);
if (!m_supports_fast)
{
disconnect(errors::invalid_suggest, operation_t::bittorrent, 2);
disconnect(errors::invalid_suggest, operation_t::bittorrent, peer_error);
return;
}
@ -1251,7 +1251,7 @@ namespace {
received_bytes(0, received);
if (!m_supports_fast)
{
disconnect(errors::invalid_have_all, operation_t::bittorrent, 2);
disconnect(errors::invalid_have_all, operation_t::bittorrent, peer_error);
return;
}
incoming_have_all();
@ -1264,7 +1264,7 @@ namespace {
received_bytes(0, received);
if (!m_supports_fast)
{
disconnect(errors::invalid_have_none, operation_t::bittorrent, 2);
disconnect(errors::invalid_have_none, operation_t::bittorrent, peer_error);
return;
}
incoming_have_none();
@ -1277,7 +1277,7 @@ namespace {
received_bytes(0, received);
if (!m_supports_fast)
{
disconnect(errors::invalid_reject, operation_t::bittorrent, 2);
disconnect(errors::invalid_reject, operation_t::bittorrent, peer_error);
return;
}
@ -1301,7 +1301,7 @@ namespace {
received_bytes(0, received);
if (!m_supports_fast)
{
disconnect(errors::invalid_allow_fast, operation_t::bittorrent, 2);
disconnect(errors::invalid_allow_fast, operation_t::bittorrent, peer_error);
return;
}
@ -1540,13 +1540,13 @@ namespace {
received_bytes(0, received);
if (m_recv_buffer.packet_size() < 2)
{
disconnect(errors::invalid_extended, operation_t::bittorrent, 2);
disconnect(errors::invalid_extended, operation_t::bittorrent, peer_error);
return;
}
if (associated_torrent().expired())
{
disconnect(errors::invalid_extended, operation_t::bittorrent, 2);
disconnect(errors::invalid_extended, operation_t::bittorrent, peer_error);
return;
}
@ -1646,7 +1646,7 @@ namespace {
}
#endif
disconnect(errors::invalid_message, operation_t::bittorrent, 2);
disconnect(errors::invalid_message, operation_t::bittorrent, peer_error);
}
void bt_peer_connection::on_extended_handshake()
@ -2366,7 +2366,7 @@ namespace {
if (!m_recv_buffer.crypto_packet_finished()
&& m_recv_buffer.crypto_packet_size() > 1025 * 1024)
{
disconnect(errors::packet_too_large, operation_t::encryption, 2);
disconnect(errors::packet_too_large, operation_t::encryption, peer_error);
return;
}
@ -2481,7 +2481,7 @@ namespace {
received_bytes(0, int(bytes_transferred));
if (m_recv_buffer.packet_finished())
disconnect(errors::sync_hash_not_found, operation_t::bittorrent, 1);
disconnect(errors::sync_hash_not_found, operation_t::bittorrent, failure);
return;
}
@ -2518,7 +2518,7 @@ namespace {
m_sync_bytes_read += bytes_processed;
if (m_sync_bytes_read >= 512)
{
disconnect(errors::sync_hash_not_found, operation_t::encryption, 1);
disconnect(errors::sync_hash_not_found, operation_t::encryption, failure);
return;
}
@ -2594,7 +2594,7 @@ namespace {
if (!m_rc4)
{
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
}
@ -2604,7 +2604,7 @@ namespace {
static const char sh_vc[] = {0,0,0,0, 0,0,0,0};
if (!std::equal(sh_vc, sh_vc + 8, recv_buffer.begin() + 20))
{
disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
disconnect(errors::invalid_encryption_constant, operation_t::encryption, peer_error);
return;
}
@ -2628,7 +2628,7 @@ namespace {
{
received_bytes(0, int(bytes_transferred));
if (m_recv_buffer.packet_finished())
disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
disconnect(errors::invalid_encryption_constant, operation_t::encryption, peer_error);
return;
}
@ -2659,7 +2659,7 @@ namespace {
if (m_sync_bytes_read >= 512)
{
disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
disconnect(errors::invalid_encryption_constant, operation_t::encryption, peer_error);
return;
}
@ -2747,7 +2747,7 @@ namespace {
if (crypto_select == 0)
{
disconnect(errors::unsupported_encryption_mode, operation_t::encryption, 1);
disconnect(errors::unsupported_encryption_mode, operation_t::encryption, failure);
return;
}
@ -2763,7 +2763,7 @@ namespace {
if (crypto_field == 0)
{
// we don't allow any of the offered encryption levels
disconnect(errors::unsupported_encryption_mode_selected, operation_t::encryption, 2);
disconnect(errors::unsupported_encryption_mode_selected, operation_t::encryption, peer_error);
return;
}
@ -2776,7 +2776,7 @@ namespace {
int const len_pad = aux::read_int16(recv_buffer);
if (len_pad < 0 || len_pad > 512)
{
disconnect(errors::invalid_pad_size, operation_t::encryption, 2);
disconnect(errors::invalid_pad_size, operation_t::encryption, peer_error);
return;
}
@ -2821,7 +2821,7 @@ namespace {
if (len_ia < 0)
{
disconnect(errors::invalid_encrypt_handshake, operation_t::encryption, 2);
disconnect(errors::invalid_encrypt_handshake, operation_t::encryption, peer_error);
return;
}
@ -2955,7 +2955,7 @@ namespace {
peer_log(peer_log_alert::info, "ENCRYPTION"
, "SSL peers are not allowed to use any other encryption");
#endif
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
}
#endif // TORRENT_USE_OPENSSL
@ -2974,7 +2974,7 @@ namespace {
// handshake by this point
if (m_encrypted || is_outgoing())
{
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
}
@ -2986,7 +2986,7 @@ namespace {
TORRENT_ASSERT(!m_recv_buffer.packet_finished());
return;
#else
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
#endif // TORRENT_DISABLE_ENCRYPTION
}
@ -3080,7 +3080,7 @@ namespace {
#ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ERROR", "received invalid info_hash");
#endif
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
}
@ -3274,7 +3274,7 @@ namespace {
{
// packet too large
received_bytes(0, int(bytes_transferred));
disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
disconnect(errors::packet_too_large, operation_t::bittorrent, peer_error);
return;
}
@ -3305,7 +3305,7 @@ namespace {
if (!t)
{
received_bytes(0, int(bytes_transferred));
disconnect(errors::torrent_removed, operation_t::bittorrent, 1);
disconnect(errors::torrent_removed, operation_t::bittorrent, failure);
return;
}
#if TORRENT_USE_ASSERTS

18
src/http_seed_connection.cpp
View File

@ -80,7 +80,7 @@ namespace libtorrent {
}
void http_seed_connection::disconnect(error_code const& ec
, operation_t const op, int const error)
, operation_t const op, disconnect_severity_t const error)
{
if (is_disconnecting()) return;
@ -231,7 +231,7 @@ namespace libtorrent {
if (m_requests.empty())
{
received_bytes(0, int(bytes_transferred));
disconnect(errors::http_error, operation_t::bittorrent, 2);
disconnect(errors::http_error, operation_t::bittorrent, peer_error);
return;
}
@ -255,7 +255,7 @@ namespace libtorrent {
if (parse_error)
{
received_bytes(0, int(bytes_transferred));
disconnect(errors::http_parse_error, operation_t::bittorrent, 2);
disconnect(errors::http_parse_error, operation_t::bittorrent, peer_error);
return;
}
@ -288,7 +288,7 @@ namespace libtorrent {
, error_msg);
}
received_bytes(0, int(bytes_transferred));
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, failure);
return;
}
if (!m_parser.header_finished())
@ -312,13 +312,13 @@ namespace libtorrent {
if (location.empty())
{
// we should not try this server again.
t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, peer_error);
return;
}
// add the redirected url and remove the current one
t->add_web_seed(location, web_seed_entry::http_seed);
t->remove_web_seed_conn(this, errors::redirecting, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, errors::redirecting, operation_t::bittorrent, peer_error);
return;
}
@ -337,14 +337,14 @@ namespace libtorrent {
{
received_bytes(0, int(bytes_transferred));
// we should not try this server again.
t->remove_web_seed_conn(this, errors::no_content_length, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, errors::no_content_length, operation_t::bittorrent, peer_error);
return;
}
if (m_response_left != front_request.length)
{
received_bytes(0, int(bytes_transferred));
// we should not try this server again.
t->remove_web_seed_conn(this, errors::invalid_range, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, errors::invalid_range, operation_t::bittorrent, peer_error);
return;
}
m_body_start = m_parser.body_start();
@ -423,7 +423,7 @@ namespace libtorrent {
received_bytes(0, int(bytes_transferred));
// temporarily unavailable, retry later
t->retry_web_seed(this, seconds32(retry_time));
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, failure);
return;
}

66
src/peer_connection.cpp
View File

@ -64,6 +64,7 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/aux_/has_block.hpp"
#include "libtorrent/aux_/time.hpp"
#include "libtorrent/buffer.hpp"
#include "libtorrent/aux_/array.hpp"
#if TORRENT_USE_ASSERTS
#include <set>
@ -105,6 +106,10 @@ namespace libtorrent {
constexpr piece_index_t piece_block_progress::invalid_index;
constexpr disconnect_severity_t peer_connection_interface::normal;
constexpr disconnect_severity_t peer_connection_interface::failure;
constexpr disconnect_severity_t peer_connection_interface::peer_error;
#if TORRENT_USE_ASSERTS
bool peer_connection::is_single_thread() const
{
@ -249,12 +254,12 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "PEER_ERROR" ,"error: %s"
, e.what());
#endif
disconnect(error_code(), operation_t::unknown, 2);
disconnect(error_code(), operation_t::unknown, peer_error);
}
void peer_connection::on_error(error_code const& ec)
{
disconnect(ec, operation_t::unknown, 2);
disconnect(ec, operation_t::unknown, peer_error);
}
void peer_connection::increase_est_reciprocation_rate()
@ -1247,7 +1252,7 @@ namespace libtorrent {
m_ses.ban_ip(m_remote.address());
}
#endif
disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
disconnect(errors::invalid_info_hash, operation_t::bittorrent, failure);
return;
}
@ -1269,7 +1274,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ATTACH", "rejected connection to paused torrent");
#endif
disconnect(errors::torrent_paused, operation_t::bittorrent, 2);
disconnect(errors::torrent_paused, operation_t::bittorrent, peer_error);
return;
}
@ -1283,7 +1288,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ATTACH", "rejected regular connection to i2p torrent");
#endif
disconnect(errors::peer_banned, operation_t::bittorrent, 2);
disconnect(errors::peer_banned, operation_t::bittorrent, peer_error);
return;
}
#endif // TORRENT_USE_I2P
@ -1884,7 +1889,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "ERROR", "have-metadata have_piece: %d size: %d"
, static_cast<int>(index), m_have_piece.size());
#endif
disconnect(errors::invalid_have, operation_t::bittorrent, 2);
disconnect(errors::invalid_have, operation_t::bittorrent, peer_error);
return;
}
@ -2008,7 +2013,7 @@ namespace libtorrent {
// if we got an invalid message, abort
if (index >= m_have_piece.end_index() || index < piece_index_t(0))
{
disconnect(errors::invalid_dont_have, operation_t::bittorrent, 2);
disconnect(errors::invalid_dont_have, operation_t::bittorrent, peer_error);
return;
}
@ -2085,7 +2090,7 @@ namespace libtorrent {
, m_have_piece.size());
}
#endif
disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, 2);
disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, peer_error);
return;
}
@ -2427,7 +2432,7 @@ namespace libtorrent {
if (m_num_invalid_requests > 300 && !m_peer_choked
&& can_disconnect(errors::too_many_requests_when_choked))
{
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, peer_error);
return;
}
#ifndef TORRENT_DISABLE_LOGGING
@ -2449,7 +2454,7 @@ namespace libtorrent {
if (m_choked && fast_idx != -1 && m_accept_fast_piece_cnt[fast_idx] >= 3 * blocks_per_piece
&& can_disconnect(errors::too_many_requests_when_choked))
{
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, peer_error);
return;
}
@ -2468,7 +2473,7 @@ namespace libtorrent {
if (aux::time_now() - seconds(2) > m_last_choke
&& can_disconnect(errors::too_many_requests_when_choked))
{
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, peer_error);
return;
}
}
@ -2556,7 +2561,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "INVALID_PIECE", "piece: %d s: %d l: %d"
, static_cast<int>(r.piece), r.start, r.length);
#endif
disconnect(errors::invalid_piece, operation_t::bittorrent, 2);
disconnect(errors::invalid_piece, operation_t::bittorrent, peer_error);
return;
}
@ -4081,7 +4086,7 @@ namespace libtorrent {
m_peer_info->supports_utp = false;
// reconnect immediately using TCP
fast_reconnect(true);
disconnect(e, operation_t::connect, 0);
disconnect(e, operation_t::connect, normal);
if (t && m_peer_info)
{
std::weak_ptr<torrent> weak_t = t;
@ -4121,14 +4126,14 @@ namespace libtorrent {
}
#endif
disconnect(e, operation_t::connect, 1);
disconnect(e, operation_t::connect, failure);
}
// the error argument defaults to 0, which means deliberate disconnect
// 1 means unexpected disconnect/error
// 2 protocol error (client sent something invalid)
void peer_connection::disconnect(error_code const& ec
, operation_t const op, int const error)
, operation_t const op, disconnect_severity_t const error)
{
TORRENT_ASSERT(is_single_thread());
#if TORRENT_USE_ASSERTS
@ -4154,21 +4159,10 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING
if (should_log(peer_log_alert::info)) try
{
switch (error)
{
case 0:
peer_log(peer_log_alert::info, "CONNECTION_CLOSED", "op: %d error: %s"
, static_cast<int>(op), ec.message().c_str());
break;
case 1:
peer_log(peer_log_alert::info, "CONNECTION_FAILED", "op: %d error: %s"
, static_cast<int>(op), ec.message().c_str());
break;
case 2:
peer_log(peer_log_alert::info, "PEER_ERROR" ,"op: %d error: %s"
, static_cast<int>(op), ec.message().c_str());
break;
}
static aux::array<char const*, 3, disconnect_severity_t> const str{{{
"CONNECTION_CLOSED", "CONNECTION_FAILED", "PEER_ERROR"}}};
peer_log(peer_log_alert::info, str[error], "op: %d error: %s"
, static_cast<int>(op), ec.message().c_str());
if (ec == boost::asio::error::eof
&& !in_handshake()
@ -4194,7 +4188,7 @@ namespace libtorrent {
// we cannot do this in a constructor
TORRENT_ASSERT(m_in_constructor == false);
if (error > 0)
if (error > normal)
{
m_failed = true;
}
@ -4211,7 +4205,7 @@ namespace libtorrent {
// TORRENT_ASSERT(ec != error::invalid_argument || !m_outgoing);
m_counters.inc_stats_counter(counters::disconnected_peers);
if (error == 2) m_counters.inc_stats_counter(counters::error_peers);
if (error == peer_error) m_counters.inc_stats_counter(counters::error_peers);
if (ec == error::connection_reset)
m_counters.inc_stats_counter(counters::connreset_peers);
@ -4264,7 +4258,7 @@ namespace libtorrent {
if (ec == errors::timed_out_no_handshake)
m_counters.inc_stats_counter(counters::connect_timeouts);
if (error > 0)
if (error > normal)
{
if (is_utp(*m_socket)) m_counters.inc_stats_counter(counters::error_utp_peers);
else m_counters.inc_stats_counter(counters::error_tcp_peers);
@ -4337,14 +4331,14 @@ namespace libtorrent {
{
if (ec)
{
if ((error > 1 || ec.category() == socks_category())
if ((error > failure || ec.category() == socks_category())
&& t->alerts().should_post<peer_error_alert>())
{
t->alerts().emplace_alert<peer_error_alert>(handle, remote()
, pid(), op, ec);
}
if (error <= 1 && t->alerts().should_post<peer_disconnected_alert>())
if (error <= failure && t->alerts().should_post<peer_disconnected_alert>())
{
t->alerts().emplace_alert<peer_disconnected_alert>(handle
, remote(), pid(), op, m_socket->type(), ec, close_reason);
@ -6110,7 +6104,7 @@ namespace libtorrent {
if (m_remote == m_socket->local_endpoint(ec))
{
disconnect(errors::self_connection, operation_t::bittorrent, 1);
disconnect(errors::self_connection, operation_t::bittorrent, failure);
return;
}

3
src/peer_connection_handle.cpp
View File

@ -169,7 +169,8 @@ tcp::endpoint peer_connection_handle::local_endpoint() const
return pc->local_endpoint();
}
void peer_connection_handle::disconnect(error_code const& ec, operation_t op, int error)
void peer_connection_handle::disconnect(error_code const& ec, operation_t const op
, disconnect_severity_t const error)
{
std::shared_ptr<peer_connection> pc = native_handle();
TORRENT_ASSERT(pc);

4
src/peer_list.cpp
View File

@ -643,9 +643,9 @@ namespace libtorrent {
if (self_connection)
{
c.disconnect(errors::self_connection, operation_t::bittorrent, 1);
c.disconnect(errors::self_connection, operation_t::bittorrent, peer_connection_interface::failure);
TORRENT_ASSERT(i->connection->peer_info_struct() == i);
i->connection->disconnect(errors::self_connection, operation_t::bittorrent, 1);
i->connection->disconnect(errors::self_connection, operation_t::bittorrent, peer_connection_interface::failure);
TORRENT_ASSERT(i->connection == nullptr);
return false;
}

7
src/torrent.cpp
View File

@ -6552,7 +6552,7 @@ bool is_downloading_state(int const st)
TORRENT_CATCH (std::exception const&)
{
TORRENT_ASSERT(m_iterating_connections == 0);
c->disconnect(errors::no_error, operation_t::bittorrent, 1);
c->disconnect(errors::no_error, operation_t::bittorrent, peer_connection_interface::failure);
return false;
}
@ -7215,7 +7215,8 @@ bool is_downloading_state(int const st)
}
}
for (auto& p : seeds)
p->disconnect(errors::torrent_finished, operation_t::bittorrent, 0);
p->disconnect(errors::torrent_finished, operation_t::bittorrent
, peer_connection_interface::normal);
}
if (m_abort) return;
@ -9825,7 +9826,7 @@ bool is_downloading_state(int const st)
}
void torrent::remove_web_seed_conn(peer_connection* p, error_code const& ec
, operation_t const op, int const error)
, operation_t const op, disconnect_severity_t const error)
{
auto const i = std::find_if(m_web_seeds.begin(), m_web_seeds.end()
, [p] (web_seed_t const& ws) { return ws.peer_info.connection == p; });

6
src/ut_metadata.cpp
View File

@ -303,7 +303,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "packet too big %d", length);
#endif
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, peer_connection_interface::peer_error);
return true;
}
@ -317,7 +317,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "not a dictionary");
#endif
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, peer_connection_interface::peer_error);
return true;
}
@ -330,7 +330,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "missing or invalid keys");
#endif
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, peer_connection_interface::peer_error);
return true;
}
// TODO: make this an enum class

4
src/ut_pex.cpp
View File

@ -262,7 +262,7 @@ namespace libtorrent { namespace {
if (length > 500 * 1024)
{
m_pc.disconnect(errors::pex_message_too_large, operation_t::bittorrent, 2);
m_pc.disconnect(errors::pex_message_too_large, operation_t::bittorrent, peer_connection_interface::peer_error);
return true;
}
@ -287,7 +287,7 @@ namespace libtorrent { namespace {
int const ret = bdecode(body.begin(), body.end(), pex_msg, ec);
if (ret != 0 || pex_msg.type() != bdecode_node::dict_t)
{
m_pc.disconnect(errors::invalid_pex_message, operation_t::bittorrent, 2);
m_pc.disconnect(errors::invalid_pex_message, operation_t::bittorrent, peer_connection_interface::peer_error);
return true;
}

24
src/web_peer_connection.cpp
View File

@ -177,7 +177,7 @@ void web_peer_connection::on_connected()
}
void web_peer_connection::disconnect(error_code const& ec
, operation_t op, int error)
, operation_t op, disconnect_severity_t const error)
{
if (is_disconnecting()) return;
@ -241,7 +241,7 @@ void web_peer_connection::disconnect(error_code const& ec
m_requests.clear();
}
if (m_web && !m_web->supports_keepalive && error == 0)
if (m_web && !m_web->supports_keepalive && error == peer_connection_interface::normal)
{
// if the web server doesn't support keepalive and we were
// disconnected as a graceful EOF, reconnect right away
@ -589,7 +589,7 @@ void web_peer_connection::handle_error(int const bytes_left)
, error_msg);
}
received_bytes(0, bytes_left);
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, failure);
}
void web_peer_connection::handle_redirect(int const bytes_left)
@ -605,7 +605,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (location.empty())
{
// we should not try this server again.
t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, peer_error);
m_web = nullptr;
TORRENT_ASSERT(is_disconnecting());
return;
@ -635,7 +635,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (ec)
{
// we should not try this server again.
disconnect(errors::missing_location, operation_t::bittorrent, 1);
disconnect(errors::missing_location, operation_t::bittorrent, failure);
return;
}
@ -679,7 +679,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (m_web->have_files[file_index])
{
m_web->have_files.clear_bit(file_index);
disconnect(errors::redirecting, operation_t::bittorrent, 2);
disconnect(errors::redirecting, operation_t::bittorrent, peer_error);
}
}
else
@ -694,7 +694,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
// this web seed doesn't have any files. Don't try to request from it
// again this session
m_web->have_files.resize(t->torrent_file().num_files(), false);
disconnect(errors::redirecting, operation_t::bittorrent, 2);
disconnect(errors::redirecting, operation_t::bittorrent, peer_error);
m_web = nullptr;
TORRENT_ASSERT(is_disconnecting());
}
@ -749,7 +749,7 @@ void web_peer_connection::on_receive(error_code const& error
, "%*s", int(recv_buffer.size()), recv_buffer.data());
}
#endif
disconnect(errors::http_parse_error, operation_t::bittorrent, 2);
disconnect(errors::http_parse_error, operation_t::bittorrent, peer_error);
return;
}
@ -841,7 +841,7 @@ void web_peer_connection::on_receive(error_code const& error
{
received_bytes(0, int(recv_buffer.size()));
// we should not try this server again.
t->remove_web_seed_conn(this, ec, operation_t::bittorrent, 2);
t->remove_web_seed_conn(this, ec, operation_t::bittorrent, peer_error);
m_web = nullptr;
TORRENT_ASSERT(is_disconnecting());
return;
@ -864,7 +864,7 @@ void web_peer_connection::on_receive(error_code const& error
, static_cast<int>(file_req.file_index), file_req.start, file_req.start + file_req.length - 1);
}
#endif
disconnect(errors::invalid_range, operation_t::bittorrent, 2);
disconnect(errors::invalid_range, operation_t::bittorrent, peer_error);
return;
}
@ -894,7 +894,7 @@ void web_peer_connection::on_receive(error_code const& error
, "received body: %d request size: %d"
, m_received_body, file_req.length);
#endif
disconnect(errors::invalid_range, operation_t::bittorrent, 2);
disconnect(errors::invalid_range, operation_t::bittorrent, peer_error);
return;
}
incoming_payload(recv_buffer.data(), copy_size);
@ -956,7 +956,7 @@ void web_peer_connection::on_receive(error_code const& error
, "received body: %d request size: %d"
, m_received_body, file_req.length);
#endif
disconnect(errors::invalid_range, operation_t::bittorrent, 2);
disconnect(errors::invalid_range, operation_t::bittorrent, peer_error);
return;
}
// we just completed an HTTP file request. pop it from m_file_requests

4
test/test_peer_list.cpp
View File

@ -111,7 +111,7 @@ struct mock_peer_connection
tcp::endpoint const& remote() const override { return m_remote; }
tcp::endpoint local_endpoint() const override { return m_local; }
void disconnect(error_code const& ec
, operation_t op, int error = 0) override;
, operation_t op, disconnect_severity_t error = peer_connection_interface::normal) override;
peer_id const& pid() const override { return m_id; }
peer_id our_pid() const override { return m_our_id; }
void set_holepunch_mode() override {}
@ -149,7 +149,7 @@ struct mock_torrent
};
void mock_peer_connection::disconnect(error_code const&
, operation_t, int /*error*/)
, operation_t, disconnect_severity_t)
{
m_torrent.m_p->connection_closed(*this, 0, m_torrent.m_state);
auto const i = std::find(m_torrent.m_connections.begin(), m_torrent.m_connections.end()