wornvirtue
/
premiere-libtorrent
forked from premiere/premiere-libtorrent
1
0
Fork 0
Code Pull Requests Activity

make operation_t an enum class, for type safety

This commit is contained in:
arvidn 2017-06-14 18:46:11 -04:00 committed by Arvid Norberg
parent 3f09d16e3c
commit 1fd350cf60
15 changed files with 342 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
bindings/python/src/alert.cpp
View File

@ -289,6 +289,29 @@ void bind_alert()
} }
enum_<operation_t>("operation_t")
.value("bittorrent", operation_t::bittorrent)
.value("iocontrol", operation_t::iocontrol)
.value("getpeername", operation_t::getpeername)
.value("getname", operation_t::getname)
.value("alloc_recvbuf", operation_t::alloc_recvbuf)
.value("alloc_sndbuf", operation_t::alloc_sndbuf)
.value("file_write", operation_t::file_write)
.value("file_read", operation_t::file_read)
.value("file", operation_t::file)
.value("sock_write", operation_t::sock_write)
.value("sock_read", operation_t::sock_read)
.value("sock_open", operation_t::sock_open)
.value("sock_bind", operation_t::sock_bind)
.value("available", operation_t::available)
.value("encryption", operation_t::encryption)
.value("connect", operation_t::connect)
.value("ssl_handshake", operation_t::ssl_handshake)
.value("get_interface", operation_t::get_interface)
.value("unknown", operation_t::unknown)
;
class_<torrent_alert, bases<alert>, noncopyable>( class_<torrent_alert, bases<alert>, noncopyable>(
"torrent_alert", no_init) "torrent_alert", no_init)
.def_readonly("handle", &torrent_alert::handle) .def_readonly("handle", &torrent_alert::handle)
@ -367,6 +390,7 @@ void bind_alert()
class_<peer_error_alert, bases<peer_alert>, noncopyable>( class_<peer_error_alert, bases<peer_alert>, noncopyable>(
"peer_error_alert", no_init) "peer_error_alert", no_init)
.def_readonly("error", &peer_error_alert::error) .def_readonly("error", &peer_error_alert::error)
.def_readonly("op", &peer_error_alert::op)
; ;
class_<invalid_request_alert, bases<peer_alert>, noncopyable>( class_<invalid_request_alert, bases<peer_alert>, noncopyable>(
@ -690,7 +714,10 @@ void bind_alert()
class_<peer_disconnected_alert, bases<peer_alert>, noncopyable>( class_<peer_disconnected_alert, bases<peer_alert>, noncopyable>(
"peer_disconnected_alert", no_init) "peer_disconnected_alert", no_init)
.def_readonly("socket_type", &peer_disconnected_alert::socket_type)
.def_readonly("op", &peer_disconnected_alert::op)
.def_readonly("error", &peer_disconnected_alert::error) .def_readonly("error", &peer_disconnected_alert::error)
.def_readonly("reason", &peer_disconnected_alert::reason)
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
.def_readonly("msg", &peer_disconnected_alert::msg) .def_readonly("msg", &peer_disconnected_alert::msg)
#endif #endif

2
examples/client_test.cpp
View File

@ -835,7 +835,7 @@ bool handle_alert(torrent_view& view, session_view& ses_view
// ignore failures to connect and peers not responding with a // ignore failures to connect and peers not responding with a
// handshake. The peers that we successfully connect to and then // handshake. The peers that we successfully connect to and then
// disconnect is more interesting. // disconnect is more interesting.
if (pd->operation == op_connect if (pd->op == operation_t::connect
|| pd->error == errors::timed_out_no_handshake) || pd->error == errors::timed_out_no_handshake)
return true; return true;
} }

25
include/libtorrent/alert_types.hpp
View File

@ -62,7 +62,11 @@ namespace libtorrent {
// maps an operation id (from peer_error_alert and peer_disconnected_alert) // maps an operation id (from peer_error_alert and peer_disconnected_alert)
// to its name. See peer_connection for the constants // to its name. See peer_connection for the constants
TORRENT_EXPORT char const* operation_name(int op); TORRENT_EXPORT char const* operation_name(operation_t op);
#ifndef TORRENT_NO_DEPRECATE
TORRENT_DEPRECATED_EXPORT char const* operation_name(int op);
#endif
// user defined alerts should use IDs greater than this // user defined alerts should use IDs greater than this
static const int user_alert_id = 10000; static const int user_alert_id = 10000;
@ -648,7 +652,7 @@ namespace libtorrent {
{ {
// internal // internal
peer_error_alert(aux::stack_allocator& alloc, torrent_handle const& h peer_error_alert(aux::stack_allocator& alloc, torrent_handle const& h
, tcp::endpoint const& ep, peer_id const& peer_id, int op , tcp::endpoint const& ep, peer_id const& peer_id, operation_t op
, error_code const& e); , error_code const& e);
TORRENT_DEFINE_ALERT(peer_error_alert, 22) TORRENT_DEFINE_ALERT(peer_error_alert, 22)
@ -658,12 +662,13 @@ namespace libtorrent {
// a 0-terminated string of the low-level operation that failed, or nullptr if // a 0-terminated string of the low-level operation that failed, or nullptr if
// there was no low level disk operation. // there was no low level disk operation.
int const operation; operation_t op;
// tells you what error caused this alert. // tells you what error caused this alert.
error_code const error; error_code const error;
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
int const TORRENT_DEPRECATED_MEMBER operation;
std::string TORRENT_DEPRECATED_MEMBER msg; std::string TORRENT_DEPRECATED_MEMBER msg;
#endif #endif
}; };
@ -703,7 +708,7 @@ namespace libtorrent {
// the operation or level where the error occurred. Specified as an // the operation or level where the error occurred. Specified as an
// value from the operation_t enum. Defined in operations.hpp. // value from the operation_t enum. Defined in operations.hpp.
operation_t const operation; operation_t const op;
// tells you what error caused peer to disconnect. // tells you what error caused peer to disconnect.
error_code const error; error_code const error;
@ -712,6 +717,7 @@ namespace libtorrent {
close_reason_t const reason; close_reason_t const reason;
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
int const TORRENT_DEPRECATED_MEMBER operation;
std::string TORRENT_DEPRECATED_MEMBER msg; std::string TORRENT_DEPRECATED_MEMBER msg;
#endif #endif
}; };
@ -1253,7 +1259,7 @@ namespace libtorrent {
struct TORRENT_EXPORT listen_failed_alert final : alert struct TORRENT_EXPORT listen_failed_alert final : alert
{ {
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
enum socket_type_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl }; enum socket_type_t : std::uint8_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl };
#endif #endif
// internal // internal
@ -1321,7 +1327,7 @@ namespace libtorrent {
struct TORRENT_EXPORT listen_succeeded_alert final : alert struct TORRENT_EXPORT listen_succeeded_alert final : alert
{ {
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
enum socket_type_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl }; enum socket_type_t : std::uint8_t { tcp, tcp_ssl, udp, i2p, socks5, utp_ssl };
#endif #endif
// internal // internal
@ -1480,11 +1486,6 @@ namespace libtorrent {
error_code error; error_code error;
#ifndef TORRENT_NO_DEPRECATE
// If the error happened to a specific file, ``file`` is the path to it.
std::string TORRENT_DEPRECATED_MEMBER file;
#endif
// If the error happened to a specific file, this returns the path to it. // If the error happened to a specific file, this returns the path to it.
char const* file_path() const; char const* file_path() const;
@ -1493,6 +1494,8 @@ namespace libtorrent {
char const* operation; char const* operation;
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
// If the error happened to a specific file, ``file`` is the path to it.
std::string TORRENT_DEPRECATED_MEMBER file;
std::string TORRENT_DEPRECATED_MEMBER msg; std::string TORRENT_DEPRECATED_MEMBER msg;
#endif #endif
private: private:

110
include/libtorrent/operations.hpp
View File

@ -30,78 +30,146 @@ POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef TORRENT_OPERATIONS_HPP_INCLUDED #ifndef TORRENT_OPERATIONS_HPP_INCLUDED
#define TORRENT_OPERATIONS_HPP_INCLUDED #define TORRENT_OPERATIONS_HPP_INCLUDED
#include "libtorrent/config.hpp"
#include <cstdint>
namespace libtorrent { namespace libtorrent {
// these constants are used to identify the operation that failed, causing a // these constants are used to identify the operation that failed, causing a
// peer to disconnect // peer to disconnect
enum operation_t enum class operation_t : std::uint8_t
{ {
// this is used when the bittorrent logic // this is used when the bittorrent logic
// determines to disconnect // determines to disconnect
op_bittorrent = 0, bittorrent = 0,
// a call to iocontrol failed // a call to iocontrol failed
op_iocontrol, iocontrol,
// a call to getpeername failed (querying the remote IP of a // a call to getpeername failed (querying the remote IP of a
// connection) // connection)
op_getpeername, getpeername,
// a call to getname failed (querying the local IP of a // a call to getname failed (querying the local IP of a
// connection) // connection)
op_getname, getname,
// an attempt to allocate a receive buffer failed // an attempt to allocate a receive buffer failed
op_alloc_recvbuf, alloc_recvbuf,
// an attempt to allocate a send buffer failed // an attempt to allocate a send buffer failed
op_alloc_sndbuf, alloc_sndbuf,
// writing to a file failed // writing to a file failed
op_file_write, file_write,
// reading from a file failed // reading from a file failed
op_file_read, file_read,
// a non-read and non-write file operation failed // a non-read and non-write file operation failed
op_file, file,
// a socket write operation failed // a socket write operation failed
op_sock_write, sock_write,
// a socket read operation failed // a socket read operation failed
op_sock_read, sock_read,
// a call to open(), to create a socket socket failed // a call to open(), to create a socket socket failed
op_sock_open, sock_open,
// a call to bind() on a socket failed // a call to bind() on a socket failed
op_sock_bind, sock_bind,
// an attempt to query the number of bytes available to read from a socket // an attempt to query the number of bytes available to read from a socket
// failed // failed
op_available, available,
// a call related to bittorrent protocol encryption failed // a call related to bittorrent protocol encryption failed
op_encryption, encryption,
// an attempt to connect a socket failed // an attempt to connect a socket failed
op_connect, connect,
// establishing an SSL connection failed // establishing an SSL connection failed
op_ssl_handshake, ssl_handshake,
// a connection failed to satisfy the bind interface setting // a connection failed to satisfy the bind interface setting
op_get_interface, get_interface,
// the error was unexpected and it is unknown which operation caused it // the error was unexpected and it is unknown which operation caused it
op_unknown, unknown,
}; };
#ifndef TORRENT_NO_DEPRECATE
enum deprecated_operation_t : std::uint8_t
{
// this is used when the bittorrent logic
// determines to disconnect
op_bittorrent TORRENT_DEPRECATED_ENUM = 0,
// a call to iocontrol failed
op_iocontrol TORRENT_DEPRECATED_ENUM,
// a call to getpeername failed (querying the remote IP of a
// connection)
op_getpeername TORRENT_DEPRECATED_ENUM,
// a call to getname failed (querying the local IP of a
// connection)
op_getname TORRENT_DEPRECATED_ENUM,
// an attempt to allocate a receive buffer failed
op_alloc_recvbuf TORRENT_DEPRECATED_ENUM,
// an attempt to allocate a send buffer failed
op_alloc_sndbuf TORRENT_DEPRECATED_ENUM,
// writing to a file failed
op_file_write TORRENT_DEPRECATED_ENUM,
// reading from a file failed
op_file_read TORRENT_DEPRECATED_ENUM,
// a non-read and non-write file operation failed
op_file TORRENT_DEPRECATED_ENUM,
// a socket write operation failed
op_sock_write TORRENT_DEPRECATED_ENUM,
// a socket read operation failed
op_sock_read TORRENT_DEPRECATED_ENUM,
// a call to open(), to create a socket socket failed
op_sock_open TORRENT_DEPRECATED_ENUM,
// a call to bind() on a socket failed
op_sock_bind TORRENT_DEPRECATED_ENUM,
// an attempt to query the number of bytes available to read from a socket
// failed
op_available TORRENT_DEPRECATED_ENUM,
// a call related to bittorrent protocol encryption failed
op_encryption TORRENT_DEPRECATED_ENUM,
// an attempt to connect a socket failed
op_connect TORRENT_DEPRECATED_ENUM,
// establishing an SSL connection failed
op_ssl_handshake TORRENT_DEPRECATED_ENUM,
// a connection failed to satisfy the bind interface setting
op_get_interface TORRENT_DEPRECATED_ENUM,
// the error was unexpected and it is unknown which operation caused it
op_unknown TORRENT_DEPRECATED_ENUM,
};
#endif
} }
#endif // TORRENT_OPERATIONS_HPP_INCLUDED #endif // TORRENT_OPERATIONS_HPP_INCLUDED

76
src/alert.cpp
View File

@ -1036,15 +1036,13 @@ namespace {
, char const* op) , char const* op)
: torrent_alert(alloc, h) : torrent_alert(alloc, h)
, error(ec) , error(ec)
, operation(op)
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
, file(f) , file(f)
, msg(convert_from_native(error.message()))
#endif #endif
, operation(op)
, m_path_idx(alloc.copy_string(f)) , m_path_idx(alloc.copy_string(f))
{ {
#ifndef TORRENT_NO_DEPRECATE
msg = convert_from_native(error.message());
#endif
} }
std::string fastresume_rejected_alert::message() const std::string fastresume_rejected_alert::message() const
@ -1394,29 +1392,7 @@ namespace {
} }
#endif #endif
peer_error_alert::peer_error_alert(aux::stack_allocator& alloc, torrent_handle const& h char const* operation_name(operation_t const op)
, tcp::endpoint const& ep, peer_id const& peer_id, int op
, error_code const& e)
: peer_alert(alloc, h, ep, peer_id)
, operation(op)
, error(e)
{
#ifndef TORRENT_NO_DEPRECATE
msg = convert_from_native(error.message());
#endif
}
std::string peer_error_alert::message() const
{
char buf[200];
std::snprintf(buf, sizeof(buf), "%s peer error [%s] [%s]: %s"
, peer_alert::message().c_str()
, operation_name(operation), error.category().name()
, convert_from_native(error.message()).c_str());
return buf;
}
char const* operation_name(int op)
{ {
static char const* names[] = { static char const* names[] = {
"bittorrent", "bittorrent",
@ -1440,10 +1416,40 @@ namespace {
"unknown", "unknown",
}; };
if (op < 0 || op >= int(sizeof(names)/sizeof(names[0]))) int const idx = static_cast<int>(op);
if (idx < 0 || idx >= int(sizeof(names)/sizeof(names[0])))
return "unknown operation"; return "unknown operation";
return names[op]; return names[idx];
}
#ifndef TORRENT_NO_DEPRECATE
char const* operation_name(int const op)
{
return operation_name(static_cast<operation_t>(op));
}
#endif
peer_error_alert::peer_error_alert(aux::stack_allocator& alloc, torrent_handle const& h
, tcp::endpoint const& ep, peer_id const& peer_id, operation_t const op_
, error_code const& e)
: peer_alert(alloc, h, ep, peer_id)
, op(op_)
, error(e)
#ifndef TORRENT_NO_DEPRECATE
, operation(static_cast<int>(op_))
, msg(convert_from_native(error.message()))
#endif
{}
std::string peer_error_alert::message() const
{
char buf[200];
std::snprintf(buf, sizeof(buf), "%s peer error [%s] [%s]: %s"
, peer_alert::message().c_str()
, operation_name(op), error.category().name()
, convert_from_native(error.message()).c_str());
return buf;
} }
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
@ -1466,18 +1472,18 @@ namespace {
peer_disconnected_alert::peer_disconnected_alert(aux::stack_allocator& alloc peer_disconnected_alert::peer_disconnected_alert(aux::stack_allocator& alloc
, torrent_handle const& h, tcp::endpoint const& ep , torrent_handle const& h, tcp::endpoint const& ep
, peer_id const& peer_id, operation_t op, int type, error_code const& e , peer_id const& peer_id, operation_t op_, int type, error_code const& e
, close_reason_t r) , close_reason_t r)
: peer_alert(alloc, h, ep, peer_id) : peer_alert(alloc, h, ep, peer_id)
, socket_type(type) , socket_type(type)
, operation(op) , op(op_)
, error(e) , error(e)
, reason(r) , reason(r)
{
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
msg = convert_from_native(error.message()); , operation(static_cast<int>(op))
, msg(convert_from_native(error.message()))
#endif #endif
} {}
std::string peer_disconnected_alert::message() const std::string peer_disconnected_alert::message() const
{ {
@ -1485,7 +1491,7 @@ namespace {
std::snprintf(buf, sizeof(buf), "%s disconnecting (%s) [%s] [%s]: %s (reason: %d)" std::snprintf(buf, sizeof(buf), "%s disconnecting (%s) [%s] [%s]: %s (reason: %d)"
, peer_alert::message().c_str() , peer_alert::message().c_str()
, socket_type_str[socket_type] , socket_type_str[socket_type]
, operation_name(operation), error.category().name() , operation_name(op), error.category().name()
, convert_from_native(error.message()).c_str() , convert_from_native(error.message()).c_str()
, int(reason)); , int(reason));
return buf; return buf;

102
src/bt_peer_connection.cpp
View File

@ -213,7 +213,7 @@ namespace {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ON_CONNECTED", "graceful-paused"); peer_log(peer_log_alert::info, "ON_CONNECTED", "graceful-paused");
#endif #endif
disconnect(error_code(errors::torrent_paused), op_bittorrent); disconnect(error_code(errors::torrent_paused), operation_t::bittorrent);
return; return;
} }
@ -495,7 +495,7 @@ namespace {
m_dh_key_exchange.reset(new (std::nothrow) dh_key_exchange); m_dh_key_exchange.reset(new (std::nothrow) dh_key_exchange);
if (!m_dh_key_exchange || !m_dh_key_exchange->good()) if (!m_dh_key_exchange || !m_dh_key_exchange->good())
{ {
disconnect(errors::no_memory, op_encryption); disconnect(errors::no_memory, operation_t::encryption);
return; return;
} }
@ -855,7 +855,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1) if (m_recv_buffer.packet_size() != 1)
{ {
disconnect(errors::invalid_choke, op_bittorrent, 2); disconnect(errors::invalid_choke, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -905,7 +905,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1) if (m_recv_buffer.packet_size() != 1)
{ {
disconnect(errors::invalid_unchoke, op_bittorrent, 2); disconnect(errors::invalid_unchoke, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -925,7 +925,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1) if (m_recv_buffer.packet_size() != 1)
{ {
disconnect(errors::invalid_interested, op_bittorrent, 2); disconnect(errors::invalid_interested, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -954,7 +954,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 1) if (m_recv_buffer.packet_size() != 1)
{ {
disconnect(errors::invalid_not_interested, op_bittorrent, 2); disconnect(errors::invalid_not_interested, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -974,7 +974,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 5) if (m_recv_buffer.packet_size() != 5)
{ {
disconnect(errors::invalid_have, op_bittorrent, 2); disconnect(errors::invalid_have, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -1006,7 +1006,7 @@ namespace {
if (t->valid_metadata() if (t->valid_metadata()
&& m_recv_buffer.packet_size() - 1 != (t->torrent_file().num_pieces() + 7) / 8) && m_recv_buffer.packet_size() - 1 != (t->torrent_file().num_pieces() + 7) / 8)
{ {
disconnect(errors::invalid_bitfield_size, op_bittorrent, 2); disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, 2);
return; return;
} }
@ -1033,7 +1033,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 13) if (m_recv_buffer.packet_size() != 13)
{ {
disconnect(errors::invalid_request, op_bittorrent, 2); disconnect(errors::invalid_request, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -1084,13 +1084,13 @@ namespace {
if (list_size > m_recv_buffer.packet_size() - 13) if (list_size > m_recv_buffer.packet_size() - 13)
{ {
disconnect(errors::invalid_hash_list, op_bittorrent, 2); disconnect(errors::invalid_hash_list, operation_t::bittorrent, 2);
return; return;
} }
if (m_recv_buffer.packet_size() - 13 - list_size > t->block_size()) if (m_recv_buffer.packet_size() - 13 - list_size > t->block_size())
{ {
disconnect(errors::packet_too_large, op_bittorrent, 2); disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
return; return;
} }
} }
@ -1101,7 +1101,7 @@ namespace {
{ {
if (m_recv_buffer.packet_size() - 9 > t->block_size()) if (m_recv_buffer.packet_size() - 9 > t->block_size())
{ {
disconnect(errors::packet_too_large, op_bittorrent, 2); disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
return; return;
} }
} }
@ -1191,7 +1191,7 @@ namespace {
if (bdecode(recv_buffer.begin() + 13, recv_buffer.begin() + 13 + list_size if (bdecode(recv_buffer.begin() + 13, recv_buffer.begin() + 13 + list_size
, hash_list, ec) != 0) , hash_list, ec) != 0)
{ {
disconnect(errors::invalid_hash_piece, op_bittorrent, 2); disconnect(errors::invalid_hash_piece, operation_t::bittorrent, 2);
return; return;
} }
@ -1199,7 +1199,7 @@ namespace {
// [ [node-index, hash], [node-index, hash], ... ] // [ [node-index, hash], [node-index, hash], ... ]
if (hash_list.type() != bdecode_node::list_t) if (hash_list.type() != bdecode_node::list_t)
{ {
disconnect(errors::invalid_hash_list, op_bittorrent, 2); disconnect(errors::invalid_hash_list, operation_t::bittorrent, 2);
return; return;
} }
@ -1218,7 +1218,7 @@ namespace {
} }
if (!nodes.empty() && !t->add_merkle_nodes(nodes, p.piece)) if (!nodes.empty() && !t->add_merkle_nodes(nodes, p.piece))
{ {
disconnect(errors::invalid_hash_piece, op_bittorrent, 2); disconnect(errors::invalid_hash_piece, operation_t::bittorrent, 2);
return; return;
} }
} }
@ -1238,7 +1238,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 13) if (m_recv_buffer.packet_size() != 13)
{ {
disconnect(errors::invalid_cancel, op_bittorrent, 2); disconnect(errors::invalid_cancel, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -1266,7 +1266,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() != 3) if (m_recv_buffer.packet_size() != 3)
{ {
disconnect(errors::invalid_dht_port, op_bittorrent, 2); disconnect(errors::invalid_dht_port, operation_t::bittorrent, 2);
return; return;
} }
if (!m_recv_buffer.packet_finished()) return; if (!m_recv_buffer.packet_finished()) return;
@ -1292,7 +1292,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (!m_supports_fast) if (!m_supports_fast)
{ {
disconnect(errors::invalid_suggest, op_bittorrent, 2); disconnect(errors::invalid_suggest, operation_t::bittorrent, 2);
return; return;
} }
@ -1312,7 +1312,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (!m_supports_fast) if (!m_supports_fast)
{ {
disconnect(errors::invalid_have_all, op_bittorrent, 2); disconnect(errors::invalid_have_all, operation_t::bittorrent, 2);
return; return;
} }
incoming_have_all(); incoming_have_all();
@ -1325,7 +1325,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (!m_supports_fast) if (!m_supports_fast)
{ {
disconnect(errors::invalid_have_none, op_bittorrent, 2); disconnect(errors::invalid_have_none, operation_t::bittorrent, 2);
return; return;
} }
incoming_have_none(); incoming_have_none();
@ -1338,7 +1338,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (!m_supports_fast) if (!m_supports_fast)
{ {
disconnect(errors::invalid_reject, op_bittorrent, 2); disconnect(errors::invalid_reject, operation_t::bittorrent, 2);
return; return;
} }
@ -1362,7 +1362,7 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (!m_supports_fast) if (!m_supports_fast)
{ {
disconnect(errors::invalid_allow_fast, op_bittorrent, 2); disconnect(errors::invalid_allow_fast, operation_t::bittorrent, 2);
return; return;
} }
@ -1606,13 +1606,13 @@ namespace {
received_bytes(0, received); received_bytes(0, received);
if (m_recv_buffer.packet_size() < 2) if (m_recv_buffer.packet_size() < 2)
{ {
disconnect(errors::invalid_extended, op_bittorrent, 2); disconnect(errors::invalid_extended, operation_t::bittorrent, 2);
return; return;
} }
if (associated_torrent().expired()) if (associated_torrent().expired())
{ {
disconnect(errors::invalid_extended, op_bittorrent, 2); disconnect(errors::invalid_extended, operation_t::bittorrent, 2);
return; return;
} }
@ -1710,7 +1710,7 @@ namespace {
return; return;
} }
disconnect(errors::invalid_message, op_bittorrent, 2); disconnect(errors::invalid_message, operation_t::bittorrent, 2);
return; return;
} }
@ -1830,7 +1830,7 @@ namespace {
if (t->is_finished() && upload_only() if (t->is_finished() && upload_only()
&& m_settings.get_bool(settings_pack::close_redundant_connections) && m_settings.get_bool(settings_pack::close_redundant_connections)
&& !t->share_mode()) && !t->share_mode())
disconnect(errors::upload_upload_connection, op_bittorrent); disconnect(errors::upload_upload_connection, operation_t::bittorrent);
stats_counters().inc_stats_counter(counters::num_incoming_ext_handshake); stats_counters().inc_stats_counter(counters::num_incoming_ext_handshake);
} }
@ -1899,7 +1899,7 @@ namespace {
} }
#endif #endif
received_bytes(0, received); received_bytes(0, received);
disconnect(errors::invalid_message, op_bittorrent); disconnect(errors::invalid_message, operation_t::bittorrent);
return m_recv_buffer.packet_finished(); return m_recv_buffer.packet_finished();
} }
} }
@ -2427,7 +2427,7 @@ namespace {
#endif #endif
if (bytes_transferred == SIZE_MAX) if (bytes_transferred == SIZE_MAX)
{ {
disconnect(errors::parse_failed, op_encryption); disconnect(errors::parse_failed, operation_t::encryption);
return; return;
} }
received_bytes(0, consumed); received_bytes(0, consumed);
@ -2436,7 +2436,7 @@ namespace {
if (!m_recv_buffer.crypto_packet_finished() if (!m_recv_buffer.crypto_packet_finished()
&& m_recv_buffer.crypto_packet_size() > 1025 * 1024) && m_recv_buffer.crypto_packet_size() > 1025 * 1024)
{ {
disconnect(errors::packet_too_large, op_encryption, 2); disconnect(errors::packet_too_large, operation_t::encryption, 2);
return; return;
} }
@ -2551,7 +2551,7 @@ namespace {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
if (m_recv_buffer.packet_finished()) if (m_recv_buffer.packet_finished())
disconnect(errors::sync_hash_not_found, op_bittorrent, 1); disconnect(errors::sync_hash_not_found, operation_t::bittorrent, 1);
return; return;
} }
@ -2589,7 +2589,7 @@ namespace {
m_sync_bytes_read += bytes_processed; m_sync_bytes_read += bytes_processed;
if (m_sync_bytes_read >= 512) if (m_sync_bytes_read >= 512)
{ {
disconnect(errors::sync_hash_not_found, op_encryption, 1); disconnect(errors::sync_hash_not_found, operation_t::encryption, 1);
return; return;
} }
@ -2665,7 +2665,7 @@ namespace {
if (!m_rc4.get()) if (!m_rc4.get())
{ {
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
} }
@ -2675,7 +2675,7 @@ namespace {
static const char sh_vc[] = {0,0,0,0, 0,0,0,0}; 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)) if (!std::equal(sh_vc, sh_vc + 8, recv_buffer.begin() + 20))
{ {
disconnect(errors::invalid_encryption_constant, op_encryption, 2); disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
return; return;
} }
@ -2699,7 +2699,7 @@ namespace {
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
if (m_recv_buffer.packet_finished()) if (m_recv_buffer.packet_finished())
disconnect(errors::invalid_encryption_constant, op_encryption, 2); disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
return; return;
} }
@ -2711,7 +2711,7 @@ namespace {
m_sync_vc.reset(new (std::nothrow) char[8]); m_sync_vc.reset(new (std::nothrow) char[8]);
if (!m_sync_vc) if (!m_sync_vc)
{ {
disconnect(errors::no_memory, op_encryption); disconnect(errors::no_memory, operation_t::encryption);
return; return;
} }
std::fill(m_sync_vc.get(), m_sync_vc.get() + 8, char{0}); std::fill(m_sync_vc.get(), m_sync_vc.get() + 8, char{0});
@ -2731,7 +2731,7 @@ namespace {
if (m_sync_bytes_read >= 512) if (m_sync_bytes_read >= 512)
{ {
disconnect(errors::invalid_encryption_constant, op_encryption, 2); disconnect(errors::invalid_encryption_constant, operation_t::encryption, 2);
return; return;
} }
@ -2821,7 +2821,7 @@ namespace {
if (crypto_select == 0) if (crypto_select == 0)
{ {
disconnect(errors::unsupported_encryption_mode, op_encryption, 1); disconnect(errors::unsupported_encryption_mode, operation_t::encryption, 1);
return; return;
} }
@ -2837,7 +2837,7 @@ namespace {
if (crypto_field == 0) if (crypto_field == 0)
{ {
// we don't allow any of the offered encryption levels // we don't allow any of the offered encryption levels
disconnect(errors::unsupported_encryption_mode_selected, op_encryption, 2); disconnect(errors::unsupported_encryption_mode_selected, operation_t::encryption, 2);
return; return;
} }
@ -2850,7 +2850,7 @@ namespace {
int len_pad = aux::read_int16(recv_buffer); int len_pad = aux::read_int16(recv_buffer);
if (len_pad < 0 || len_pad > 512) if (len_pad < 0 || len_pad > 512)
{ {
disconnect(errors::invalid_pad_size, op_encryption, 2); disconnect(errors::invalid_pad_size, operation_t::encryption, 2);
return; return;
} }
@ -2897,7 +2897,7 @@ namespace {
if (len_ia < 0) if (len_ia < 0)
{ {
disconnect(errors::invalid_encrypt_handshake, op_encryption, 2); disconnect(errors::invalid_encrypt_handshake, operation_t::encryption, 2);
return; return;
} }
@ -3034,7 +3034,7 @@ namespace {
peer_log(peer_log_alert::info, "ENCRYPTION" peer_log(peer_log_alert::info, "ENCRYPTION"
, "SSL peers are not allowed to use any other encryption"); , "SSL peers are not allowed to use any other encryption");
#endif #endif
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
} }
#endif // TORRENT_USE_OPENSSL #endif // TORRENT_USE_OPENSSL
@ -3043,7 +3043,7 @@ namespace {
&& m_settings.get_int(settings_pack::in_enc_policy) && m_settings.get_int(settings_pack::in_enc_policy)
== settings_pack::pe_disabled) == settings_pack::pe_disabled)
{ {
disconnect(errors::no_incoming_encrypted, op_bittorrent); disconnect(errors::no_incoming_encrypted, operation_t::bittorrent);
return; return;
} }
@ -3053,7 +3053,7 @@ namespace {
// handshake by this point // handshake by this point
if (m_encrypted || is_outgoing()) if (m_encrypted || is_outgoing())
{ {
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
} }
@ -3065,7 +3065,7 @@ namespace {
TORRENT_ASSERT(!m_recv_buffer.packet_finished()); TORRENT_ASSERT(!m_recv_buffer.packet_finished());
return; return;
#else #else
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
#endif // TORRENT_DISABLE_ENCRYPTION #endif // TORRENT_DISABLE_ENCRYPTION
} }
@ -3080,7 +3080,7 @@ namespace {
&& !m_encrypted && !m_encrypted
&& !is_ssl(*get_socket())) && !is_ssl(*get_socket()))
{ {
disconnect(errors::no_incoming_regular, op_bittorrent); disconnect(errors::no_incoming_regular, operation_t::bittorrent);
return; return;
} }
#endif #endif
@ -3160,7 +3160,7 @@ namespace {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ERROR", "received invalid info_hash"); peer_log(peer_log_alert::info, "ERROR", "received invalid info_hash");
#endif #endif
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
} }
@ -3236,11 +3236,11 @@ namespace {
// if not, we should close the outgoing one. // if not, we should close the outgoing one.
if (pid < m_our_peer_id && is_outgoing()) if (pid < m_our_peer_id && is_outgoing())
{ {
p->disconnect(errors::duplicate_peer_id, op_bittorrent); p->disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
} }
else else
{ {
disconnect(errors::duplicate_peer_id, op_bittorrent); disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
return; return;
} }
} }
@ -3253,7 +3253,7 @@ namespace {
if (pid == m_our_peer_id) if (pid == m_our_peer_id)
{ {
if (peer_info_struct()) t->ban_peer(peer_info_struct()); if (peer_info_struct()) t->ban_peer(peer_info_struct());
disconnect(errors::self_connection, op_bittorrent, 1); disconnect(errors::self_connection, operation_t::bittorrent, 1);
return; return;
} }
@ -3358,7 +3358,7 @@ namespace {
{ {
// packet too large // packet too large
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
disconnect(errors::packet_too_large, op_bittorrent, 2); disconnect(errors::packet_too_large, operation_t::bittorrent, 2);
return; return;
} }
@ -3389,7 +3389,7 @@ namespace {
if (!t) if (!t)
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
disconnect(errors::torrent_removed, op_bittorrent, 1); disconnect(errors::torrent_removed, operation_t::bittorrent, 1);
return; return;
} }
#if TORRENT_USE_ASSERTS #if TORRENT_USE_ASSERTS

18
src/http_seed_connection.cpp
View File

@ -83,7 +83,7 @@ namespace libtorrent {
{ {
if (is_disconnecting()) return; if (is_disconnecting()) return;
if (op == op_connect && m_web && !m_web->endpoints.empty()) if (op == operation_t::connect && m_web && !m_web->endpoints.empty())
{ {
// we failed to connect to this IP. remove it so that the next attempt // we failed to connect to this IP. remove it so that the next attempt
// uses the next IP in the list. // uses the next IP in the list.
@ -231,7 +231,7 @@ namespace libtorrent {
if (m_requests.empty()) if (m_requests.empty())
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
disconnect(errors::http_error, op_bittorrent, 2); disconnect(errors::http_error, operation_t::bittorrent, 2);
return; return;
} }
@ -255,7 +255,7 @@ namespace libtorrent {
if (parse_error) if (parse_error)
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
disconnect(errors::http_parse_error, op_bittorrent, 2); disconnect(errors::http_parse_error, operation_t::bittorrent, 2);
return; return;
} }
@ -287,7 +287,7 @@ namespace libtorrent {
, error_msg); , error_msg);
} }
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1); disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
return; return;
} }
if (!m_parser.header_finished()) if (!m_parser.header_finished())
@ -311,13 +311,13 @@ namespace libtorrent {
if (location.empty()) if (location.empty())
{ {
// we should not try this server again. // we should not try this server again.
t->remove_web_seed_conn(this, errors::missing_location, op_bittorrent, 2); t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, 2);
return; return;
} }
// add the redirected url and remove the current one // add the redirected url and remove the current one
t->add_web_seed(location, web_seed_entry::http_seed); t->add_web_seed(location, web_seed_entry::http_seed);
t->remove_web_seed_conn(this, errors::redirecting, op_bittorrent, 2); t->remove_web_seed_conn(this, errors::redirecting, operation_t::bittorrent, 2);
return; return;
} }
@ -336,14 +336,14 @@ namespace libtorrent {
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
// we should not try this server again. // we should not try this server again.
t->remove_web_seed_conn(this, errors::no_content_length, op_bittorrent, 2); t->remove_web_seed_conn(this, errors::no_content_length, operation_t::bittorrent, 2);
return; return;
} }
if (m_response_left != front_request.length) if (m_response_left != front_request.length)
{ {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
// we should not try this server again. // we should not try this server again.
t->remove_web_seed_conn(this, errors::invalid_range, op_bittorrent, 2); t->remove_web_seed_conn(this, errors::invalid_range, operation_t::bittorrent, 2);
return; return;
} }
m_body_start = m_parser.body_start(); m_body_start = m_parser.body_start();
@ -422,7 +422,7 @@ namespace libtorrent {
received_bytes(0, int(bytes_transferred)); received_bytes(0, int(bytes_transferred));
// temporarily unavailable, retry later // temporarily unavailable, retry later
t->retry_web_seed(this, retry_time); t->retry_web_seed(this, retry_time);
disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1); disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
return; return;
} }

96
src/peer_connection.cpp
View File

@ -203,12 +203,12 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "PEER_ERROR" ,"error: %s" peer_log(peer_log_alert::info, "PEER_ERROR" ,"error: %s"
, e.what()); , e.what());
#endif #endif
disconnect(error_code(), op_unknown, 2); disconnect(error_code(), operation_t::unknown, 2);
} }
void peer_connection::on_error(error_code const& ec) void peer_connection::on_error(error_code const& ec)
{ {
disconnect(ec, op_unknown, 2); disconnect(ec, operation_t::unknown, 2);
} }
void peer_connection::increase_est_reciprocation_rate() void peer_connection::increase_est_reciprocation_rate()
@ -269,19 +269,19 @@ namespace libtorrent {
m_socket->io_control(ioc, ec); m_socket->io_control(ioc, ec);
if (ec) if (ec)
{ {
disconnect(ec, op_iocontrol); disconnect(ec, operation_t::iocontrol);
return; return;
} }
m_remote = m_socket->remote_endpoint(ec); m_remote = m_socket->remote_endpoint(ec);
if (ec) if (ec)
{ {
disconnect(ec, op_getpeername); disconnect(ec, operation_t::getpeername);
return; return;
} }
m_local = m_socket->local_endpoint(ec); m_local = m_socket->local_endpoint(ec);
if (ec) if (ec)
{ {
disconnect(ec, op_getname); disconnect(ec, operation_t::getname);
return; return;
} }
if (m_remote.address().is_v4() && m_settings.get_int(settings_pack::peer_tos) != 0) if (m_remote.address().is_v4() && m_settings.get_int(settings_pack::peer_tos) != 0)
@ -342,7 +342,7 @@ namespace libtorrent {
m_socket->open(m_remote.protocol(), ec); m_socket->open(m_remote.protocol(), ec);
if (ec) if (ec)
{ {
disconnect(ec, op_sock_open); disconnect(ec, operation_t::sock_open);
return; return;
} }
@ -360,7 +360,7 @@ namespace libtorrent {
#endif #endif
if (ec) if (ec)
{ {
disconnect(ec, op_sock_bind); disconnect(ec, operation_t::sock_bind);
return; return;
} }
@ -1200,7 +1200,7 @@ namespace libtorrent {
m_ses.ban_ip(m_remote.address()); m_ses.ban_ip(m_remote.address());
} }
#endif #endif
disconnect(errors::invalid_info_hash, op_bittorrent, 1); disconnect(errors::invalid_info_hash, operation_t::bittorrent, 1);
return; return;
} }
@ -1222,7 +1222,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ATTACH", "rejected connection to paused torrent"); peer_log(peer_log_alert::info, "ATTACH", "rejected connection to paused torrent");
#endif #endif
disconnect(errors::torrent_paused, op_bittorrent, 2); disconnect(errors::torrent_paused, operation_t::bittorrent, 2);
return; return;
} }
@ -1236,7 +1236,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "ATTACH", "rejected regular connection to i2p torrent"); peer_log(peer_log_alert::info, "ATTACH", "rejected regular connection to i2p torrent");
#endif #endif
disconnect(errors::peer_banned, op_bittorrent, 2); disconnect(errors::peer_banned, operation_t::bittorrent, 2);
return; return;
} }
#endif // TORRENT_USE_I2P #endif // TORRENT_USE_I2P
@ -1264,17 +1264,17 @@ namespace libtorrent {
{ {
if (other_t->num_peers() <= t->num_peers()) if (other_t->num_peers() <= t->num_peers())
{ {
disconnect(errors::too_many_connections, op_bittorrent); disconnect(errors::too_many_connections, operation_t::bittorrent);
return; return;
} }
// find the lowest ranking peer and disconnect that // find the lowest ranking peer and disconnect that
peer_connection* p = other_t->find_lowest_ranking_peer(); peer_connection* p = other_t->find_lowest_ranking_peer();
p->disconnect(errors::too_many_connections, op_bittorrent); p->disconnect(errors::too_many_connections, operation_t::bittorrent);
peer_disconnected_other(); peer_disconnected_other();
} }
else else
{ {
disconnect(errors::too_many_connections, op_bittorrent); disconnect(errors::too_many_connections, operation_t::bittorrent);
return; return;
} }
} }
@ -1834,7 +1834,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "ERROR", "have-metadata have_piece: %d size: %d" peer_log(peer_log_alert::info, "ERROR", "have-metadata have_piece: %d size: %d"
, static_cast<int>(index), m_have_piece.size()); , static_cast<int>(index), m_have_piece.size());
#endif #endif
disconnect(errors::invalid_have, op_bittorrent, 2); disconnect(errors::invalid_have, operation_t::bittorrent, 2);
return; return;
} }
@ -1959,7 +1959,7 @@ namespace libtorrent {
// if we got an invalid message, abort // if we got an invalid message, abort
if (index >= piece_index_t(m_have_piece.size()) || index < piece_index_t(0)) if (index >= piece_index_t(m_have_piece.size()) || index < piece_index_t(0))
{ {
disconnect(errors::invalid_dont_have, op_bittorrent, 2); disconnect(errors::invalid_dont_have, operation_t::bittorrent, 2);
return; return;
} }
@ -2036,7 +2036,7 @@ namespace libtorrent {
, m_have_piece.size()); , m_have_piece.size());
} }
#endif #endif
disconnect(errors::invalid_bitfield_size, op_bittorrent, 2); disconnect(errors::invalid_bitfield_size, operation_t::bittorrent, 2);
return; return;
} }
@ -2151,7 +2151,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and our torrent is also upload-only"); peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and our torrent is also upload-only");
#endif #endif
disconnect(errors::upload_upload_connection, op_bittorrent); disconnect(errors::upload_upload_connection, operation_t::bittorrent);
return true; return true;
} }
@ -2164,7 +2164,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and we're not interested in it"); peer_log(peer_log_alert::info, "UPLOAD_ONLY", "the peer is upload-only and we're not interested in it");
#endif #endif
disconnect(errors::uninteresting_upload_peer, op_bittorrent); disconnect(errors::uninteresting_upload_peer, operation_t::bittorrent);
return true; return true;
} }
@ -2377,7 +2377,7 @@ namespace libtorrent {
if (m_num_invalid_requests > 300 && !m_peer_choked if (m_num_invalid_requests > 300 && !m_peer_choked
&& can_disconnect(errors::too_many_requests_when_choked)) && can_disconnect(errors::too_many_requests_when_choked))
{ {
disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2); disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
return; return;
} }
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
@ -2399,7 +2399,7 @@ namespace libtorrent {
if (m_choked && fast_idx != -1 && m_accept_fast_piece_cnt[fast_idx] >= 3 * blocks_per_piece 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)) && can_disconnect(errors::too_many_requests_when_choked))
{ {
disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2); disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
return; return;
} }
@ -2418,7 +2418,7 @@ namespace libtorrent {
if (aux::time_now() - seconds(2) > m_last_choke if (aux::time_now() - seconds(2) > m_last_choke
&& can_disconnect(errors::too_many_requests_when_choked)) && can_disconnect(errors::too_many_requests_when_choked))
{ {
disconnect(errors::too_many_requests_when_choked, op_bittorrent, 2); disconnect(errors::too_many_requests_when_choked, operation_t::bittorrent, 2);
return; return;
} }
} }
@ -2507,7 +2507,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "INVALID_PIECE", "piece: %d s: %d l: %d" peer_log(peer_log_alert::info, "INVALID_PIECE", "piece: %d s: %d l: %d"
, static_cast<int>(r.piece), r.start, r.length); , static_cast<int>(r.piece), r.start, r.length);
#endif #endif
disconnect(errors::invalid_piece, op_bittorrent, 2); disconnect(errors::invalid_piece, operation_t::bittorrent, 2);
return; return;
} }
@ -2662,7 +2662,7 @@ namespace libtorrent {
if (t->alerts().should_post<peer_error_alert>()) if (t->alerts().should_post<peer_error_alert>())
{ {
t->alerts().emplace_alert<peer_error_alert>(t->get_handle(), m_remote t->alerts().emplace_alert<peer_error_alert>(t->get_handle(), m_remote
, m_peer_id, op_bittorrent, errors::peer_sent_empty_piece); , m_peer_id, operation_t::bittorrent, errors::peer_sent_empty_piece);
} }
// This is used as a reject-request by bitcomet // This is used as a reject-request by bitcomet
incoming_reject_request(p); incoming_reject_request(p);
@ -2950,7 +2950,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
peer_log(peer_log_alert::info, "GRACEFUL_PAUSE", "NO MORE DOWNLOAD"); peer_log(peer_log_alert::info, "GRACEFUL_PAUSE", "NO MORE DOWNLOAD");
#endif #endif
disconnect(errors::torrent_paused, op_bittorrent); disconnect(errors::torrent_paused, operation_t::bittorrent);
} }
void peer_connection::on_disk_write_complete(storage_error const& error void peer_connection::on_disk_write_complete(storage_error const& error
@ -2983,7 +2983,7 @@ namespace libtorrent {
if (!t) if (!t)
{ {
disconnect(error.ec, op_file_write); disconnect(error.ec, operation_t::file_write);
return; return;
} }
@ -4020,7 +4020,7 @@ namespace libtorrent {
m_peer_info->supports_utp = false; m_peer_info->supports_utp = false;
// reconnect immediately using TCP // reconnect immediately using TCP
fast_reconnect(true); fast_reconnect(true);
disconnect(e, op_connect, 0); disconnect(e, operation_t::connect, 0);
if (t && m_peer_info) if (t && m_peer_info)
{ {
std::weak_ptr<torrent> weak_t = t; std::weak_ptr<torrent> weak_t = t;
@ -4060,7 +4060,7 @@ namespace libtorrent {
} }
#endif #endif
disconnect(e, op_connect, 1); disconnect(e, operation_t::connect, 1);
return; return;
} }
@ -4098,15 +4098,15 @@ namespace libtorrent {
{ {
case 0: case 0:
peer_log(peer_log_alert::info, "CONNECTION_CLOSED", "op: %d error: %s" peer_log(peer_log_alert::info, "CONNECTION_CLOSED", "op: %d error: %s"
, op, ec.message().c_str()); , static_cast<int>(op), ec.message().c_str());
break; break;
case 1: case 1:
peer_log(peer_log_alert::info, "CONNECTION_FAILED", "op: %d error: %s" peer_log(peer_log_alert::info, "CONNECTION_FAILED", "op: %d error: %s"
, op, ec.message().c_str()); , static_cast<int>(op), ec.message().c_str());
break; break;
case 2: case 2:
peer_log(peer_log_alert::info, "PEER_ERROR" ,"op: %d error: %s" peer_log(peer_log_alert::info, "PEER_ERROR" ,"op: %d error: %s"
, op, ec.message().c_str()); , static_cast<int>(op), ec.message().c_str());
break; break;
} }
@ -4208,7 +4208,7 @@ namespace libtorrent {
else m_counters.inc_stats_counter(counters::error_incoming_peers); else m_counters.inc_stats_counter(counters::error_incoming_peers);
#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
if (type() == connection_type::bittorrent && op != op_connect) if (type() == connection_type::bittorrent && op != operation_t::connect)
{ {
bt_peer_connection* bt = static_cast<bt_peer_connection*>(this); bt_peer_connection* bt = static_cast<bt_peer_connection*>(this);
if (bt->supports_encryption()) m_counters.inc_stats_counter( if (bt->supports_encryption()) m_counters.inc_stats_counter(
@ -4677,7 +4677,7 @@ namespace libtorrent {
if (t) t->dec_num_connecting(m_peer_info); if (t) t->dec_num_connecting(m_peer_info);
m_connecting = false; m_connecting = false;
} }
disconnect(errors::torrent_aborted, op_bittorrent); disconnect(errors::torrent_aborted, operation_t::bittorrent);
return; return;
} }
@ -4769,7 +4769,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "LAST_ACTIVITY", "%d seconds ago" peer_log(peer_log_alert::info, "LAST_ACTIVITY", "%d seconds ago"
, int(total_seconds(d))); , int(total_seconds(d)));
#endif #endif
disconnect(errors::timed_out_inactivity, op_bittorrent); disconnect(errors::timed_out_inactivity, operation_t::bittorrent);
return; return;
} }
@ -4787,7 +4787,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "NO_HANDSHAKE", "waited %d seconds" peer_log(peer_log_alert::info, "NO_HANDSHAKE", "waited %d seconds"
, int(total_seconds(d))); , int(total_seconds(d)));
#endif #endif
disconnect(errors::timed_out_no_handshake, op_bittorrent); disconnect(errors::timed_out_no_handshake, operation_t::bittorrent);
return; return;
} }
@ -4812,7 +4812,7 @@ namespace libtorrent {
peer_log(peer_log_alert::info, "NO_REQUEST", "waited %d seconds" peer_log(peer_log_alert::info, "NO_REQUEST", "waited %d seconds"
, int(total_seconds(d))); , int(total_seconds(d)));
#endif #endif
disconnect(errors::timed_out_no_request, op_bittorrent); disconnect(errors::timed_out_no_request, operation_t::bittorrent);
return; return;
} }
@ -4845,7 +4845,7 @@ namespace libtorrent {
, int(total_seconds(d1)), int(total_seconds(d2))); , int(total_seconds(d1)), int(total_seconds(d2)));
} }
#endif #endif
disconnect(errors::timed_out_no_interest, op_bittorrent); disconnect(errors::timed_out_no_interest, operation_t::bittorrent);
return; return;
} }
@ -5257,7 +5257,7 @@ namespace libtorrent {
{ {
if (!t) if (!t)
{ {
disconnect(error.ec, op_file_read); disconnect(error.ec, operation_t::file_read);
return; return;
} }
@ -5270,7 +5270,7 @@ namespace libtorrent {
, error.operation_str(), t->get_handle()); , error.operation_str(), t->get_handle());
++m_disk_read_failures; ++m_disk_read_failures;
if (m_disk_read_failures > 100) disconnect(error.ec, op_file_read); if (m_disk_read_failures > 100) disconnect(error.ec, operation_t::file_read);
return; return;
} }
@ -5292,7 +5292,7 @@ namespace libtorrent {
if (!t) if (!t)
{ {
disconnect(error.ec, op_file_read); disconnect(error.ec, operation_t::file_read);
return; return;
} }
@ -5777,7 +5777,7 @@ namespace libtorrent {
} }
#endif #endif
on_receive(error, bytes_transferred); on_receive(error, bytes_transferred);
disconnect(error, op_sock_read); disconnect(error, operation_t::sock_read);
return; return;
} }
@ -5818,7 +5818,7 @@ namespace libtorrent {
int buffer_size = int(m_socket->available(ec)); int buffer_size = int(m_socket->available(ec));
if (ec) if (ec)
{ {
disconnect(ec, op_available); disconnect(ec, operation_t::available);
return; return;
} }
@ -5855,7 +5855,7 @@ namespace libtorrent {
} }
else if (ec) else if (ec)
{ {
disconnect(ec, op_sock_read); disconnect(ec, operation_t::sock_read);
return; return;
} }
else else
@ -5997,7 +5997,7 @@ namespace libtorrent {
m_local = m_socket->local_endpoint(ec); m_local = m_socket->local_endpoint(ec);
if (ec) if (ec)
{ {
disconnect(ec, op_getname); disconnect(ec, operation_t::getname);
return; return;
} }
@ -6010,12 +6010,12 @@ namespace libtorrent {
{ {
if (ec) if (ec)
{ {
disconnect(ec, op_get_interface); disconnect(ec, operation_t::get_interface);
return; return;
} }
disconnect(error_code( disconnect(error_code(
boost::system::errc::no_such_device, generic_category()) boost::system::errc::no_such_device, generic_category())
, op_connect); , operation_t::connect);
return; return;
} }
} }
@ -6048,7 +6048,7 @@ namespace libtorrent {
m_socket->io_control(ioc, ec); m_socket->io_control(ioc, ec);
if (ec) if (ec)
{ {
disconnect(ec, op_iocontrol); disconnect(ec, operation_t::iocontrol);
return; return;
} }
@ -6057,7 +6057,7 @@ namespace libtorrent {
// if the remote endpoint is the same as the local endpoint, we're connected // if the remote endpoint is the same as the local endpoint, we're connected
// to ourselves // to ourselves
if (m_peer_info && t) t->ban_peer(m_peer_info); if (m_peer_info && t) t->ban_peer(m_peer_info);
disconnect(errors::self_connection, op_bittorrent, 1); disconnect(errors::self_connection, operation_t::bittorrent, 1);
return; return;
} }
@ -6175,7 +6175,7 @@ namespace libtorrent {
, "%s in peer_connection::on_send_data", error.message().c_str()); , "%s in peer_connection::on_send_data", error.message().c_str());
} }
#endif #endif
disconnect(error, op_sock_write); disconnect(error, operation_t::sock_write);
return; return;
} }
if (m_disconnecting) if (m_disconnecting)

24
src/peer_list.cpp
View File

@ -170,7 +170,7 @@ namespace libtorrent {
banned.push_back(p->remote().address()); banned.push_back(p->remote().address());
p->disconnect(errors::banned_by_ip_filter p->disconnect(errors::banned_by_ip_filter
, op_bittorrent); , operation_t::bittorrent);
// what *i refers to has changed, i.e. cur was deleted // what *i refers to has changed, i.e. cur was deleted
if (m_peers.size() < count) if (m_peers.size() < count)
@ -230,7 +230,7 @@ namespace libtorrent {
banned.push_back(p->remote().address()); banned.push_back(p->remote().address());
p->disconnect(errors::banned_by_port_filter, op_bittorrent); p->disconnect(errors::banned_by_port_filter, operation_t::bittorrent);
// what *i refers to has changed, i.e. cur was deleted // what *i refers to has changed, i.e. cur was deleted
if (int(m_peers.size()) < count) if (int(m_peers.size()) < count)
{ {
@ -619,7 +619,7 @@ namespace libtorrent {
#endif #endif
if (i->banned) if (i->banned)
{ {
c.disconnect(errors::peer_banned, op_bittorrent); c.disconnect(errors::peer_banned, operation_t::bittorrent);
return false; return false;
} }
@ -631,9 +631,9 @@ namespace libtorrent {
if (self_connection) if (self_connection)
{ {
c.disconnect(errors::self_connection, op_bittorrent, 1); c.disconnect(errors::self_connection, operation_t::bittorrent, 1);
TORRENT_ASSERT(i->connection->peer_info_struct() == i); TORRENT_ASSERT(i->connection->peer_info_struct() == i);
i->connection->disconnect(errors::self_connection, op_bittorrent, 1); i->connection->disconnect(errors::self_connection, operation_t::bittorrent, 1);
TORRENT_ASSERT(i->connection == nullptr); TORRENT_ASSERT(i->connection == nullptr);
return false; return false;
} }
@ -645,7 +645,7 @@ namespace libtorrent {
{ {
// if the other end connected to us both times, just drop // if the other end connected to us both times, just drop
// the second one. Or if we made both connections. // the second one. Or if we made both connections.
c.disconnect(errors::duplicate_peer_id, op_bittorrent); c.disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
return false; return false;
} }
else else
@ -683,12 +683,12 @@ namespace libtorrent {
// we should keep our outgoing connection // we should keep our outgoing connection
if (!outgoing1) if (!outgoing1)
{ {
c.disconnect(errors::duplicate_peer_id, op_bittorrent); c.disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
return false; return false;
} }
TORRENT_ASSERT(m_locked_peer == nullptr); TORRENT_ASSERT(m_locked_peer == nullptr);
m_locked_peer = i; m_locked_peer = i;
i->connection->disconnect(errors::duplicate_peer_id, op_bittorrent); i->connection->disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
m_locked_peer = nullptr; m_locked_peer = nullptr;
} }
else else
@ -705,12 +705,12 @@ namespace libtorrent {
// they should keep their outgoing connection // they should keep their outgoing connection
if (outgoing1) if (outgoing1)
{ {
c.disconnect(errors::duplicate_peer_id, op_bittorrent); c.disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
return false; return false;
} }
TORRENT_ASSERT(m_locked_peer == nullptr); TORRENT_ASSERT(m_locked_peer == nullptr);
m_locked_peer = i; m_locked_peer = i;
i->connection->disconnect(errors::duplicate_peer_id, op_bittorrent); i->connection->disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
m_locked_peer = nullptr; m_locked_peer = nullptr;
} }
} }
@ -731,7 +731,7 @@ namespace libtorrent {
erase_peers(state, force_erase); erase_peers(state, force_erase);
if (int(m_peers.size()) >= state->max_peerlist_size) if (int(m_peers.size()) >= state->max_peerlist_size)
{ {
c.disconnect(errors::too_many_connections, op_bittorrent); c.disconnect(errors::too_many_connections, operation_t::bittorrent);
return false; return false;
} }
// restore it // restore it
@ -827,7 +827,7 @@ namespace libtorrent {
// we need to make sure we don't let it do that, locking i // we need to make sure we don't let it do that, locking i
TORRENT_ASSERT(m_locked_peer == nullptr); TORRENT_ASSERT(m_locked_peer == nullptr);
m_locked_peer = p; m_locked_peer = p;
p->connection->disconnect(errors::duplicate_peer_id, op_bittorrent); p->connection->disconnect(errors::duplicate_peer_id, operation_t::bittorrent);
m_locked_peer = nullptr; m_locked_peer = nullptr;
erase_peer(p, state); erase_peer(p, state);
return false; return false;

8
src/session_impl.cpp
View File

@ -1004,7 +1004,7 @@ namespace aux {
// can't iterate over it here // can't iterate over it here
auto conns = m_connections; auto conns = m_connections;
for (auto const& p : conns) for (auto const& p : conns)
p->disconnect(errors::stopping_torrent, op_bittorrent); p->disconnect(errors::stopping_torrent, operation_t::bittorrent);
// close the listen sockets // close the listen sockets
for (auto const& l : m_listen_sockets) for (auto const& l : m_listen_sockets)
@ -2735,7 +2735,7 @@ namespace {
if (m_alerts.should_post<peer_error_alert>()) if (m_alerts.should_post<peer_error_alert>())
{ {
m_alerts.emplace_alert<peer_error_alert>(torrent_handle(), endp m_alerts.emplace_alert<peer_error_alert>(torrent_handle(), endp
, peer_id(), op_ssl_handshake, ec); , peer_id(), operation_t::ssl_handshake, ec);
} }
return; return;
} }
@ -2911,7 +2911,7 @@ namespace {
if (m_alerts.should_post<peer_disconnected_alert>()) if (m_alerts.should_post<peer_disconnected_alert>())
{ {
m_alerts.emplace_alert<peer_disconnected_alert>(torrent_handle(), endp, peer_id() m_alerts.emplace_alert<peer_disconnected_alert>(torrent_handle(), endp, peer_id()
, op_bittorrent, s->type() , operation_t::bittorrent, s->type()
, error_code(errors::too_many_connections) , error_code(errors::too_many_connections)
, close_reason_t::none); , close_reason_t::none);
} }
@ -3381,7 +3381,7 @@ namespace {
timeout *= is_i2p(*p->get_socket()) ? 4 : 1; timeout *= is_i2p(*p->get_socket()) ? 4 : 1;
#endif #endif
if (m_last_tick - p->connected_time () > seconds(timeout)) if (m_last_tick - p->connected_time () > seconds(timeout))
p->disconnect(errors::timed_out, op_bittorrent); p->disconnect(errors::timed_out, operation_t::bittorrent);
} }
// -------------------------------------------------------------- // --------------------------------------------------------------

4
src/smart_ban.cpp
View File

@ -226,7 +226,7 @@ namespace {
#endif #endif
m_torrent.ban_peer(p); m_torrent.ban_peer(p);
if (p->connection) p->connection->disconnect( if (p->connection) p->connection->disconnect(
errors::peer_banned, op_bittorrent); errors::peer_banned, operation_t::bittorrent);
} }
// we already have this exact entry in the map // we already have this exact entry in the map
// we don't have to insert it // we don't have to insert it
@ -302,7 +302,7 @@ namespace {
#endif #endif
m_torrent.ban_peer(p); m_torrent.ban_peer(p);
if (p->connection) p->connection->disconnect( if (p->connection) p->connection->disconnect(
errors::peer_banned, op_bittorrent); errors::peer_banned, operation_t::bittorrent);
} }
torrent& m_torrent; torrent& m_torrent;

52
src/torrent.cpp
View File

@ -1038,7 +1038,7 @@ namespace libtorrent {
if (alerts().should_post<file_error_alert>()) if (alerts().should_post<file_error_alert>())
alerts().emplace_alert<file_error_alert>(error.ec alerts().emplace_alert<file_error_alert>(error.ec
, resolve_filename(error.file()), error.operation_str(), get_handle()); , resolve_filename(error.file()), error.operation_str(), get_handle());
if (c) c->disconnect(errors::no_memory, op_file); if (c) c->disconnect(errors::no_memory, operation_t::file);
return; return;
} }
@ -2132,7 +2132,7 @@ namespace libtorrent {
clear_error(); clear_error();
disconnect_all(errors::stopping_torrent, op_bittorrent); disconnect_all(errors::stopping_torrent, operation_t::bittorrent);
stop_announcing(); stop_announcing();
// we're checking everything anyway, no point in assuming we are a seed // we're checking everything anyway, no point in assuming we are a seed
@ -4113,7 +4113,7 @@ namespace libtorrent {
} }
peer->peer_log(peer_log_alert::info, "BANNING_PEER", "Too many corrupt pieces"); peer->peer_log(peer_log_alert::info, "BANNING_PEER", "Too many corrupt pieces");
#endif #endif
peer->disconnect(errors::too_many_corrupt_pieces, op_bittorrent); peer->disconnect(errors::too_many_corrupt_pieces, operation_t::bittorrent);
} }
} }
} }
@ -4313,7 +4313,7 @@ namespace libtorrent {
// disconnect all peers and close all // disconnect all peers and close all
// files belonging to the torrents // files belonging to the torrents
disconnect_all(errors::torrent_aborted, op_bittorrent); disconnect_all(errors::torrent_aborted, operation_t::bittorrent);
// make sure to destruct the peers immediately // make sure to destruct the peers immediately
on_remove_peers(); on_remove_peers();
@ -5487,7 +5487,7 @@ namespace libtorrent {
// disconnect it and clear its reference to the peer_info object // disconnect it and clear its reference to the peer_info object
// that's part of the web_seed_t we're about to remove // that's part of the web_seed_t we're about to remove
TORRENT_ASSERT(peer->m_in_use == 1337); TORRENT_ASSERT(peer->m_in_use == 1337);
peer->disconnect(boost::asio::error::operation_aborted, op_bittorrent); peer->disconnect(boost::asio::error::operation_aborted, operation_t::bittorrent);
peer->set_peer_info(nullptr); peer->set_peer_info(nullptr);
} }
if (has_picker()) picker().clear_peer(&web->peer_info); if (has_picker()) picker().clear_peer(&web->peer_info);
@ -6553,7 +6553,7 @@ namespace libtorrent {
TORRENT_CATCH (std::exception const&) TORRENT_CATCH (std::exception const&)
{ {
TORRENT_ASSERT(m_iterating_connections == 0); TORRENT_ASSERT(m_iterating_connections == 0);
c->disconnect(errors::no_error, op_bittorrent, 1); c->disconnect(errors::no_error, operation_t::bittorrent, 1);
return false; return false;
} }
@ -6675,14 +6675,14 @@ namespace libtorrent {
if (ssl_conn == nullptr) if (ssl_conn == nullptr)
{ {
// don't allow non SSL peers on SSL torrents // don't allow non SSL peers on SSL torrents
p->disconnect(errors::requires_ssl_connection, op_bittorrent); p->disconnect(errors::requires_ssl_connection, operation_t::bittorrent);
return false; return false;
} }
if (!m_ssl_ctx) if (!m_ssl_ctx)
{ {
// we don't have a valid cert, don't accept any connection! // we don't have a valid cert, don't accept any connection!
p->disconnect(errors::invalid_ssl_cert, op_ssl_handshake); p->disconnect(errors::invalid_ssl_cert, operation_t::ssl_handshake);
return false; return false;
} }
@ -6693,7 +6693,7 @@ namespace libtorrent {
// connected to one torrent, and the BitTorrent protocol // connected to one torrent, and the BitTorrent protocol
// to a different one. This is probably an attempt to circumvent // to a different one. This is probably an attempt to circumvent
// access control. Don't allow it. // access control. Don't allow it.
p->disconnect(errors::invalid_ssl_cert, op_bittorrent); p->disconnect(errors::invalid_ssl_cert, operation_t::bittorrent);
return false; return false;
} }
} }
@ -6705,7 +6705,7 @@ namespace libtorrent {
{ {
// Don't accidentally allow seeding of SSL torrents, just // Don't accidentally allow seeding of SSL torrents, just
// because libtorrent wasn't built with SSL support // because libtorrent wasn't built with SSL support
p->disconnect(errors::requires_ssl_connection, op_ssl_handshake); p->disconnect(errors::requires_ssl_connection, operation_t::ssl_handshake);
return false; return false;
} }
#endif // TORRENT_USE_OPENSSL #endif // TORRENT_USE_OPENSSL
@ -6722,7 +6722,7 @@ namespace libtorrent {
if (m_ses.alerts().should_post<peer_blocked_alert>()) if (m_ses.alerts().should_post<peer_blocked_alert>())
m_ses.alerts().emplace_alert<peer_blocked_alert>(get_handle() m_ses.alerts().emplace_alert<peer_blocked_alert>(get_handle()
, p->remote(), peer_blocked_alert::ip_filter); , p->remote(), peer_blocked_alert::ip_filter);
p->disconnect(errors::banned_by_ip_filter, op_bittorrent); p->disconnect(errors::banned_by_ip_filter, operation_t::bittorrent);
return false; return false;
} }
@ -6730,19 +6730,19 @@ namespace libtorrent {
|| m_state == torrent_status::checking_resume_data) || m_state == torrent_status::checking_resume_data)
&& valid_metadata()) && valid_metadata())
{ {
p->disconnect(errors::torrent_not_ready, op_bittorrent); p->disconnect(errors::torrent_not_ready, operation_t::bittorrent);
return false; return false;
} }
if (!m_ses.has_connection(p)) if (!m_ses.has_connection(p))
{ {
p->disconnect(errors::peer_not_constructed, op_bittorrent); p->disconnect(errors::peer_not_constructed, operation_t::bittorrent);
return false; return false;
} }
if (m_ses.is_aborted()) if (m_ses.is_aborted())
{ {
p->disconnect(errors::session_closing, op_bittorrent); p->disconnect(errors::session_closing, operation_t::bittorrent);
return false; return false;
} }
@ -6778,10 +6778,10 @@ namespace libtorrent {
if (i == end() || !(*i)->is_connecting() || (*i)->is_disconnecting()) if (i == end() || !(*i)->is_connecting() || (*i)->is_disconnecting())
{ {
// this seems odd, but we might as well handle it // this seems odd, but we might as well handle it
p->disconnect(errors::too_many_connections, op_bittorrent); p->disconnect(errors::too_many_connections, operation_t::bittorrent);
return false; return false;
} }
(*i)->disconnect(errors::too_many_connections, op_bittorrent); (*i)->disconnect(errors::too_many_connections, operation_t::bittorrent);
// if this peer was let in via connections slack, // if this peer was let in via connections slack,
// it has done its duty of causing the disconnection // it has done its duty of causing the disconnection
@ -6817,7 +6817,7 @@ namespace libtorrent {
, m_max_connections); , m_max_connections);
} }
#endif #endif
p->disconnect(errors::too_many_connections, op_bittorrent); p->disconnect(errors::too_many_connections, operation_t::bittorrent);
return false; return false;
} }
peers_erased(st.erased); peers_erased(st.erased);
@ -6869,7 +6869,7 @@ namespace libtorrent {
, m_max_connections); , m_max_connections);
} }
#endif #endif
peer->disconnect(errors::too_many_connections, op_bittorrent); peer->disconnect(errors::too_many_connections, operation_t::bittorrent);
p->peer_disconnected_other(); p->peer_disconnected_other();
} }
else else
@ -6884,7 +6884,7 @@ namespace libtorrent {
, m_max_connections); , m_max_connections);
} }
#endif #endif
p->disconnect(errors::too_many_connections, op_bittorrent); p->disconnect(errors::too_many_connections, operation_t::bittorrent);
// we have to do this here because from the peer's point of view // we have to do this here because from the peer's point of view
// it wasn't really attached to the torrent, but we do need // it wasn't really attached to the torrent, but we do need
// to let peer_list know we're removing it // to let peer_list know we're removing it
@ -7152,7 +7152,7 @@ namespace libtorrent {
for (auto p : range(to_disconnect.begin(), end)) for (auto p : range(to_disconnect.begin(), end))
{ {
TORRENT_ASSERT(p->associated_torrent().lock().get() == this); TORRENT_ASSERT(p->associated_torrent().lock().get() == this);
p->disconnect(ec, op_bittorrent); p->disconnect(ec, operation_t::bittorrent);
} }
return static_cast<int>(end - to_disconnect.begin()); return static_cast<int>(end - to_disconnect.begin());
} }
@ -7204,7 +7204,7 @@ namespace libtorrent {
} }
std::for_each(seeds.begin(), seeds.end() std::for_each(seeds.begin(), seeds.end()
, std::bind(&peer_connection::disconnect, _1, errors::torrent_finished , std::bind(&peer_connection::disconnect, _1, errors::torrent_finished
, op_bittorrent, 0)); , operation_t::bittorrent, 0));
} }
if (m_abort) return; if (m_abort) return;
@ -8029,7 +8029,7 @@ namespace libtorrent {
log_to_all_peers("deleting files"); log_to_all_peers("deleting files");
#endif #endif
disconnect_all(errors::torrent_removed, op_bittorrent); disconnect_all(errors::torrent_removed, operation_t::bittorrent);
stop_announcing(); stop_announcing();
// storage may be nullptr during shutdown // storage may be nullptr during shutdown
@ -8414,7 +8414,7 @@ namespace libtorrent {
if (alerts().should_post<torrent_paused_alert>()) if (alerts().should_post<torrent_paused_alert>())
alerts().emplace_alert<torrent_paused_alert>(get_handle()); alerts().emplace_alert<torrent_paused_alert>(get_handle());
} }
disconnect_all(errors::torrent_paused, op_bittorrent); disconnect_all(errors::torrent_paused, operation_t::bittorrent);
return; return;
} }
@ -8434,7 +8434,7 @@ namespace libtorrent {
alerts().emplace_alert<torrent_paused_alert>(get_handle()); alerts().emplace_alert<torrent_paused_alert>(get_handle());
} }
disconnect_all(errors::torrent_paused, op_bittorrent); disconnect_all(errors::torrent_paused, operation_t::bittorrent);
} }
else else
{ {
@ -8466,7 +8466,7 @@ namespace libtorrent {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
p->peer_log(peer_log_alert::info, "CLOSING_CONNECTION", "torrent_paused"); p->peer_log(peer_log_alert::info, "CLOSING_CONNECTION", "torrent_paused");
#endif #endif
p->disconnect(errors::torrent_paused, op_bittorrent); p->disconnect(errors::torrent_paused, operation_t::bittorrent);
} }
} }
@ -9149,7 +9149,7 @@ namespace libtorrent {
TORRENT_ASSERT(to_disconnect <= seeds.end_index()); TORRENT_ASSERT(to_disconnect <= seeds.end_index());
for (int i = 0; i < to_disconnect; ++i) for (int i = 0; i < to_disconnect; ++i)
seeds[i]->disconnect(errors::upload_upload_connection seeds[i]->disconnect(errors::upload_upload_connection
, op_bittorrent); , operation_t::bittorrent);
} }
if (num_downloaders == 0) return; if (num_downloaders == 0) return;

6
src/ut_metadata.cpp
View File

@ -304,7 +304,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA" m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "packet too big %d", length); , "packet too big %d", length);
#endif #endif
m_pc.disconnect(errors::invalid_metadata_message, op_bittorrent, 2); m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
return true; return true;
} }
@ -318,7 +318,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA" m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "not a dictionary"); , "not a dictionary");
#endif #endif
m_pc.disconnect(errors::invalid_metadata_message, op_bittorrent, 2); m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
return true; return true;
} }
@ -331,7 +331,7 @@ namespace libtorrent {namespace {
m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA" m_pc.peer_log(peer_log_alert::incoming_message, "UT_METADATA"
, "missing or invalid keys"); , "missing or invalid keys");
#endif #endif
m_pc.disconnect(errors::invalid_metadata_message, op_bittorrent, 2); m_pc.disconnect(errors::invalid_metadata_message, operation_t::bittorrent, 2);
return true; return true;
} }
int type = int(type_ent->integer()); int type = int(type_ent->integer());

6
src/ut_pex.cpp
View File

@ -271,7 +271,7 @@ namespace libtorrent {namespace {
if (length > 500 * 1024) if (length > 500 * 1024)
{ {
m_pc.disconnect(errors::pex_message_too_large, op_bittorrent, 2); m_pc.disconnect(errors::pex_message_too_large, operation_t::bittorrent, 2);
return true; return true;
} }
@ -282,7 +282,7 @@ namespace libtorrent {namespace {
{ {
// this client appears to be trying to flood us // this client appears to be trying to flood us
// with pex messages. Don't allow that. // with pex messages. Don't allow that.
m_pc.disconnect(errors::too_frequent_pex, op_bittorrent); m_pc.disconnect(errors::too_frequent_pex, operation_t::bittorrent);
return true; return true;
} }
@ -296,7 +296,7 @@ namespace libtorrent {namespace {
int const ret = bdecode(body.begin(), body.end(), pex_msg, ec); int const ret = bdecode(body.begin(), body.end(), pex_msg, ec);
if (ret != 0 || pex_msg.type() != bdecode_node::dict_t) if (ret != 0 || pex_msg.type() != bdecode_node::dict_t)
{ {
m_pc.disconnect(errors::invalid_pex_message, op_bittorrent, 2); m_pc.disconnect(errors::invalid_pex_message, operation_t::bittorrent, 2);
return true; return true;
} }

24
src/web_peer_connection.cpp
View File

@ -181,7 +181,7 @@ void web_peer_connection::disconnect(error_code const& ec
{ {
if (is_disconnecting()) return; if (is_disconnecting()) return;
if (op == op_sock_write && ec == boost::system::errc::broken_pipe) if (op == operation_t::sock_write && ec == boost::system::errc::broken_pipe)
{ {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
// a write operation failed with broken-pipe. This typically happens // a write operation failed with broken-pipe. This typically happens
@ -204,7 +204,7 @@ void web_peer_connection::disconnect(error_code const& ec
return; return;
} }
if (op == op_connect && m_web && !m_web->endpoints.empty()) if (op == operation_t::connect && m_web && !m_web->endpoints.empty())
{ {
// we failed to connect to this IP. remove it so that the next attempt // we failed to connect to this IP. remove it so that the next attempt
// uses the next IP in the list. // uses the next IP in the list.
@ -590,7 +590,7 @@ void web_peer_connection::handle_error(int const bytes_left)
, error_msg); , error_msg);
} }
received_bytes(0, bytes_left); received_bytes(0, bytes_left);
disconnect(error_code(m_parser.status_code(), http_category()), op_bittorrent, 1); disconnect(error_code(m_parser.status_code(), http_category()), operation_t::bittorrent, 1);
return; return;
} }
@ -607,7 +607,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (location.empty()) if (location.empty())
{ {
// we should not try this server again. // we should not try this server again.
t->remove_web_seed_conn(this, errors::missing_location, op_bittorrent, 2); t->remove_web_seed_conn(this, errors::missing_location, operation_t::bittorrent, 2);
m_web = nullptr; m_web = nullptr;
TORRENT_ASSERT(is_disconnecting()); TORRENT_ASSERT(is_disconnecting());
return; return;
@ -637,7 +637,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (ec) if (ec)
{ {
// we should not try this server again. // we should not try this server again.
disconnect(errors::missing_location, op_bittorrent, 1); disconnect(errors::missing_location, operation_t::bittorrent, 1);
return; return;
} }
@ -680,7 +680,7 @@ void web_peer_connection::handle_redirect(int const bytes_left)
if (m_web->have_files.get_bit(file_index) == true) if (m_web->have_files.get_bit(file_index) == true)
{ {
m_web->have_files.clear_bit(file_index); m_web->have_files.clear_bit(file_index);
disconnect(errors::redirecting, op_bittorrent, 2); disconnect(errors::redirecting, operation_t::bittorrent, 2);
} }
} }
else 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 // this web seed doesn't have any files. Don't try to request from it
// again this session // again this session
m_web->have_files.resize(t->torrent_file().num_files(), false); m_web->have_files.resize(t->torrent_file().num_files(), false);
disconnect(errors::redirecting, op_bittorrent, 2); disconnect(errors::redirecting, operation_t::bittorrent, 2);
m_web = nullptr; m_web = nullptr;
TORRENT_ASSERT(is_disconnecting()); TORRENT_ASSERT(is_disconnecting());
} }
@ -750,7 +750,7 @@ void web_peer_connection::on_receive(error_code const& error
, "%*s", int(recv_buffer.size()), recv_buffer.data()); , "%*s", int(recv_buffer.size()), recv_buffer.data());
} }
#endif #endif
disconnect(errors::http_parse_error, op_bittorrent, 2); disconnect(errors::http_parse_error, operation_t::bittorrent, 2);
return; return;
} }
@ -842,7 +842,7 @@ void web_peer_connection::on_receive(error_code const& error
{ {
received_bytes(0, int(recv_buffer.size())); received_bytes(0, int(recv_buffer.size()));
// we should not try this server again. // we should not try this server again.
t->remove_web_seed_conn(this, ec, op_bittorrent, 2); t->remove_web_seed_conn(this, ec, operation_t::bittorrent, 2);
m_web = nullptr; m_web = nullptr;
TORRENT_ASSERT(is_disconnecting()); TORRENT_ASSERT(is_disconnecting());
return; return;
@ -865,7 +865,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); , static_cast<int>(file_req.file_index), file_req.start, file_req.start + file_req.length - 1);
} }
#endif #endif
disconnect(errors::invalid_range, op_bittorrent, 2); disconnect(errors::invalid_range, operation_t::bittorrent, 2);
return; return;
} }
@ -895,7 +895,7 @@ void web_peer_connection::on_receive(error_code const& error
, "received body: %d request size: %d" , "received body: %d request size: %d"
, m_received_body, file_req.length); , m_received_body, file_req.length);
#endif #endif
disconnect(errors::invalid_range, op_bittorrent, 2); disconnect(errors::invalid_range, operation_t::bittorrent, 2);
return; return;
} }
incoming_payload(recv_buffer.data(), copy_size); incoming_payload(recv_buffer.data(), copy_size);
@ -957,7 +957,7 @@ void web_peer_connection::on_receive(error_code const& error
, "received body: %d request size: %d" , "received body: %d request size: %d"
, m_received_body, file_req.length); , m_received_body, file_req.length);
#endif #endif
disconnect(errors::invalid_range, op_bittorrent, 2); disconnect(errors::invalid_range, operation_t::bittorrent, 2);
return; return;
} }
// we just completed an HTTP file request. pop it from m_file_requests // we just completed an HTTP file request. pop it from m_file_requests