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

use enum class for close reason

This commit is contained in:
arvidn 2017-02-03 20:27:31 -05:00 committed by Arvid Norberg
parent 4c487ec47c
commit 34ecb60c09
9 changed files with 167 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
include/libtorrent/close_reason.hpp
View File

@ -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);

4
include/libtorrent/socket_type.hpp
View File

@ -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;

2
include/libtorrent/utp_socket_manager.hpp
View File

@ -44,7 +44,7 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent
{
class utp_stream;
struct utp_stream;
struct utp_socket_impl;
struct counters;

27
include/libtorrent/utp_stream.hpp
View File

@ -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 <functional>
@ -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;

164
src/close_reason.cpp
View File

@ -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;
}
}

4
src/peer_connection.cpp
View File

@ -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));
}

2
src/session_impl.cpp
View File

@ -2791,7 +2791,7 @@ namespace aux {
m_alerts.emplace_alert<peer_disconnected_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())

6
src/socket_type.cpp
View File

@ -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<ssl_stream<utp_stream>>::value:
return get<ssl_stream<utp_stream>>()->lowest_layer().get_close_reason();
#endif
default: return 0;
default: return close_reason_t::none;
}
}

23
src/utp_stream.cpp
View File

@ -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<utp_stream*>(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<void*>(this), int(m_close_reason));
, static_cast<void*>(this), static_cast<int>(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<close_reason_t>(detail::read_uint16(ptr));
UTP_LOGV("%8p: incoming close_reason: %d\n"
, static_cast<void*>(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<std::uint32_t>(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);