diff --git a/include/libtorrent/close_reason.hpp b/include/libtorrent/close_reason.hpp index 024ea7bab..c557fc089 100644 --- a/include/libtorrent/close_reason.hpp +++ b/include/libtorrent/close_reason.hpp @@ -40,114 +40,114 @@ namespace libtorrent // internal: these are all the reasons to disconnect a peer // all reasons caused by the peer sending unexpected data // are 256 and up. - enum close_reason_t + enum class close_reason_t : std::uint16_t { // no reason specified. Generic close. - close_no_reason = 0, + none = 0, // we're already connected to - close_duplicate_peer_id, + duplicate_peer_id, // this torrent has been removed, paused or stopped from this client. - close_torrent_removed, + torrent_removed, // client failed to allocate necessary memory for this peer connection - close_no_memory, + no_memory, // the source port of this peer is blocked - close_port_blocked, + port_blocked, // the source IP has been blocked - close_blocked, + blocked, // both ends of the connection are upload-only. staying connected would // be redundant - close_upload_to_upload, + upload_to_upload, // connection was closed because the other end is upload only and does // not have any pieces we're interested in - close_not_interested_upload_only, + not_interested_upload_only, // peer connection timed out (generic timeout) - close_timeout, + timeout, // the peers have not been interested in each other for a very long time. // disconnect - close_timed_out_interest, + timed_out_interest, // the peer has not sent any message in a long time. - close_timed_out_activity, + timed_out_activity, // the peer did not complete the handshake in too long - close_timed_out_handshake, + timed_out_handshake, // the peer sent an interested message, but did not send a request // after a very long time after being unchoked. - close_timed_out_request, + timed_out_request, // the encryption mode is blocked - close_protocol_blocked, + protocol_blocked, // the peer was disconnected in the hopes of finding a better peer // in the swarm - close_peer_churn, + peer_churn, // we have too many peers connected - close_too_many_connections, + too_many_connections, // we have too many file-descriptors open - close_too_many_files, + too_many_files, // the encryption handshake failed - close_encryption_error = 256, + encryption_error = 256, // the info hash sent as part of the handshake was not what we expected - close_invalid_info_hash, + invalid_info_hash, - close_self_connection, + self_connection, // the metadata received matched the info-hash, but failed to parse. // this is either someone finding a SHA1 collision, or the author of // the magnet link creating it from an invalid torrent - close_invalid_metadata, + invalid_metadata, // the advertised metadata size - close_metadata_too_big, + metadata_too_big, // invalid bittorrent messages - close_message_too_big, - close_invalid_message_id, - close_invalid_message, - close_invalid_piece_message, - close_invalid_have_message, - close_invalid_bitfield_message, - close_invalid_choke_message, - close_invalid_unchoke_message, - close_invalid_interested_message, - close_invalid_not_interested_message, - close_invalid_request_message, - close_invalid_reject_message, - close_invalid_allow_fast_message, - close_invalid_extended_message, - close_invalid_cancel_message, - close_invalid_dht_port_message, - close_invalid_suggest_message, - close_invalid_have_all_message, - close_invalid_dont_have_message, - close_invalid_have_none_message, - close_invalid_pex_message, - close_invalid_metadata_request_message, - close_invalid_metadata_message, - close_invalid_metadata_offset, + message_too_big, + invalid_message_id, + invalid_message, + invalid_piece_message, + invalid_have_message, + invalid_bitfield_message, + invalid_choke_message, + invalid_unchoke_message, + invalid_interested_message, + invalid_not_interested_message, + invalid_request_message, + invalid_reject_message, + invalid_allow_fast_message, + invalid_extended_message, + invalid_cancel_message, + invalid_dht_port_message, + invalid_suggest_message, + invalid_have_all_message, + invalid_dont_have_message, + invalid_have_none_message, + invalid_pex_message, + invalid_metadata_request_message, + invalid_metadata_message, + invalid_metadata_offset, // the peer sent a request while being choked - close_request_when_choked, + request_when_choked, // the peer sent corrupt data - close_corrupt_pieces, + corrupt_pieces, - close_pex_message_too_big, - close_pex_too_frequent + pex_message_too_big, + pex_too_frequent }; close_reason_t error_to_close_reason(error_code const& ec); diff --git a/include/libtorrent/socket_type.hpp b/include/libtorrent/socket_type.hpp index 26e1a2577..84d2e4f49 100644 --- a/include/libtorrent/socket_type.hpp +++ b/include/libtorrent/socket_type.hpp @@ -205,8 +205,8 @@ namespace libtorrent void close(error_code& ec); // this is only relevant for uTP connections - void set_close_reason(std::uint16_t code); - std::uint16_t get_close_reason(); + void set_close_reason(close_reason_t code); + close_reason_t get_close_reason(); endpoint_type local_endpoint(error_code& ec) const; endpoint_type remote_endpoint(error_code& ec) const; diff --git a/include/libtorrent/utp_socket_manager.hpp b/include/libtorrent/utp_socket_manager.hpp index 5265ac8b2..a7f70faec 100644 --- a/include/libtorrent/utp_socket_manager.hpp +++ b/include/libtorrent/utp_socket_manager.hpp @@ -44,7 +44,7 @@ POSSIBILITY OF SUCH DAMAGE. namespace libtorrent { - class utp_stream; + struct utp_stream; struct utp_socket_impl; struct counters; diff --git a/include/libtorrent/utp_stream.hpp b/include/libtorrent/utp_stream.hpp index 673fd79ad..107e3735b 100644 --- a/include/libtorrent/utp_stream.hpp +++ b/include/libtorrent/utp_stream.hpp @@ -39,6 +39,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/packet_buffer.hpp" #include "libtorrent/error_code.hpp" #include "libtorrent/time.hpp" +#include "libtorrent/close_reason.hpp" #include @@ -190,16 +191,18 @@ void utp_writable(utp_socket_impl* s); // will keep the utp_stream object around for. // for more details, see utp_socket_impl, which is analogous // to the kernel state for a socket. It's defined in utp_stream.cpp -class TORRENT_EXTRA_EXPORT utp_stream +struct TORRENT_EXTRA_EXPORT utp_stream { -public: - - typedef utp_stream lowest_layer_type; - typedef tcp::socket::endpoint_type endpoint_type; - typedef tcp::socket::protocol_type protocol_type; + using lowest_layer_type = utp_stream ; + using endpoint_type = tcp::socket::endpoint_type; + using protocol_type = tcp::socket::protocol_type; explicit utp_stream(io_service& io_service); ~utp_stream(); + utp_stream& operator=(utp_stream const&) = delete; + utp_stream(utp_stream const&) = delete; + utp_stream& operator=(utp_stream&&) = default; + utp_stream(utp_stream&&) = default; lowest_layer_type& lowest_layer() { return *this; } @@ -245,10 +248,10 @@ public: } void close(); - void close(error_code const& /*ec*/) { close(); } + void close(error_code const&) { close(); } - void set_close_reason(std::uint16_t code); - std::uint16_t get_close_reason(); + void set_close_reason(close_reason_t code); + close_reason_t get_close_reason(); bool is_open() const { return m_open; } @@ -258,7 +261,7 @@ public: static void on_write(void* self, std::size_t bytes_transferred , error_code const& ec, bool kill); static void on_connect(void* self, error_code const& ec, bool kill); - static void on_close_reason(void* self, std::uint16_t reason); + static void on_close_reason(void* self, close_reason_t reason); void add_read_buffer(void* buf, size_t len); void issue_read(); @@ -484,8 +487,6 @@ public: } private: - // explicitly disallow assignment, to silence msvc warning - utp_stream& operator=(utp_stream const&); void cancel_handlers(error_code const&); @@ -496,7 +497,7 @@ private: io_service& m_io_service; utp_socket_impl* m_impl; - std::uint16_t m_incoming_close_reason; + close_reason_t m_incoming_close_reason = close_reason_t::none; // this field requires another 8 bytes (including padding) bool m_open; diff --git a/src/close_reason.cpp b/src/close_reason.cpp index 6331fb340..14f7876ba 100644 --- a/src/close_reason.cpp +++ b/src/close_reason.cpp @@ -47,87 +47,87 @@ namespace libtorrent switch (ec.value()) { - TORRENT_MAP(invalid_swarm_metadata, close_invalid_metadata) - TORRENT_MAP(session_is_closing, close_torrent_removed) - TORRENT_MAP(peer_sent_empty_piece, close_invalid_piece_message) - TORRENT_MAP(mismatching_info_hash, close_invalid_info_hash) - TORRENT_MAP(port_blocked, close_port_blocked) - TORRENT_MAP(destructing_torrent, close_torrent_removed) - TORRENT_MAP(timed_out, close_timeout) - TORRENT_MAP(upload_upload_connection, close_upload_to_upload) - TORRENT_MAP(uninteresting_upload_peer, close_not_interested_upload_only) - TORRENT_MAP(invalid_info_hash, close_invalid_info_hash) - TORRENT_MAP(torrent_paused, close_torrent_removed) - TORRENT_MAP(invalid_have, close_invalid_have_message) - TORRENT_MAP(invalid_bitfield_size, close_invalid_bitfield_message) - TORRENT_MAP(too_many_requests_when_choked, close_request_when_choked) - TORRENT_MAP(invalid_piece, close_invalid_piece_message) - TORRENT_MAP(invalid_piece_size, close_invalid_piece_message) - TORRENT_MAP(no_memory, close_no_memory) - TORRENT_MAP(torrent_aborted, close_torrent_removed) - TORRENT_MAP(self_connection, close_self_connection) - TORRENT_MAP(timed_out_no_interest, close_timed_out_interest) - TORRENT_MAP(timed_out_inactivity, close_timed_out_activity) - TORRENT_MAP(timed_out_no_handshake, close_timed_out_handshake) - TORRENT_MAP(timed_out_no_request, close_timed_out_request) - TORRENT_MAP(invalid_choke, close_invalid_choke_message) - TORRENT_MAP(invalid_unchoke, close_invalid_unchoke_message) - TORRENT_MAP(invalid_interested, close_invalid_interested_message) - TORRENT_MAP(invalid_not_interested, close_invalid_not_interested_message) - TORRENT_MAP(invalid_request, close_invalid_request_message) - TORRENT_MAP(invalid_hash_list, close_invalid_message) - TORRENT_MAP(invalid_hash_piece, close_invalid_message) - TORRENT_MAP(invalid_cancel, close_invalid_cancel_message) - TORRENT_MAP(invalid_dht_port, close_invalid_dht_port_message) - TORRENT_MAP(invalid_suggest, close_invalid_suggest_message) - TORRENT_MAP(invalid_have_all, close_invalid_have_all_message) - TORRENT_MAP(invalid_have_none, close_invalid_have_none_message) - TORRENT_MAP(invalid_reject, close_invalid_reject_message) - TORRENT_MAP(invalid_allow_fast, close_invalid_allow_fast_message) - TORRENT_MAP(invalid_extended, close_invalid_extended_message) - TORRENT_MAP(invalid_message, close_invalid_message_id) - TORRENT_MAP(sync_hash_not_found, close_encryption_error) - TORRENT_MAP(invalid_encryption_constant, close_encryption_error) - TORRENT_MAP(no_plaintext_mode, close_protocol_blocked) - TORRENT_MAP(no_rc4_mode, close_protocol_blocked) - TORRENT_MAP(unsupported_encryption_mode_selected, close_protocol_blocked) - TORRENT_MAP(invalid_pad_size, close_encryption_error) - TORRENT_MAP(invalid_encrypt_handshake, close_encryption_error) - TORRENT_MAP(no_incoming_encrypted, close_protocol_blocked) - TORRENT_MAP(no_incoming_regular, close_protocol_blocked) - TORRENT_MAP(duplicate_peer_id, close_duplicate_peer_id) - TORRENT_MAP(torrent_removed, close_torrent_removed) - TORRENT_MAP(packet_too_large, close_message_too_big) - TORRENT_MAP(torrent_not_ready, close_torrent_removed) - TORRENT_MAP(session_closing, close_torrent_removed) - TORRENT_MAP(optimistic_disconnect, close_peer_churn) - TORRENT_MAP(torrent_finished, close_upload_to_upload) - TORRENT_MAP(too_many_corrupt_pieces, close_corrupt_pieces) - TORRENT_MAP(too_many_connections, close_too_many_connections) - TORRENT_MAP(peer_banned, close_blocked) - TORRENT_MAP(stopping_torrent, close_torrent_removed) - TORRENT_MAP(metadata_too_large, close_metadata_too_big) - TORRENT_MAP(invalid_metadata_size, close_metadata_too_big) - TORRENT_MAP(invalid_metadata_request, close_invalid_metadata_request_message) - TORRENT_MAP(invalid_metadata_offset, close_invalid_metadata_offset) - TORRENT_MAP(invalid_metadata_message, close_invalid_metadata_message) - TORRENT_MAP(pex_message_too_large, close_pex_message_too_big) - TORRENT_MAP(invalid_pex_message, close_invalid_pex_message) - TORRENT_MAP(invalid_lt_tracker_message, close_invalid_message) - TORRENT_MAP(too_frequent_pex, close_pex_too_frequent) - TORRENT_MAP(invalid_dont_have, close_invalid_dont_have_message) - TORRENT_MAP(requires_ssl_connection, close_protocol_blocked) - TORRENT_MAP(invalid_ssl_cert, close_blocked) - TORRENT_MAP(not_an_ssl_torrent, close_blocked) - TORRENT_MAP(banned_by_port_filter, close_port_blocked) + TORRENT_MAP(invalid_swarm_metadata, close_reason_t::invalid_metadata) + TORRENT_MAP(session_is_closing, close_reason_t::torrent_removed) + TORRENT_MAP(peer_sent_empty_piece, close_reason_t::invalid_piece_message) + TORRENT_MAP(mismatching_info_hash, close_reason_t::invalid_info_hash) + TORRENT_MAP(port_blocked, close_reason_t::port_blocked) + TORRENT_MAP(destructing_torrent, close_reason_t::torrent_removed) + TORRENT_MAP(timed_out, close_reason_t::timeout) + TORRENT_MAP(upload_upload_connection, close_reason_t::upload_to_upload) + TORRENT_MAP(uninteresting_upload_peer, close_reason_t::not_interested_upload_only) + TORRENT_MAP(invalid_info_hash, close_reason_t::invalid_info_hash) + TORRENT_MAP(torrent_paused, close_reason_t::torrent_removed) + TORRENT_MAP(invalid_have, close_reason_t::invalid_have_message) + TORRENT_MAP(invalid_bitfield_size, close_reason_t::invalid_bitfield_message) + TORRENT_MAP(too_many_requests_when_choked, close_reason_t::request_when_choked) + TORRENT_MAP(invalid_piece, close_reason_t::invalid_piece_message) + TORRENT_MAP(invalid_piece_size, close_reason_t::invalid_piece_message) + TORRENT_MAP(no_memory, close_reason_t::no_memory) + TORRENT_MAP(torrent_aborted, close_reason_t::torrent_removed) + TORRENT_MAP(self_connection, close_reason_t::self_connection) + TORRENT_MAP(timed_out_no_interest, close_reason_t::timed_out_interest) + TORRENT_MAP(timed_out_inactivity, close_reason_t::timed_out_activity) + TORRENT_MAP(timed_out_no_handshake, close_reason_t::timed_out_handshake) + TORRENT_MAP(timed_out_no_request, close_reason_t::timed_out_request) + TORRENT_MAP(invalid_choke, close_reason_t::invalid_choke_message) + TORRENT_MAP(invalid_unchoke, close_reason_t::invalid_unchoke_message) + TORRENT_MAP(invalid_interested, close_reason_t::invalid_interested_message) + TORRENT_MAP(invalid_not_interested, close_reason_t::invalid_not_interested_message) + TORRENT_MAP(invalid_request, close_reason_t::invalid_request_message) + TORRENT_MAP(invalid_hash_list, close_reason_t::invalid_message) + TORRENT_MAP(invalid_hash_piece, close_reason_t::invalid_message) + TORRENT_MAP(invalid_cancel, close_reason_t::invalid_cancel_message) + TORRENT_MAP(invalid_dht_port, close_reason_t::invalid_dht_port_message) + TORRENT_MAP(invalid_suggest, close_reason_t::invalid_suggest_message) + TORRENT_MAP(invalid_have_all, close_reason_t::invalid_have_all_message) + TORRENT_MAP(invalid_have_none, close_reason_t::invalid_have_none_message) + TORRENT_MAP(invalid_reject, close_reason_t::invalid_reject_message) + TORRENT_MAP(invalid_allow_fast, close_reason_t::invalid_allow_fast_message) + TORRENT_MAP(invalid_extended, close_reason_t::invalid_extended_message) + TORRENT_MAP(invalid_message, close_reason_t::invalid_message_id) + TORRENT_MAP(sync_hash_not_found, close_reason_t::encryption_error) + TORRENT_MAP(invalid_encryption_constant, close_reason_t::encryption_error) + TORRENT_MAP(no_plaintext_mode, close_reason_t::protocol_blocked) + TORRENT_MAP(no_rc4_mode, close_reason_t::protocol_blocked) + TORRENT_MAP(unsupported_encryption_mode_selected, close_reason_t::protocol_blocked) + TORRENT_MAP(invalid_pad_size, close_reason_t::encryption_error) + TORRENT_MAP(invalid_encrypt_handshake, close_reason_t::encryption_error) + TORRENT_MAP(no_incoming_encrypted, close_reason_t::protocol_blocked) + TORRENT_MAP(no_incoming_regular, close_reason_t::protocol_blocked) + TORRENT_MAP(duplicate_peer_id, close_reason_t::duplicate_peer_id) + TORRENT_MAP(torrent_removed, close_reason_t::torrent_removed) + TORRENT_MAP(packet_too_large, close_reason_t::message_too_big) + TORRENT_MAP(torrent_not_ready, close_reason_t::torrent_removed) + TORRENT_MAP(session_closing, close_reason_t::torrent_removed) + TORRENT_MAP(optimistic_disconnect, close_reason_t::peer_churn) + TORRENT_MAP(torrent_finished, close_reason_t::upload_to_upload) + TORRENT_MAP(too_many_corrupt_pieces, close_reason_t::corrupt_pieces) + TORRENT_MAP(too_many_connections, close_reason_t::too_many_connections) + TORRENT_MAP(peer_banned, close_reason_t::blocked) + TORRENT_MAP(stopping_torrent, close_reason_t::torrent_removed) + TORRENT_MAP(metadata_too_large, close_reason_t::metadata_too_big) + TORRENT_MAP(invalid_metadata_size, close_reason_t::metadata_too_big) + TORRENT_MAP(invalid_metadata_request, close_reason_t::invalid_metadata_request_message) + TORRENT_MAP(invalid_metadata_offset, close_reason_t::invalid_metadata_offset) + TORRENT_MAP(invalid_metadata_message, close_reason_t::invalid_metadata_message) + TORRENT_MAP(pex_message_too_large, close_reason_t::pex_message_too_big) + TORRENT_MAP(invalid_pex_message, close_reason_t::invalid_pex_message) + TORRENT_MAP(invalid_lt_tracker_message, close_reason_t::invalid_message) + TORRENT_MAP(too_frequent_pex, close_reason_t::pex_too_frequent) + TORRENT_MAP(invalid_dont_have, close_reason_t::invalid_dont_have_message) + TORRENT_MAP(requires_ssl_connection, close_reason_t::protocol_blocked) + TORRENT_MAP(invalid_ssl_cert, close_reason_t::blocked) + TORRENT_MAP(not_an_ssl_torrent, close_reason_t::blocked) + TORRENT_MAP(banned_by_port_filter, close_reason_t::port_blocked) #ifdef TORRENT_USE_ASSERTS case errors::redirecting: - return close_no_reason; + return close_reason_t::none; #endif default: - return close_no_reason; + return close_reason_t::none; } } else if (ec.category() == boost::asio::error::get_misc_category()) @@ -135,7 +135,7 @@ namespace libtorrent switch (ec.value()) { case boost::asio::error::eof: - return close_no_reason; + return close_reason_t::none; } } else if (ec.category() == generic_category()) @@ -145,23 +145,23 @@ namespace libtorrent #ifdef TORRENT_USE_ASSERTS case boost::system::errc::connection_reset: case boost::system::errc::broken_pipe: - return close_no_reason; + return close_reason_t::none; #endif case boost::system::errc::timed_out: - return close_timeout; + return close_reason_t::timeout; case boost::system::errc::too_many_files_open: case boost::system::errc::too_many_files_open_in_system: - return close_too_many_files; + return close_reason_t::too_many_files; case boost::system::errc::not_enough_memory: case boost::system::errc::no_buffer_space: - return close_no_memory; + return close_reason_t::no_memory; } } else if (ec.category() == http_category()) { - return close_no_memory; + return close_reason_t::no_memory; } - return close_no_reason; + return close_reason_t::none; } } diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index fc2d19779..4c250fd93 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -4055,9 +4055,9 @@ namespace libtorrent if (m_disconnecting) return; m_socket->set_close_reason(error_to_close_reason(ec)); - close_reason_t close_reason = close_reason_t(m_socket->get_close_reason()); + close_reason_t const close_reason = m_socket->get_close_reason(); #ifndef TORRENT_DISABLE_LOGGING - if (close_reason != 0) + if (close_reason != close_reason_t::none) { peer_log(peer_log_alert::info, "CLOSE_REASON", "%d", int(close_reason)); } diff --git a/src/session_impl.cpp b/src/session_impl.cpp index 57456dc9d..b68c36632 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -2791,7 +2791,7 @@ namespace aux { m_alerts.emplace_alert(torrent_handle(), endp, peer_id() , op_bittorrent, s->type() , error_code(errors::too_many_connections) - , close_no_reason); + , close_reason_t::none); } #ifndef TORRENT_DISABLE_LOGGING if (should_log()) diff --git a/src/socket_type.cpp b/src/socket_type.cpp index 97cd9a801..e51d8ee3f 100644 --- a/src/socket_type.cpp +++ b/src/socket_type.cpp @@ -329,7 +329,7 @@ namespace libtorrent TORRENT_SOCKTYPE_FORWARD(close(ec)) } - void socket_type::set_close_reason(std::uint16_t code) + void socket_type::set_close_reason(close_reason_t code) { switch (m_type) { @@ -345,7 +345,7 @@ namespace libtorrent } } - std::uint16_t socket_type::get_close_reason() + close_reason_t socket_type::get_close_reason() { switch (m_type) { @@ -355,7 +355,7 @@ namespace libtorrent case socket_type_int_impl>::value: return get>()->lowest_layer().get_close_reason(); #endif - default: return 0; + default: return close_reason_t::none; } } diff --git a/src/utp_stream.cpp b/src/utp_stream.cpp index ce10de7ea..de0a1d92b 100644 --- a/src/utp_stream.cpp +++ b/src/utp_stream.cpp @@ -306,7 +306,7 @@ struct utp_socket_impl // returns true if there were handlers cancelled // if it returns false, we can detach immediately bool destroy(); - void set_close_reason(std::uint16_t code); + void set_close_reason(close_reason_t code); void detach(); void send_syn(); void send_fin(); @@ -515,7 +515,7 @@ public: // if this is != 0, it means the upper layer provided a reason for why // the connection is being closed. The reason is indicated by this // non-zero value which is included in a packet header extension - std::uint16_t m_close_reason = 0; + close_reason_t m_close_reason = close_reason_t::none; // port of destination endpoint std::uint16_t m_port = 0; @@ -796,7 +796,6 @@ int utp_stream::recv_delay() const utp_stream::utp_stream(io_service& io_service) : m_io_service(io_service) , m_impl(nullptr) - , m_incoming_close_reason(0) , m_open(false) { } @@ -806,13 +805,13 @@ utp_socket_impl* utp_stream::get_impl() return m_impl; } -void utp_stream::set_close_reason(std::uint16_t code) +void utp_stream::set_close_reason(close_reason_t code) { if (!m_impl) return; m_impl->set_close_reason(code); } -std::uint16_t utp_stream::get_close_reason() +close_reason_t utp_stream::get_close_reason() { return m_incoming_close_reason; } @@ -878,14 +877,14 @@ int utp_stream::read_buffer_size() const return m_impl->m_receive_buffer_size; } -void utp_stream::on_close_reason(void* self, std::uint16_t close_reason) +void utp_stream::on_close_reason(void* self, close_reason_t reason) { utp_stream* s = static_cast(self); // it's possible the socket has been unlinked already, in which case m_impl // will be nullptr if (s->m_impl) - s->m_incoming_close_reason = close_reason; + s->m_incoming_close_reason = reason; } void utp_stream::on_read(void* self, size_t bytes_transferred @@ -1248,11 +1247,11 @@ void utp_socket_impl::maybe_trigger_send_callback() m_write_buffer.clear(); } -void utp_socket_impl::set_close_reason(std::uint16_t code) +void utp_socket_impl::set_close_reason(close_reason_t code) { #if TORRENT_UTP_LOG UTP_LOGV("%8p: set_close_reason: %d\n" - , static_cast(this), int(m_close_reason)); + , static_cast(this), static_cast(m_close_reason)); #endif m_close_reason = code; } @@ -1459,7 +1458,7 @@ void utp_socket_impl::parse_close_reason(std::uint8_t const* ptr, int size) if (size != 4) return; // skip reserved bytes ptr += 2; - std::uint16_t incoming_close_reason = detail::read_uint16(ptr); + close_reason_t incoming_close_reason = static_cast(detail::read_uint16(ptr)); UTP_LOGV("%8p: incoming close_reason: %d\n" , static_cast(this), int(incoming_close_reason)); @@ -1751,7 +1750,7 @@ bool utp_socket_impl::send_pkt(int const flags) if (sack > 32) sack = 32; } - std::uint32_t const close_reason = m_close_reason; + std::uint32_t const close_reason = static_cast(m_close_reason); // MTU DISCOVERY @@ -3532,7 +3531,7 @@ void utp_socket_impl::tick(time_point now) // observed that the SSL shutdown sometimes can hang in a state where // there's no outstanding data, and it won't receive any more from the // other end. This catches that case and let the socket time out. - if (m_outbuf.size() || m_close_reason != 0) + if (m_outbuf.size() || m_close_reason != close_reason_t::none) { ++m_num_timeouts; m_sm->inc_stats_counter(counters::utp_timeout);