mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

refactor: make tr_peerIoGetAddress() a member function (#3141) 

* refactor: make tr_peerIoGetAddress() a member function

* refactor: make tr_peerIo.addr a private field

* refactor: make tr_peerIoIsIncoming a member function

* refactor: make tr_peerIoHasBandwidthLeft a member function

* refactor: make tr_peerIoGetPieceSpeed_Bps a member function

* refactor: make tr_peerIoSupportsFEXT() a member function

* refactor: mark tr_peerIo::supportsDHT nodiscard

* refactor: update naming style for tr_peerIo fields

* refactor: make tr_peerIo.is_seed a private field
This commit is contained in:
Charles Kerr 2022-05-26 12:17:03 -05:00 committed by GitHub
parent 4f0f3f1c49
commit 51760bd5c1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 156 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libtransmission/bandwidth.cc
View File

@ -244,7 +244,7 @@ void Bandwidth::allocate(tr_direction dir, unsigned int period_msec)
* or (2) the next Bandwidth::allocate () call, when we start over again. */
for (auto* io : tmp)
{
tr_peerIoSetEnabled(io, dir, tr_peerIoHasBandwidthLeft(io, dir));
tr_peerIoSetEnabled(io, dir, io->hasBandwidthLeft(dir));
}
for (auto* io : tmp)

33
libtransmission/handshake.cc
View File

@ -108,6 +108,11 @@ enum handshake_state_t
struct tr_handshake
{
[[nodiscard]] auto constexpr isIncoming() const noexcept
{
return io->isIncoming();
}
bool haveReadAnythingFromPeer;
bool haveSentBitTorrentHandshake;
tr_peerIo* io;
@ -262,9 +267,9 @@ static handshake_parse_err_t parseHandshake(tr_handshake* handshake, struct evbu
*** Extensions
**/
tr_peerIoEnableDHT(handshake->io, HANDSHAKE_HAS_DHT(reserved));
tr_peerIoEnableLTEP(handshake->io, HANDSHAKE_HAS_LTEP(reserved));
tr_peerIoEnableFEXT(handshake->io, HANDSHAKE_HAS_FASTEXT(reserved));
handshake->io->enableDHT(HANDSHAKE_HAS_DHT(reserved));
handshake->io->enableLTEP(HANDSHAKE_HAS_LTEP(reserved));
handshake->io->enableFEXT(HANDSHAKE_HAS_FASTEXT(reserved));
return HANDSHAKE_OK;
}
@ -595,7 +600,7 @@ static ReadState readHandshake(tr_handshake* handshake, struct evbuffer* inbuf)
{
tr_peerIoSetEncryption(handshake->io, PEER_ENCRYPTION_RC4);
if (tr_peerIoIsIncoming(handshake->io))
if (handshake->isIncoming())
{
tr_logAddTraceHand(handshake, "I think peer is sending us an encrypted handshake...");
setState(handshake, AWAITING_YA);
@ -632,15 +637,15 @@ static ReadState readHandshake(tr_handshake* handshake, struct evbuffer* inbuf)
*** Extensions
**/
tr_peerIoEnableDHT(handshake->io, HANDSHAKE_HAS_DHT(reserved));
tr_peerIoEnableLTEP(handshake->io, HANDSHAKE_HAS_LTEP(reserved));
tr_peerIoEnableFEXT(handshake->io, HANDSHAKE_HAS_FASTEXT(reserved));
handshake->io->enableDHT(HANDSHAKE_HAS_DHT(reserved));
handshake->io->enableLTEP(HANDSHAKE_HAS_LTEP(reserved));
handshake->io->enableFEXT(HANDSHAKE_HAS_FASTEXT(reserved));
/* torrent hash */
auto hash = tr_sha1_digest_t{};
tr_peerIoReadBytes(handshake->io, inbuf, std::data(hash), std::size(hash));
if (tr_peerIoIsIncoming(handshake->io))
if (handshake->isIncoming())
{
if (!handshake->session->torrents().contains(hash))
{
@ -694,9 +699,7 @@ static ReadState readPeerId(tr_handshake* handshake, struct evbuffer* inbuf)
char client[128] = {};
tr_clientForId(client, sizeof(client), peer_id);
tr_logAddTraceHand(
handshake,
fmt::format("peer-id is '{}' ... isIncoming is {}", client, tr_peerIoIsIncoming(handshake->io)));
tr_logAddTraceHand(handshake, fmt::format("peer-id is '{}' ... isIncoming is {}", client, handshake->isIncoming()));
// if we've somehow connected to ourselves, don't keep the connection
auto const hash = tr_peerIoGetTorrentHash(handshake->io);
@ -815,7 +818,7 @@ static ReadState readCryptoProvide(tr_handshake* handshake, struct evbuffer* inb
if (auto const* const tor = tr_torrentFindFromObfuscatedHash(handshake->session, obfuscated_hash); tor != nullptr)
{
bool const clientIsSeed = tor->isDone();
bool const peerIsSeed = tr_peerMgrPeerIsSeed(tor, tr_peerIoGetAddress(handshake->io, nullptr));
bool const peerIsSeed = tr_peerMgrPeerIsSeed(tor, handshake->io->address());
tr_logAddTraceHand(
handshake,
fmt::format("got INCOMING connection's encrypted handshake for torrent [{}]", tor->name()));
@ -1130,7 +1133,7 @@ static void gotError(tr_peerIo* io, short what, void* vhandshake)
int errcode = errno;
auto* handshake = static_cast<tr_handshake*>(vhandshake);
if (io->socket.type == TR_PEER_SOCKET_TYPE_UTP && !tr_peerIoIsIncoming(io) && handshake->state == AWAITING_YB)
if (io->socket.type == TR_PEER_SOCKET_TYPE_UTP && !io->isIncoming() && handshake->state == AWAITING_YB)
{
/* This peer probably doesn't speak uTP. */
@ -1140,7 +1143,7 @@ static void gotError(tr_peerIo* io, short what, void* vhandshake)
/* Don't mark a peer as non-uTP unless it's really a connect failure. */
if ((errcode == ETIMEDOUT || errcode == ECONNREFUSED) && tr_isTorrent(tor))
{
tr_peerMgrSetUtpFailed(tor, tr_peerIoGetAddress(io, nullptr), true);
tr_peerMgrSetUtpFailed(tor, io->address(), true);
}
if (tr_peerIoReconnect(handshake->io) == 0)
@ -1207,7 +1210,7 @@ tr_handshake* tr_handshakeNew(
tr_peerIoSetIOFuncs(handshake->io, canRead, nullptr, gotError, handshake);
tr_peerIoSetEncryption(io, PEER_ENCRYPTION_NONE);
if (tr_peerIoIsIncoming(handshake->io))
if (handshake->isIncoming())
{
setReadState(handshake, AWAITING_HANDSHAKE);
}

37
libtransmission/peer-io.cc
View File

@ -487,7 +487,7 @@ static void utp_on_state_change(void* vio, int state)
if (state == UTP_STATE_CONNECT)
{
tr_logAddTraceIo(io, "utp_on_state_change -- changed to connected");
io->utpSupported = true;
io->utp_supported_ = true;
}
else if (state == UTP_STATE_WRITABLE)
{
@ -904,35 +904,9 @@ void tr_peerIoUnrefImpl(char const* file, int line, tr_peerIo* io)
}
}
tr_address const* tr_peerIoGetAddress(tr_peerIo const* io, tr_port* port)
{
TR_ASSERT(tr_isPeerIo(io));
if (port != nullptr)
{
*port = io->port;
}
return &io->addr;
}
std::string tr_peerIo::addrStr() const
{
return tr_isPeerIo(this) ? this->addr.readable(this->port) : "error";
}
char const* tr_peerIoGetAddrStr(tr_peerIo const* io, char* buf, size_t buflen)
{
if (tr_isPeerIo(io))
{
tr_address_and_port_to_string(buf, buflen, &io->addr, io->port);
}
else
{
tr_strlcpy(buf, "error", buflen);
}
return buf;
return tr_isPeerIo(this) ? this->addr_.readable(this->port_) : "error";
}
void tr_peerIoSetIOFuncs(tr_peerIo* io, tr_can_read_cb readcb, tr_did_write_cb writecb, tr_net_error_cb errcb, void* userData)
@ -953,7 +927,7 @@ void tr_peerIoClear(tr_peerIo* io)
int tr_peerIoReconnect(tr_peerIo* io)
{
TR_ASSERT(tr_isPeerIo(io));
TR_ASSERT(!tr_peerIoIsIncoming(io));
TR_ASSERT(!io->isIncoming());
tr_session* session = tr_peerIoGetSession(io);
@ -962,7 +936,8 @@ int tr_peerIoReconnect(tr_peerIo* io)
io_close_socket(io);
io->socket = tr_netOpenPeerSocket(session, &io->addr, io->port, io->is_seed);
auto const [addr, port] = io->socketAddress();
io->socket = tr_netOpenPeerSocket(session, &addr, port, io->isSeed());
if (io->socket.type != TR_PEER_SOCKET_TYPE_TCP)
{
@ -973,7 +948,7 @@ int tr_peerIoReconnect(tr_peerIo* io)
io->event_write = event_new(session->event_base, io->socket.handle.tcp, EV_WRITE, event_write_cb, io);
event_enable(io, pendingEvents);
io->session->setSocketTOS(io->socket.handle.tcp, io->addr.type);
io->session->setSocketTOS(io->socket.handle.tcp, addr.type);
maybeSetCongestionAlgorithm(io->socket.handle.tcp, session->peerCongestionAlgorithm());
return 0;

161
libtransmission/peer-io.h
View File

@ -19,6 +19,7 @@
#include <memory>
#include <optional>
#include <string>
#include <utility> // std::make_pair
#include <event2/buffer.h>
@ -26,7 +27,7 @@
#include "bandwidth.h"
#include "crypto.h"
#include "net.h" /* tr_address */
#include "net.h" // tr_address
#include "peer-socket.h"
#include "tr-assert.h"
@ -78,29 +79,92 @@ public:
tr_session* session_in,
tr_sha1_digest_t const* torrent_hash,
bool is_incoming,
tr_address const& addr_in,
tr_port port_in,
bool is_seed_in,
tr_address const& addr,
tr_port port,
bool is_seed,
time_t current_time)
: crypto{ torrent_hash, is_incoming }
, addr{ addr_in }
, session{ session_in }
, time_created{ current_time }
, port{ port_in }
, is_seed{ is_seed_in }
, addr_{ addr }
, port_{ port }
, is_seed_{ is_seed }
{
}
[[nodiscard]] constexpr tr_address const& address() const noexcept
{
return addr_;
}
[[nodiscard]] constexpr std::pair<tr_address, tr_port> socketAddress() const noexcept
{
return std::make_pair(addr_, port_);
}
std::string addrStr() const;
[[nodiscard]] constexpr bool isIncoming() noexcept
{
return crypto.is_incoming;
}
[[nodiscard]] auto getReadBuffer() noexcept
{
return inbuf.get();
}
tr_crypto crypto;
[[nodiscard]] auto hasBandwidthLeft(tr_direction dir) noexcept
{
return bandwidth->clamp(dir, 1024) > 0;
}
tr_address const addr;
[[nodiscard]] auto getPieceSpeed_Bps(uint64_t now, tr_direction dir) noexcept
{
return bandwidth->getPieceSpeedBytesPerSecond(now, dir);
}
constexpr void enableFEXT(bool flag) noexcept
{
fast_extension_supported_ = flag;
}
[[nodiscard]] constexpr auto supportsFEXT() const noexcept
{
return fast_extension_supported_;
}
constexpr void enableLTEP(bool flag) noexcept
{
extended_protocol_supported_ = flag;
}
[[nodiscard]] constexpr auto supportsLTEP() const noexcept
{
return extended_protocol_supported_;
}
constexpr void enableDHT(bool flag) noexcept
{
dht_supported_ = flag;
}
[[nodiscard]] constexpr auto supportsDHT() const noexcept
{
return dht_supported_;
}
[[nodiscard]] constexpr auto supportsUTP() const noexcept
{
return utp_supported_;
}
[[nodiscard]] constexpr auto isSeed() const noexcept
{
return is_seed_;
}
tr_crypto crypto;
// TODO(ckerr): yikes, unlike other class' magic_numbers it looks
// like this one isn't being used just for assertions, but also in
@ -139,15 +203,19 @@ public:
short int pendingEvents = 0;
tr_port const port;
tr_priority_t priority = TR_PRI_NORMAL;
bool const is_seed;
bool dhtSupported = false;
bool extendedProtocolSupported = false;
bool fastExtensionSupported = false;
bool utpSupported = false;
bool utp_supported_ = false;
private:
tr_address const addr_;
tr_port const port_;
bool const is_seed_;
bool dht_supported_ = false;
bool extended_protocol_supported_ = false;
bool fast_extension_supported_ = false;
};
/**
@ -183,46 +251,8 @@ void tr_peerIoUnrefImpl(char const* file, int line, tr_peerIo* io);
constexpr bool tr_isPeerIo(tr_peerIo const* io)
{
return io != nullptr && io->magic_number == PEER_IO_MAGIC_NUMBER && io->refCount >= 0 && tr_address_is_valid(&io->addr);
}
/**
***
**/
constexpr void tr_peerIoEnableFEXT(tr_peerIo* io, bool flag)
{
io->fastExtensionSupported = flag;
}
constexpr bool tr_peerIoSupportsFEXT(tr_peerIo const* io)
{
return io->fastExtensionSupported;
}
constexpr void tr_peerIoEnableLTEP(tr_peerIo* io, bool flag)
{
io->extendedProtocolSupported = flag;
}
constexpr bool tr_peerIoSupportsLTEP(tr_peerIo const* io)
{
return io->extendedProtocolSupported;
}
constexpr void tr_peerIoEnableDHT(tr_peerIo* io, bool flag)
{
io->dhtSupported = flag;
}
constexpr bool tr_peerIoSupportsDHT(tr_peerIo const* io)
{
return io->dhtSupported;
}
constexpr bool tr_peerIoSupportsUTP(tr_peerIo const* io)
{
return io->utpSupported;
return io != nullptr && io->magic_number == PEER_IO_MAGIC_NUMBER && io->refCount >= 0 &&
tr_address_is_valid(&io->address());
}
/**
@ -237,21 +267,12 @@ constexpr tr_session* tr_peerIoGetSession(tr_peerIo* io)
return io->session;
}
char const* tr_peerIoGetAddrStr(tr_peerIo const* io, char* buf, size_t buflen);
struct tr_address const* tr_peerIoGetAddress(tr_peerIo const* io, tr_port* port);
std::optional<tr_sha1_digest_t> tr_peerIoGetTorrentHash(tr_peerIo const* io);
void tr_peerIoSetTorrentHash(tr_peerIo* io, tr_sha1_digest_t const& info_hash);
int tr_peerIoReconnect(tr_peerIo* io);
constexpr bool tr_peerIoIsIncoming(tr_peerIo const* io)
{
return io->crypto.is_incoming;
}
/**
***
**/
@ -334,16 +355,6 @@ static inline void tr_peerIoSetParent(tr_peerIo* io, Bandwidth* parent)
void tr_peerIoBandwidthUsed(tr_peerIo* io, tr_direction direction, size_t byteCount, int isPieceData);
static inline bool tr_peerIoHasBandwidthLeft(tr_peerIo const* io, tr_direction dir)
{
return io->bandwidth->clamp(dir, 1024) > 0;
}
static inline unsigned int tr_peerIoGetPieceSpeed_Bps(tr_peerIo const* io, uint64_t now, tr_direction dir)
{
return io->bandwidth->getPieceSpeedBytesPerSecond(now, dir);
}
/**
***
**/

45
libtransmission/peer-mgr.cc
View File

@ -349,10 +349,10 @@ static tr_swarm* getExistingSwarm(tr_peerMgr* manager, tr_sha1_digest_t const& h
return tor == nullptr ? nullptr : tor->swarm;
}
static struct peer_atom* getExistingAtom(tr_swarm const* cswarm, tr_address const* addr)
static struct peer_atom* getExistingAtom(tr_swarm const* cswarm, tr_address const& addr)
{
auto* swarm = const_cast<tr_swarm*>(cswarm);
return static_cast<struct peer_atom*>(tr_ptrArrayFindSorted(&swarm->pool, addr, comparePeerAtomToAddress));
return static_cast<struct peer_atom*>(tr_ptrArrayFindSorted(&swarm->pool, &addr, comparePeerAtomToAddress));
}
static bool peerIsInUse(tr_swarm const* cs, struct peer_atom const* atom)
@ -488,33 +488,27 @@ static void atomSetSeed(tr_swarm* s, struct peer_atom* atom)
s->pool_is_all_seeds_dirty = true;
}
bool tr_peerMgrPeerIsSeed(tr_torrent const* tor, tr_address const* addr)
bool tr_peerMgrPeerIsSeed(tr_torrent const* tor, tr_address const& addr)
{
bool isSeed = false;
if (auto const* atom = getExistingAtom(tor->swarm, addr); atom != nullptr)
{
isSeed = atomIsSeed(atom);
return atomIsSeed(atom);
}
return isSeed;
return false;
}
void tr_peerMgrSetUtpSupported(tr_torrent* tor, tr_address const* addr)
void tr_peerMgrSetUtpSupported(tr_torrent* tor, tr_address const& addr)
{
struct peer_atom* atom = getExistingAtom(tor->swarm, addr);
if (atom != nullptr)
if (auto* const atom = getExistingAtom(tor->swarm, addr); atom != nullptr)
{
atom->flags |= ADDED_F_UTP_FLAGS;
}
}
void tr_peerMgrSetUtpFailed(tr_torrent* tor, tr_address const* addr, bool failed)
void tr_peerMgrSetUtpFailed(tr_torrent* tor, tr_address const& addr, bool failed)
{
struct peer_atom* atom = getExistingAtom(tor->swarm, addr);
if (atom != nullptr)
if (auto* const atom = getExistingAtom(tor->swarm, addr); atom != nullptr)
{
atom->utp_failed = failed;
}
@ -929,12 +923,12 @@ static int getDefaultShelfLife(uint8_t from)
static struct peer_atom* ensureAtomExists(
tr_swarm* s,
tr_address const* addr,
tr_address const& addr,
tr_port const port,
uint8_t const flags,
uint8_t const from)
{
TR_ASSERT(tr_address_is_valid(addr));
TR_ASSERT(tr_address_is_valid(&addr));
TR_ASSERT(from < TR_PEER_FROM__MAX);
struct peer_atom* a = getExistingAtom(s, addr);
@ -943,7 +937,7 @@ static struct peer_atom* ensureAtomExists(
{
int const jitter = tr_rand_int_weak(60 * 10);
a = tr_new0(struct peer_atom, 1);
a->addr = *addr;
a->addr = addr;
a->port = port;
a->flags = flags;
a->fromFirst = from;
@ -1012,16 +1006,15 @@ static bool on_handshake_done(tr_handshake_result const& result)
auto const hash = tr_peerIoGetTorrentHash(result.io);
tr_swarm* const s = hash ? getExistingSwarm(manager, *hash) : nullptr;
auto port = tr_port{};
auto const* const addr = tr_peerIoGetAddress(result.io, &port);
auto const [addr, port] = result.io->socketAddress();
if (tr_peerIoIsIncoming(result.io))
if (result.io->isIncoming())
{
manager->incoming_handshakes.erase(*addr);
manager->incoming_handshakes.erase(addr);
}
else if (s != nullptr)
{
s->outgoing_handshakes.erase(*addr);
s->outgoing_handshakes.erase(addr);
}
auto const lock = manager->unique_lock();
@ -1057,7 +1050,7 @@ static bool on_handshake_done(tr_handshake_result const& result)
atom->piece_data_time = 0;
atom->lastConnectionAt = tr_time();
if (!tr_peerIoIsIncoming(result.io))
if (!result.io->isIncoming())
{
atom->flags |= ADDED_F_CONNECTABLE;
atom->flags2 &= ~MyflagUnreachable;
@ -1074,7 +1067,7 @@ static bool on_handshake_done(tr_handshake_result const& result)
{
tr_logAddTraceSwarm(s, fmt::format("banned peer {} tried to reconnect", tr_atomAddrStr(atom)));
}
else if (tr_peerIoIsIncoming(result.io) && s->peerCount() >= getMaxPeerCount(s->tor))
else if (result.io->isIncoming() && s->peerCount() >= getMaxPeerCount(s->tor))
{
/* too many peers already */
}
@ -1164,7 +1157,7 @@ size_t tr_peerMgrAddPex(tr_torrent* tor, uint8_t from, tr_pex const* pex, size_t
!tr_sessionIsAddressBlocked(s->manager->session, &pex->addr) &&
tr_address_is_valid_for_peers(&pex->addr, pex->port))
{
ensureAtomExists(s, &pex->addr, pex->port, pex->flags, from);
ensureAtomExists(s, pex->addr, pex->port, pex->flags, from);
++n_used;
}
}

6
libtransmission/peer-mgr.h
View File

@ -85,11 +85,11 @@ tr_peerMgr* tr_peerMgrNew(tr_session* session);
void tr_peerMgrFree(tr_peerMgr* manager);
bool tr_peerMgrPeerIsSeed(tr_torrent const* tor, tr_address const* addr);
bool tr_peerMgrPeerIsSeed(tr_torrent const* tor, tr_address const& addr);
void tr_peerMgrSetUtpSupported(tr_torrent* tor, tr_address const* addr);
void tr_peerMgrSetUtpSupported(tr_torrent* tor, tr_address const& addr);
void tr_peerMgrSetUtpFailed(tr_torrent* tor, tr_address const* addr, bool failed);
void tr_peerMgrSetUtpFailed(tr_torrent* tor, tr_address const& addr, bool failed);
std::vector<tr_block_span_t> tr_peerMgrGetNextRequests(tr_torrent* torrent, tr_peer const* peer, size_t numwant);

50
libtransmission/peer-msgs.cc
View File

@ -253,26 +253,23 @@ public:
tr_timerAdd(*pex_timer, PexIntervalSecs, 0);
}
if (tr_peerIoSupportsUTP(io))
if (io->supportsUTP())
{
tr_address const* addr = tr_peerIoGetAddress(io, nullptr);
tr_peerMgrSetUtpSupported(torrent, addr);
tr_peerMgrSetUtpFailed(torrent, addr, false);
tr_peerMgrSetUtpSupported(torrent, io->address());
tr_peerMgrSetUtpFailed(torrent, io->address(), false);
}
if (tr_peerIoSupportsLTEP(io))
if (io->supportsLTEP())
{
sendLtepHandshake(this);
}
tellPeerWhatWeHave(this);
if (tr_dhtEnabled(torrent->session) && tr_peerIoSupportsDHT(io))
if (tr_dhtEnabled(torrent->session) && io->supportsDHT())
{
/* Only send PORT over IPv6 when the IPv6 DHT is running (BEP-32). */
struct tr_address const* addr = tr_peerIoGetAddress(io, nullptr);
if (addr->type == TR_AF_INET || tr_globalIPv6(nullptr) != nullptr)
if (io->address().type == TR_AF_INET || tr_globalIPv6(nullptr) != nullptr)
{
protocolSendPort(this, tr_dhtPort(torrent->session));
}
@ -305,7 +302,7 @@ public:
bool is_transferring_pieces(uint64_t now, tr_direction direction, unsigned int* setme_Bps) const override
{
auto const Bps = tr_peerIoGetPieceSpeed_Bps(io, now, direction);
auto const Bps = io->getPieceSpeed_Bps(now, direction);
if (setme_Bps != nullptr)
{
@ -352,7 +349,7 @@ public:
[[nodiscard]] bool is_incoming_connection() const override
{
return tr_peerIoIsIncoming(io);
return io->isIncoming();
}
[[nodiscard]] bool is_active(tr_direction direction) const override
@ -714,7 +711,7 @@ static void dbgOutMessageLen(tr_peerMsgsImpl* msgs)
static void protocolSendReject(tr_peerMsgsImpl* msgs, struct peer_request const* req)
{
TR_ASSERT(tr_peerIoSupportsFEXT(msgs->io));
TR_ASSERT(msgs->io->supportsFEXT());
struct evbuffer* out = msgs->outMessages;
@ -785,7 +782,7 @@ static void protocolSendHave(tr_peerMsgsImpl* msgs, tr_piece_index_t index)
static void protocolSendAllowedFast(tr_peerMsgs* msgs, uint32_t pieceIndex)
{
TR_ASSERT(tr_peerIoSupportsFEXT(msgs->io));
TR_ASSERT(msgs->io->supportsFEXT());
tr_peerIo* io = msgs->io;
struct evbuffer* out = msgs->outMessages;
@ -814,7 +811,7 @@ static void protocolSendChoke(tr_peerMsgsImpl* msgs, bool choke)
static void protocolSendHaveAll(tr_peerMsgsImpl* msgs)
{
TR_ASSERT(tr_peerIoSupportsFEXT(msgs->io));
TR_ASSERT(msgs->io->supportsFEXT());
struct evbuffer* out = msgs->outMessages;
@ -828,7 +825,7 @@ static void protocolSendHaveAll(tr_peerMsgsImpl* msgs)
static void protocolSendHaveNone(tr_peerMsgsImpl* msgs)
{
TR_ASSERT(tr_peerIoSupportsFEXT(msgs->io));
TR_ASSERT(msgs->io->supportsFEXT());
struct evbuffer* out = msgs->outMessages;
@ -902,17 +899,16 @@ size_t tr_generateAllowedSet(tr_piece_index_t* setmePieces, size_t desiredSetSiz
static void updateFastSet(tr_peerMsgs*)
{
bool const fext = tr_peerIoSupportsFEXT(msgs->io);
bool const fext = msgs->io->supportsFEXT();
bool const peerIsNeedy = msgs->peer->progress < 0.10;
if (fext && peerIsNeedy && !msgs->haveFastSet)
{
struct tr_address const* addr = tr_peerIoGetAddress(msgs->io, nullptr);
tr_info const* inf = &msgs->torrent->info;
size_t const numwant = std::min(MAX_FAST_SET_SIZE, inf->pieceCount);
/* build the fast set */
msgs->fastsetSize = tr_generateAllowedSet(msgs->fastset, numwant, inf->pieceCount, inf->hash, addr);
msgs->fastsetSize = tr_generateAllowedSet(msgs->fastset, numwant, inf->pieceCount, inf->hash, msgs->io->address());
msgs->haveFastSet = true;
/* send it to the peer */
@ -959,7 +955,7 @@ static bool popNextMetadataRequest(tr_peerMsgsImpl* msgs, int* piece)
static void cancelAllRequestsToClient(tr_peerMsgsImpl* msgs)
{
if (auto const must_send_rej = tr_peerIoSupportsFEXT(msgs->io); must_send_rej)
if (auto const must_send_rej = msgs->io->supportsFEXT(); must_send_rej)
{
for (auto& req : msgs->peer_requested_)
{
@ -1156,7 +1152,7 @@ static void parseLtepHandshake(tr_peerMsgsImpl* msgs, uint32_t len, struct evbuf
{
/* Mysterious µTorrent extension that we don't grok. However,
it implies support for µTP, so use it to indicate that. */
tr_peerMgrSetUtpFailed(msgs->torrent, tr_peerIoGetAddress(msgs->io, nullptr), false);
tr_peerMgrSetUtpFailed(msgs->torrent, msgs->io->address(), false);
}
}
@ -1182,14 +1178,14 @@ static void parseLtepHandshake(tr_peerMsgsImpl* msgs, uint32_t len, struct evbuf
uint8_t const* addr = nullptr;
auto addr_len = size_t{};
if (tr_peerIoIsIncoming(msgs->io) && tr_variantDictFindRaw(&val, TR_KEY_ipv4, &addr, &addr_len) && addr_len == 4)
if (msgs->io->isIncoming() && tr_variantDictFindRaw(&val, TR_KEY_ipv4, &addr, &addr_len) && addr_len == 4)
{
pex.addr.type = TR_AF_INET;
memcpy(&pex.addr.addr.addr4, addr, 4);
tr_peerMgrAddPex(msgs->torrent, TR_PEER_FROM_LTEP, &pex, 1);
}
if (tr_peerIoIsIncoming(msgs->io) && tr_variantDictFindRaw(&val, TR_KEY_ipv6, &addr, &addr_len) && addr_len == 16)
if (msgs->io->isIncoming() && tr_variantDictFindRaw(&val, TR_KEY_ipv6, &addr, &addr_len) && addr_len == 16)
{
pex.addr.type = TR_AF_INET6;
memcpy(&pex.addr.addr.addr6, addr, 16);
@ -1342,7 +1338,7 @@ static void parseLtep(tr_peerMsgsImpl* msgs, uint32_t msglen, struct evbuffer* i
logtrace(msgs, "got ltep handshake");
parseLtepHandshake(msgs, msglen, inbuf);
if (tr_peerIoSupportsLTEP(msgs->io))
if (msgs->io->supportsLTEP())
{
sendLtepHandshake(msgs);
sendPex(msgs);
@ -1486,7 +1482,7 @@ static void peerMadeRequest(tr_peerMsgsImpl* msgs, struct peer_request const* re
msgs->peer_requested_.emplace_back(*req);
prefetchPieces(msgs);
}
else if (tr_peerIoSupportsFEXT(msgs->io))
else if (msgs->io->supportsFEXT())
{
protocolSendReject(msgs, req);
}
@ -1615,7 +1611,7 @@ static ReadState readBtMessage(tr_peerMsgsImpl* msgs, struct evbuffer* inbuf, si
#ifdef TR_ENABLE_ASSERTS
size_t const startBufLen = evbuffer_get_length(inbuf);
#endif
bool const fext = tr_peerIoSupportsFEXT(msgs->io);
bool const fext = msgs->io->supportsFEXT();
auto ui32 = uint32_t{};
auto msglen = uint32_t{ msgs->incoming.length };
@ -2103,7 +2099,7 @@ static size_t fillOutputBuffer(tr_peerMsgsImpl* msgs, time_t now)
size_t bytesWritten = 0;
struct peer_request req;
bool const haveMessages = evbuffer_get_length(msgs->outMessages) != 0;
bool const fext = tr_peerIoSupportsFEXT(msgs->io);
bool const fext = msgs->io->supportsFEXT();
/**
*** Protocol messages
@ -2341,7 +2337,7 @@ static void sendBitfield(tr_peerMsgsImpl* msgs)
static void tellPeerWhatWeHave(tr_peerMsgsImpl* msgs)
{
bool const fext = tr_peerIoSupportsFEXT(msgs->io);
bool const fext = msgs->io->supportsFEXT();
if (fext && msgs->torrent->hasAll())
{