librats 2.3.3 → 2.3.5

package/native-src/src/librats/bittorrent/peer_connection.h

@@ -5,18 +5,29 @@
  * @brief One peer link: the BitTorrent wire handshake, message codec and the
  *        choke/interest state machine.
  *
- * A PeerConnection owns a non-blocking TCP socket registered with a Reactor and
- * lives entirely on that reactor's thread. It turns the byte stream into
- * protocol events delivered to an Observer, and offers send_* methods to emit
- * messages. It deliberately knows nothing about pieces-to-request strategy or
- * disk — the owning Torrent (a later phase) drives those through this surface.
+ * A PeerConnection owns a non-blocking byte stream — a PeerLink, which is either
+ * a TCP socket or a uTP stream (BEP 29) — and lives entirely on the reactor's
+ * thread. It turns that stream into protocol events delivered to an Observer, and
+ * offers send_* methods to emit messages. It deliberately knows nothing about
+ * pieces-to-request strategy or disk — the owning Torrent drives those through
+ * this surface — and nothing about which transport carries it: everything below
+ * read/write is the link's business.
  *
  * Wire format: a 68-byte handshake, then length-prefixed messages
  * `[u32 length][u8 id][payload]` (length 0 = keep-alive). All integers are
  * big-endian.
+ *
+ * That stream may be wrapped in MSE/PE obfuscation (see mse.h). When it is, an
+ * MSE handshake runs first and the bytes above are then RC4'd in both directions
+ * — but only between here and the socket: everything from parse() and the send_*
+ * methods inward sees the same plaintext protocol either way. An inbound
+ * connection does not announce which it is, so the first 20 bytes are sniffed —
+ * a literal "\x13BitTorrent protocol" is plaintext, anything else is a DH key.
  */
 
 #include "librats/bittorrent/bitfield.h"
+#include "librats/bittorrent/mse.h"
+#include "librats/bittorrent/peer_link.h"
 #include "librats/bittorrent/reactor.h"
 #include "librats/bittorrent/types.h"
 #include "librats/core/bytes.h"
@@ -26,6 +37,7 @@
 #include <chrono>
 #include <cstdint>
 #include <functional>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -45,7 +57,20 @@ enum class MessageId : std::uint8_t {
     Extended      = 20,
 };
 
-class PeerConnection {
+/// How an outgoing connection opens, and what a failure to open it means for the
+/// peer's next attempt. Decided by the caller from the session policy plus what
+/// worked for this peer last time; the connection just carries it.
+struct DialOptions {
+    /// Run an MSE handshake instead of writing a plaintext one.
+    bool obfuscate = false;
+    /// There is another way to reach this peer that we have not tried yet — the
+    /// other encryption form (EncPolicy::Enabled), or TCP after a uTP dial. A peer
+    /// that refuses this attempt has very likely refused the *form*, not us, so the
+    /// alternative is worth trying at once rather than after the reconnect backoff.
+    bool retry_other_form_on_failure = false;
+};
+
+class PeerConnection : private PeerLink::Observer {
 public:
     /// Protocol events. All fire on the reactor thread; ByteView arguments are
     /// only valid for the duration of the call (copy if you need to keep them).
@@ -74,14 +99,23 @@ public:
     using Resolver = std::function<bool(const InfoHash& their_info_hash, Binding& out)>;
 
     /// Outgoing connection: we know the torrent up front.
+    /// @param link      the byte stream, TCP or uTP; owned from here on.
     /// @param num_pieces sizes the peer's bitfield; 0 if metadata isn't known yet.
-    PeerConnection(Reactor& reactor, socket_t sock, bool outgoing,
+    /// @param opts      whether to open with an MSE handshake, and whether a
+    ///                  failure to open should be retried another way.
+    PeerConnection(Reactor& reactor, std::unique_ptr<PeerLink> link, bool outgoing,
                    const InfoHash& info_hash, const PeerId& our_peer_id,
                    std::uint32_t num_pieces, Observer* observer,
-                   std::string remote_ip = "", std::uint16_t remote_port = 0);
+                   std::string remote_ip = "", std::uint16_t remote_port = 0,
+                   DialOptions opts = DialOptions{});
     /// Incoming connection: the torrent is resolved from the peer's handshake.
-    PeerConnection(Reactor& reactor, socket_t sock, const PeerId& our_peer_id,
-                   Resolver resolver, std::string remote_ip = "", std::uint16_t remote_port = 0);
+    /// @param enc_policy what we accept — plaintext, MSE, or either.
+    /// @param skey       resolves an obfuscated MSE stream key to a torrent;
+    ///                   required whenever @p enc_policy permits MSE.
+    PeerConnection(Reactor& reactor, std::unique_ptr<PeerLink> link, const PeerId& our_peer_id,
+                   Resolver resolver, std::string remote_ip = "", std::uint16_t remote_port = 0,
+                   EncPolicy enc_policy = EncPolicy::Disabled,
+                   mse::Handshake::SkeyResolver skey = {});
     ~PeerConnection();
 
     PeerConnection(const PeerConnection&) = delete;
@@ -96,6 +130,17 @@ public:
     bool            closed()          const noexcept { return closed_; }
     bool            handshake_done()  const noexcept { return handshake_sent_ && handshake_received_; }
     bool            outgoing()        const noexcept { return outgoing_; }
+    /// Which wire carries this connection. Only the reconnect policy cares — the
+    /// protocol above is identical either way.
+    PeerTransport   transport()       const noexcept { return link_->transport(); }
+    /// True once an MSE handshake has completed. Note this says the *connection*
+    /// was obfuscated, not that the payload is still encrypted — crypto_select may
+    /// have settled on plaintext after the obfuscated header.
+    bool            encrypted()       const noexcept { return encrypted_; }
+    /// Should a failure to reach the handshake on this connection skip the peer's
+    /// reconnect backoff, so the other encryption form can be tried at once?
+    /// Meaningless once handshake_done() — by then the form is known to work.
+    bool            fast_reconnect()  const noexcept { return fast_reconnect_; }
     bool            am_choking()      const noexcept { return am_choking_; }
     bool            am_interested()   const noexcept { return am_interested_; }
     bool            peer_choking()    const noexcept { return peer_choking_; }
@@ -124,20 +169,47 @@ public:
     void send_extended(std::uint8_t ext_id, ByteView payload);
 
 private:
-    void on_io(std::uint32_t events);
+    // ---- PeerLink::Observer ----
+    void on_link_readable() override;
+    void on_link_writable() override;
+    void on_link_error(const std::string& reason) override;
+
     void do_read();
     std::size_t read_size() const;  ///< bytes to offer the next recv() (see rx_need_)
     void parse();
     bool parse_handshake();
     void send_handshake();
+    /// The 68 bytes of the BitTorrent handshake, built but not queued — MSE needs
+    /// them as its initial payload rather than as something to write directly.
+    Bytes build_handshake();
     void dispatch(MessageId id, const std::uint8_t* payload, std::uint32_t len);
 
+    // ---- MSE ----
+    /// Decide from the first 20 bytes of an inbound stream whether the peer is
+    /// speaking plaintext or MSE, and start the obfuscated handshake if it is.
+    /// Returns false if it closed the connection (a policy refusal) or is still
+    /// waiting for bytes.
+    bool detect_inbound_encryption();
+    /// Write whatever the handshake produced, then act on @p status.
+    void pump_mse(mse::Handshake::Status status);
+    /// Adopt the negotiated ciphers and hand the handshake's leftovers to parse().
+    void finish_mse();
+
     void send_message(MessageId id, const std::uint8_t* payload, std::uint32_t len);
-    /// Append to the send queue. No syscall: the caller flushes once the whole
-    /// message is queued, so a message never costs more than one send().
-    void queue(ByteView bytes) { if (!closed_) tx_.append(bytes); }
-    /// Queue a buffer the caller already owns — moved in, never copied.
-    void queue(Bytes bytes) { if (!closed_) tx_.append(std::move(bytes)); }
+    /// Append to the send queue, encrypting first if the payload stream is RC4'd.
+    /// No syscall: the caller flushes once the whole message is queued, so a
+    /// message never costs more than one send().
+    ///
+    /// This is the single funnel every protocol message goes through, and that is
+    /// what makes the cipher correct: RC4 is one keystream, so bytes have to be
+    /// encrypted in exactly the order they enter the queue, exactly once each.
+    void queue(ByteView bytes);
+    /// Queue a buffer the caller already owns — moved in, and encrypted in place if
+    /// need be, so a block read from disk is never copied.
+    void queue(Bytes bytes);
+    /// Queue bytes that must bypass the payload cipher: the MSE handshake, which
+    /// carries its own encryption and establishes the cipher everything else uses.
+    void queue_raw(Bytes bytes) { if (!closed_) tx_.append(std::move(bytes)); }
     /// Push the queue to the socket with one gather-send, (dis)arm write interest,
     /// and enforce the send high-water mark. May close the connection.
     void flush();
@@ -147,7 +219,7 @@ private:
     void tick();
 
     Reactor&      reactor_;
-    socket_t      sock_;
+    std::unique_ptr<PeerLink> link_;
     bool          outgoing_;
     InfoHash      info_hash_;
     PeerId        our_peer_id_;
@@ -159,6 +231,26 @@ private:
     std::string   remote_ip_;       ///< peer's address (source for incoming, dialed for outgoing)
     std::uint16_t remote_port_ = 0;
 
+    // ---- MSE / PE ----
+    EncPolicy                       enc_policy_ = EncPolicy::Disabled;  ///< inbound only
+    mse::Handshake::SkeyResolver    skey_;                              ///< inbound only
+    /// Runs the obfuscated handshake and owns the byte stream while it does, so
+    /// nothing reaches rx_ until it has finished and been destroyed.
+    std::unique_ptr<mse::Handshake> mse_;
+    mse::Rc4Cipher                  rc4_send_;
+    mse::Rc4Cipher                  rc4_recv_;
+    bool                            rc4_active_ = false;  ///< payload stream is RC4'd
+    bool                            encrypted_  = false;  ///< an MSE handshake completed
+    bool                            want_mse_   = false;  ///< outbound: dial obfuscated
+    /// Outbound: this dial was one of an alternating pair, so failing to reach the
+    /// handshake earns the peer an immediate retry with the other form.
+    bool                            fast_reconnect_ = false;
+    bool                            detecting_  = false;  ///< inbound: still sniffing
+    InfoHash                        mse_skey_{};          ///< torrent the stream key named
+    /// Scratch for encrypting copy-appends, kept around so a steady stream of small
+    /// messages does not allocate a buffer each.
+    Bytes                           enc_scratch_;
+
     ReceiveBuffer     rx_;
     /// Wire size of the message rx_ is mid-way through (4-byte prefix included), once
     /// that prefix has been read; 0 when no message is in flight. Lets the next recv()

package/native-src/src/librats/bittorrent/peer_link.cpp

@@ -0,0 +1,134 @@
+#include "librats/bittorrent/peer_link.h"
+
+#include "librats/bittorrent/utp_manager.h"
+
+#include <cerrno>
+
+namespace librats::bittorrent {
+
+namespace {
+
+#ifdef _WIN32
+inline bool would_block() { return WSAGetLastError() == WSAEWOULDBLOCK; }
+#else
+inline bool would_block() { return errno == EAGAIN || errno == EWOULDBLOCK; }
+#endif
+
+} // namespace
+
+// ---- TcpPeerLink -------------------------------------------------------------
+
+TcpPeerLink::TcpPeerLink(Reactor& reactor, socket_t sock) : reactor_(reactor), sock_(sock) {}
+
+TcpPeerLink::~TcpPeerLink() {
+    close();
+}
+
+void TcpPeerLink::start(Observer* obs) {
+    obs_ = obs;
+    set_socket_nonblocking(sock_);
+    reactor_.add(sock_, PollIn, [this](std::uint32_t ev) { on_io(ev); });
+}
+
+void TcpPeerLink::on_io(std::uint32_t events) {
+    // The observer may close us from inside any of these, which clears obs_ — so
+    // each step re-checks rather than assuming the link is still alive.
+    if ((events & PollOut) && obs_ != nullptr) obs_->on_link_writable();
+    if ((events & PollIn) && obs_ != nullptr) obs_->on_link_readable();
+    if ((events & (PollErr | PollHup)) && obs_ != nullptr) obs_->on_link_error("socket error");
+}
+
+PeerLink::IoResult TcpPeerLink::read(ByteSpan into) {
+    if (!is_valid_socket(sock_)) return {0, Status::Error};
+    const int n = ::recv(sock_, reinterpret_cast<char*>(into.data()),
+                         static_cast<int>(into.size()), 0);
+    if (n == 0) return {0, Status::Closed};
+    if (n < 0) return {0, would_block() ? Status::WouldBlock : Status::Error};
+    return {std::size_t(n), Status::Ok};
+}
+
+PeerLink::IoResult TcpPeerLink::write(const ByteView* slices, std::size_t count) {
+    if (!is_valid_socket(sock_)) return {0, Status::Error};
+    const std::ptrdiff_t n = send_vectored(sock_, slices, count);
+    if (n > 0) return {std::size_t(n), Status::Ok};
+    // Zero accepted is not an error: the socket buffer is full right now. Treated
+    // the same as would-block, i.e. retry when the poller says we may.
+    if (n == 0) return {0, Status::WouldBlock};
+    return {0, would_block() ? Status::WouldBlock : Status::Error};
+}
+
+void TcpPeerLink::want_write(bool on) {
+    if (on == want_write_ || !is_valid_socket(sock_)) return;
+    want_write_ = on;
+    reactor_.modify(sock_, PollIn | (on ? PollOut : PollNone));
+}
+
+void TcpPeerLink::close() {
+    obs_ = nullptr;
+    if (!is_valid_socket(sock_)) return;
+    reactor_.remove(sock_);
+    close_socket(sock_);
+    sock_ = RATS_INVALID_SOCKET;
+}
+
+// ---- UtpPeerLink -------------------------------------------------------------
+
+UtpPeerLink::UtpPeerLink(utp::Manager& manager, utp::Stream& stream)
+    : manager_(manager), stream_(&stream) {}
+
+UtpPeerLink::~UtpPeerLink() {
+    close();
+}
+
+void UtpPeerLink::start(PeerLink::Observer* obs) {
+    obs_ = obs;
+    if (stream_ != nullptr) stream_->set_observer(this);
+}
+
+PeerLink::IoResult UtpPeerLink::read(ByteSpan into) {
+    if (stream_ == nullptr) return {0, Status::Error};
+    const auto r = stream_->read(into);
+    switch (r.status) {
+        case utp::Stream::Status::Ok:         return {r.bytes, Status::Ok};
+        case utp::Stream::Status::WouldBlock: return {0, Status::WouldBlock};
+        case utp::Stream::Status::Eof:        return {0, Status::Closed};
+        case utp::Stream::Status::Error:      break;
+    }
+    return {0, Status::Error};
+}
+
+PeerLink::IoResult UtpPeerLink::write(const ByteView* slices, std::size_t count) {
+    if (stream_ == nullptr) return {0, Status::Error};
+    const auto r = stream_->write(slices, count, utp::Stream::Clock::now());
+    switch (r.status) {
+        case utp::Stream::Status::Ok:         return {r.bytes, Status::Ok};
+        case utp::Stream::Status::WouldBlock: return {0, Status::WouldBlock};
+        case utp::Stream::Status::Eof:
+        case utp::Stream::Status::Error:      break;
+    }
+    return {0, Status::Error};
+}
+
+void UtpPeerLink::close() {
+    obs_ = nullptr;
+    if (stream_ == nullptr) return;
+    // Hand it back rather than delete it: the stream still owes the peer a FIN, and
+    // the manager keeps it alive just long enough to deliver one.
+    utp::Stream* s = stream_;
+    stream_        = nullptr;
+    manager_.release(*s);
+}
+
+void UtpPeerLink::on_utp_readable() {
+    if (obs_ != nullptr) obs_->on_link_readable();
+}
+
+void UtpPeerLink::on_utp_writable() {
+    if (obs_ != nullptr && want_write_) obs_->on_link_writable();
+}
+
+void UtpPeerLink::on_utp_error(const std::string& why) {
+    if (obs_ != nullptr) obs_->on_link_error(why);
+}
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/peer_link.h

@@ -0,0 +1,145 @@
+#pragma once
+
+/**
+ * @file peer_link.h
+ * @brief The byte stream a PeerConnection runs on, independent of how it is carried.
+ *
+ * Everything above this line — the BitTorrent handshake, the message codec, MSE
+ * obfuscation, the choke machine, backpressure, the idle deadlines — only ever
+ * needs an ordered, reliable, non-blocking byte stream. A PeerLink is exactly that
+ * and nothing more, so the same PeerConnection code drives a kernel TCP socket and
+ * the library's own uTP implementation. Neither is a special case of the other: a
+ * peer reached over either is indistinguishable to every layer above.
+ *
+ * This mirrors `transport/link.h` on the node side of the library, and libtorrent's
+ * `aux::socket_type` variant on the BitTorrent side, for the same reason all three
+ * exist: without it, "which transport is this?" leaks into every function that
+ * touches the wire.
+ *
+ * The read/write calls deliberately mirror non-blocking socket semantics, because
+ * that is what a reactor loop is built around:
+ *   - read()  fills the caller's span and reports WouldBlock once nothing more is
+ *             ready, or Closed when the peer has finished sending.
+ *   - write() takes what it can and reports WouldBlock when it can take no more;
+ *             the caller keeps the remainder queued and calls want_write(true) so
+ *             it is told when to retry.
+ *
+ * Ownership and threading: a link belongs to exactly one PeerConnection, lives on
+ * the BitTorrent reactor thread, and holds no locks. Events arrive through the
+ * Observer the connection installs in start().
+ */
+
+#include "librats/bittorrent/reactor.h"
+#include "librats/bittorrent/types.h"
+#include "librats/bittorrent/utp_stream.h"
+#include "librats/core/bytes.h"
+#include "librats/core/socket.h"
+
+#include <cstddef>
+#include <string>
+
+namespace librats::bittorrent {
+
+namespace utp { class Manager; }
+
+class PeerLink {
+public:
+    /// Outcome of a read/write attempt. `Closed` is orderly (the peer is done
+    /// sending); `Error` means the link is broken and must be torn down.
+    enum class Status : std::uint8_t { Ok, WouldBlock, Closed, Error };
+
+    struct IoResult {
+        std::size_t bytes  = 0;
+        Status      status = Status::WouldBlock;
+    };
+
+    /// How the link tells its connection that something happened. Every callback
+    /// runs on the reactor thread, and the connection may close the link from
+    /// inside one — so a link must not touch its own state after calling out.
+    struct Observer {
+        virtual ~Observer() = default;
+        virtual void on_link_readable() = 0;
+        virtual void on_link_writable() = 0;
+        virtual void on_link_error(const std::string& reason) = 0;
+    };
+
+    virtual ~PeerLink() = default;
+
+    virtual PeerTransport transport() const noexcept = 0;
+
+    /// Begin delivering events to @p obs.
+    virtual void start(Observer* obs) = 0;
+
+    /// Read up to `into.size()` bytes. A Closed or Error result always carries zero
+    /// bytes — data and end-of-stream are never reported together, so the caller
+    /// drains first and only then sees the close.
+    virtual IoResult read(ByteSpan into) = 0;
+
+    /// Hand `count` contiguous slices to the link in order, writing as many bytes
+    /// as it will take (a partial write is normal and expected).
+    virtual IoResult write(const ByteView* slices, std::size_t count) = 0;
+
+    /// Ask to be woken (via on_link_writable) when more can be written. Called only
+    /// when the state actually changes, so an implementation may treat it as an
+    /// unconditional set.
+    virtual void want_write(bool on) = 0;
+
+    /// Tear down. Idempotent, and safe to call from inside an Observer callback.
+    virtual void close() = 0;
+};
+
+/// A plain TCP socket, registered with the reactor. The kernel does the work.
+class TcpPeerLink final : public PeerLink {
+public:
+    TcpPeerLink(Reactor& reactor, socket_t sock);
+    ~TcpPeerLink() override;
+
+    PeerTransport transport() const noexcept override { return PeerTransport::Tcp; }
+    void          start(PeerLink::Observer* obs) override;
+    IoResult      read(ByteSpan into) override;
+    IoResult      write(const ByteView* slices, std::size_t count) override;
+    void          want_write(bool on) override;
+    void          close() override;
+
+private:
+    void on_io(std::uint32_t events);
+
+    Reactor&  reactor_;
+    socket_t  sock_;
+    Observer* obs_        = nullptr;
+    bool      want_write_ = false;
+};
+
+/**
+ * The same guarantee obtained from a uTP stream instead of a socket.
+ *
+ * The stream is owned by the utp::Manager (it may have to outlive this object to
+ * finish flushing a FIN), so the link holds a pointer and hands it back on close().
+ * Readiness is pushed rather than polled: the manager's socket is the only thing
+ * registered with the reactor, and it drives the stream, which drives us.
+ */
+class UtpPeerLink final : public PeerLink, private utp::Stream::Observer {
+public:
+    UtpPeerLink(utp::Manager& manager, utp::Stream& stream);
+    ~UtpPeerLink() override;
+
+    PeerTransport transport() const noexcept override { return PeerTransport::Utp; }
+    void          start(PeerLink::Observer* obs) override;
+    IoResult      read(ByteSpan into) override;
+    IoResult      write(const ByteView* slices, std::size_t count) override;
+    void          want_write(bool on) override { want_write_ = on; }
+    void          close() override;
+
+private:
+    // ---- utp::Stream::Observer ----
+    void on_utp_readable() override;
+    void on_utp_writable() override;
+    void on_utp_error(const std::string& why) override;
+
+    utp::Manager& manager_;
+    utp::Stream*  stream_;
+    PeerLink::Observer* obs_  = nullptr;
+    bool          want_write_ = false;
+};
+
+} // namespace librats::bittorrent

package/native-src/src/librats/bittorrent/peer_list.cpp

@@ -13,10 +13,10 @@ bool PeerList::add(const std::string& ip, std::uint16_t port, PeerSource source)
     return inserted;
 }
 
-std::vector<PeerList::Endpoint> PeerList::connect_candidates(std::size_t max) {
+std::vector<PeerList::Endpoint> PeerList::connect_candidates(std::size_t max, Clock::time_point now) {
     std::vector<Peer*> eligible_peers;
     for (auto& [k, p] : peers_)
-        if (eligible(p)) eligible_peers.push_back(&p);
+        if (ready(p, now)) eligible_peers.push_back(&p);
 
     // Fewest past failures first; ties broken by richer source provenance so a
     // tracker/DHT-vouched peer outranks one only seen via PEX.
@@ -28,25 +28,88 @@ std::vector<PeerList::Endpoint> PeerList::connect_candidates(std::size_t max) {
     std::vector<Endpoint> out;
     const std::size_t take = (std::min)(max, eligible_peers.size());
     out.reserve(take);
+    // Only `connecting` is set here — the backoff clock is started when the attempt
+    // *ends*, not when it begins (libtorrent stamps last_connected in
+    // connection_closed for the same reason). Stamping on hand-out instead would
+    // make Disconnect::Release meaningless: a released peer would still be sitting
+    // out a backoff started by the dial we ourselves just tore down. `connecting`
+    // is what keeps an in-flight dial from being handed out twice, and every dial
+    // now ends in on_connect_failed or on_disconnected — the connect deadline in
+    // Client guarantees it — so nothing can leave a peer stamp-less forever.
     for (std::size_t i = 0; i < take; ++i) {
-        eligible_peers[i]->connecting = true;
-        out.push_back(Endpoint{eligible_peers[i]->ip, eligible_peers[i]->port});
+        Peer& p = *eligible_peers[i];
+        p.connecting = true;
+        // uTP unless this peer has already shown it has none. Unlike the encryption
+        // form this is a latch, not an alternation: one failed uTP dial settles the
+        // question, and re-asking it every other attempt would spend a wasted round
+        // trip on a peer we already know the answer for.
+        out.push_back(Endpoint{p.ip, p.port, p.prefer_encrypted,
+                               p.supports_utp || p.confirmed_supports_utp});
+        // Flip now, not on failure: this attempt has claimed the current mode, so
+        // whatever happens to it the *next* one should try the other. A success
+        // pins the working mode back in set_connected().
+        p.prefer_encrypted = !p.prefer_encrypted;
     }
     return out;
 }
 
-void PeerList::set_connected(const std::string& ip, std::uint16_t port, bool connected) {
+void PeerList::set_connected(const std::string& ip, std::uint16_t port, bool encrypted,
+                             PeerTransport transport) {
     auto it = peers_.find(key(ip, port));
     if (it == peers_.end()) return;
-    it->second.connected  = connected;
-    it->second.connecting = false;
-    if (connected) it->second.fail_count = 0;  // a successful connect clears the penalty
+    Peer& p          = it->second;
+    p.connected        = true;
+    p.connecting       = false;
+    p.fail_count       = 0;  // reaching a working session clears the penalty
+    p.prefer_encrypted = encrypted;
+    if (transport == PeerTransport::Utp) {
+        // Proof rather than assumption. Clearing the optimistic flag alongside is
+        // libtorrent's bookkeeping: from here on the confirmation is what keeps us
+        // dialing uTP, so a stale guess can never contradict it.
+        p.confirmed_supports_utp = true;
+        p.supports_utp           = false;
+    }
+}
+
+void PeerList::note_utp_dial_failed(const std::string& ip, std::uint16_t port) {
+    auto it = peers_.find(key(ip, port));
+    if (it == peers_.end()) return;
+    it->second.supports_utp = false;
+}
+
+void PeerList::on_disconnected(const std::string& ip, std::uint16_t port, Disconnect how,
+                               Clock::time_point now) {
+    auto it = peers_.find(key(ip, port));
+    if (it == peers_.end()) return;
+    Peer& p = it->second;
+    p.connected  = false;
+    p.connecting = false;
+    if (how == Disconnect::Release) return;  // our own doing — leave the peer untouched
+
+    const bool failed = how == Disconnect::Failed || how == Disconnect::FailedRetryNow;
+    if (failed && p.fail_count < kMaxFails) ++p.fail_count;
+
+    // A waiver clears the clock rather than setting it, so the peer reads as never
+    // dialed and comes back on the very next pass — the whole point being to learn
+    // whether it wanted the other form of handshake, which costs one round trip and
+    // should not cost a minute. Still counted against fail_count above, and rationed
+    // by kMaxFastReconnects, so this cannot become a loop.
+    if (how == Disconnect::FailedRetryNow && p.fast_reconnects < kMaxFastReconnects) {
+        ++p.fast_reconnects;
+        p.last_attempt = Clock::time_point{};
+        return;
+    }
+
+    // Stamp the attempt even for a clean disconnect: the backoff is what keeps the
+    // dial loop from immediately re-opening a connection the peer just closed.
+    p.last_attempt = now;
 }
 
-void PeerList::on_connect_failed(const std::string& ip, std::uint16_t port) {
+void PeerList::on_connect_failed(const std::string& ip, std::uint16_t port, Clock::time_point now) {
     auto it = peers_.find(key(ip, port));
     if (it == peers_.end()) return;
-    it->second.connecting = false;
+    it->second.connecting   = false;
+    it->second.last_attempt = now;
     ++it->second.fail_count;
 }
 
@@ -55,9 +118,9 @@ void PeerList::ban(const std::string& ip, std::uint16_t port) {
     if (it != peers_.end()) it->second.banned = true;
 }
 
-std::size_t PeerList::num_candidates() const {
+std::size_t PeerList::num_candidates(Clock::time_point now) const {
     std::size_t n = 0;
-    for (const auto& [k, p] : peers_) if (eligible(p)) ++n;
+    for (const auto& [k, p] : peers_) if (ready(p, now)) ++n;
     return n;
 }