librats 2.1.4 → 2.3.0

package/native-src/src/librats/transport/relay_link.cpp

@@ -0,0 +1,208 @@
+#include "librats/transport/relay_link.h"
+
+#include "librats/core/io_poller.h"   // PollIn / PollOut / PollErr
+#include "librats/util/logger.h"
+
+#include <algorithm>
+#include <cstring>
+#include <utility>
+
+namespace librats {
+
+namespace {
+
+/// Slices one data message gathers from the caller's list. The send buffer hands
+/// out a length prefix and a body per queued frame, so this covers a run of frames
+/// rather than a single one; a longer backlog than this simply comes back on the
+/// next turn of Connection::flush.
+constexpr size_t kMaxParts = 16;
+
+} // namespace
+
+Circuit::Circuit(uint32_t id, std::shared_ptr<CircuitCarrier> carrier, bool open,
+                 uint32_t recv_window, uint32_t peer_window)
+    : id_(id),
+      carrier_(std::move(carrier)),
+      state_(open ? State::Open : State::Pending),
+      recv_window_(recv_window == 0 ? kDefaultWindow : recv_window),
+      send_credit_(open ? peer_window : 0) {}
+
+std::shared_ptr<Circuit> Circuit::opening(uint32_t id, std::shared_ptr<CircuitCarrier> carrier,
+                                          uint32_t recv_window) {
+    return std::shared_ptr<Circuit>(
+        new Circuit(id, std::move(carrier), /*open=*/false, recv_window, /*peer_window=*/0));
+}
+
+std::shared_ptr<Circuit> Circuit::accepted(uint32_t id, std::shared_ptr<CircuitCarrier> carrier,
+                                           uint32_t peer_window, uint32_t recv_window) {
+    return std::shared_ptr<Circuit>(
+        new Circuit(id, std::move(carrier), /*open=*/true, recv_window, peer_window));
+}
+
+// ── Fed by the relay module ─────────────────────────────────────────────────
+
+uint32_t Circuit::on_data(ByteView bytes) {
+    if (state_ == State::Closed || bytes.empty()) return 0;
+
+    // The window is the ONE thing bounding what this circuit can cost us and the
+    // relay carrying it, so a peer that sends past what it was granted is not
+    // merely impolite — it is doing the thing the window exists to prevent. Fail
+    // the circuit rather than accept the bytes.
+    if (bytes.size() > recv_window_ - recv_in_flight_) {
+        LOG_WARN("relay", "Circuit " << id_ << " overran its receive window ("
+                 << bytes.size() << " B with " << (recv_window_ - recv_in_flight_)
+                 << " B granted); failing it");
+        return on_closed(CloseReason::ProtocolError, /*orderly=*/false);
+    }
+    recv_in_flight_ += static_cast<uint32_t>(bytes.size());
+
+    // Hand back the consumed prefix before growing: the connection normally drains
+    // the inbox to empty on every readable event, so this is nearly always a reset
+    // of an already-empty buffer rather than a move.
+    if (inbox_read_ == inbox_.size()) {
+        inbox_.clear();
+        inbox_read_ = 0;
+    } else if (inbox_read_ >= kCompactThreshold) {
+        inbox_.erase(inbox_.begin(), inbox_.begin() + static_cast<std::ptrdiff_t>(inbox_read_));
+        inbox_read_ = 0;
+    }
+
+    inbox_.insert(inbox_.end(), bytes.begin(), bytes.end());
+    return PollIn;
+}
+
+uint32_t Circuit::on_accept(uint32_t peer_window) {
+    if (state_ != State::Pending) return 0;
+    state_       = State::Open;
+    send_credit_ = peer_window;
+    // Unconditional, unlike the other openings below: the Connection is still in
+    // Connecting and has nothing queued, so want_write_ is false — yet this is
+    // precisely the event it is waiting for to finish connecting and start its
+    // handshake (see Connection::on_writable).
+    return PollOut;
+}
+
+uint32_t Circuit::on_credit(uint32_t bytes) {
+    if (state_ == State::Closed || bytes == 0) return 0;
+    // Saturate rather than wrap: a far end that grants nonsense should cost us
+    // nothing worse than an over-generous window, and the receiver's own window
+    // check is what actually bounds the traffic.
+    if (bytes > UINT32_MAX - send_credit_) send_credit_ = UINT32_MAX;
+    else                                   send_credit_ += bytes;
+
+    if (!credit_blocked_) return 0;
+    credit_blocked_ = false;
+    return writable_event();
+}
+
+uint32_t Circuit::on_closed(CloseReason reason, bool orderly) {
+    if (state_ == State::Closed) return 0;
+    state_   = State::Closed;
+    reason_  = reason;
+    orderly_ = orderly;
+    // An orderly close still owes the application whatever the far end sent before
+    // it: read() drains the inbox first and only then reports the end of stream, so
+    // what this needs is a readable event, not an error. That is the same contract
+    // the other links keep (see Link::read).
+    return orderly ? PollIn : PollErr;
+}
+
+uint32_t Circuit::on_carrier_writable() {
+    if (!carrier_blocked_) return 0;
+    carrier_blocked_ = false;
+    return writable_event();
+}
+
+uint32_t Circuit::writable_event() const noexcept {
+    if (blocked() || !want_write_ || state_ != State::Open) return 0;
+    return PollOut;
+}
+
+// ── Driven by the Connection ────────────────────────────────────────────────
+
+Link::IoResult Circuit::read(ByteSpan into) {
+    const size_t available = inbox_.size() - inbox_read_;
+    const size_t n = (std::min)(available, into.size());
+    if (n > 0) {
+        std::memcpy(into.data(), inbox_.data() + inbox_read_, n);
+        inbox_read_ += n;
+        if (inbox_read_ == inbox_.size()) {
+            inbox_.clear();
+            inbox_read_ = 0;
+        }
+
+        // These bytes are out of the pipe, so the far end may put that much back
+        // in. Granted in batches: one small message per half-window rather than one
+        // per chunk, which is what keeps the credit scheme's overhead invisible.
+        recv_in_flight_ -= static_cast<uint32_t>(n);
+        recv_ungranted_ += static_cast<uint32_t>(n);
+        if (state_ != State::Closed && recv_ungranted_ >= recv_window_ / kCreditGrantFraction) {
+            carrier_->circuit_send_credit(id_, recv_ungranted_);
+            recv_ungranted_ = 0;
+        }
+        return {n, Link::Status::Ok};
+    }
+
+    // Drained. Only now may the end of the stream be reported — data and
+    // end-of-stream are never delivered together.
+    if (state_ == State::Closed)
+        return {0, orderly_ ? Link::Status::Closed : Link::Status::Error};
+    return {0, Link::Status::WouldBlock};
+}
+
+Link::IoResult Circuit::write(const ByteView* slices, size_t count) {
+    if (state_ == State::Closed) return {0, Link::Status::Error};
+    // Pending: opened but not yet accepted. Nothing may go out — and nothing tries
+    // to, since the Connection is still Connecting.
+    if (state_ != State::Open) return {0, Link::Status::WouldBlock};
+    if (blocked())             return {0, Link::Status::WouldBlock};
+
+    const size_t budget = (std::min)(static_cast<size_t>(send_credit_), kMaxDataChunk);
+    if (budget == 0) {
+        credit_blocked_ = true;
+        return {0, Link::Status::WouldBlock};
+    }
+
+    // One data message per call, gathered across as many of the caller's slices as
+    // fit. Connection::flush loops while a link keeps reporting Ok, so a backlog
+    // larger than one chunk simply comes back around — no loop is needed here, and
+    // each turn of that loop re-checks the credit and the carrier.
+    ByteView parts[kMaxParts];
+    size_t   nparts = 0;
+    size_t   taken  = 0;
+    for (size_t i = 0; i < count && taken < budget && nparts < kMaxParts; ++i) {
+        if (slices[i].empty()) continue;
+        const size_t take = (std::min)(slices[i].size(), budget - taken);
+        parts[nparts++] = ByteView(slices[i].data(), take);
+        taken += take;
+    }
+    if (taken == 0) return {0, Link::Status::WouldBlock};
+
+    send_credit_ -= static_cast<uint32_t>(taken);
+    // The carrier queues what it is given either way; false is "stop and wait", so
+    // the bytes are ours to report as written and the block applies to the NEXT
+    // call (see CircuitCarrier::circuit_send_data).
+    if (!carrier_->circuit_send_data(id_, parts, nparts)) carrier_blocked_ = true;
+    return {taken, Link::Status::Ok};
+}
+
+void Circuit::shutdown(CloseReason reason) {
+    if (!close_sent_) {
+        close_sent_ = true;
+        carrier_->circuit_send_close(id_, reason);
+    }
+    if (state_ != State::Closed) {
+        state_   = State::Closed;
+        reason_  = reason;
+        orderly_ = false;
+    }
+}
+
+void Circuit::release() {
+    if (released_) return;
+    released_ = true;
+    state_    = State::Closed;
+    carrier_->circuit_released(id_);
+}
+
+} // namespace librats

package/native-src/src/librats/transport/relay_link.h

@@ -0,0 +1,303 @@
+#pragma once
+
+/**
+ * @file relay_link.h
+ * @brief A peer connection carried inside another peer's connection.
+ *
+ * When two nodes cannot reach each other directly — a symmetric NAT on one side,
+ * a network that swallows UDP, a hole punch that simply did not land — the one
+ * thing left is to route their bytes through a node they can both reach. The
+ * question is *where* in the stack to do that, and this file is the answer: at the
+ * very bottom, as one more way of obtaining the ordered, reliable byte stream a
+ * Connection runs on (see link.h).
+ *
+ * That choice is what makes a relayed peer indistinguishable from a direct one
+ * everywhere above:
+ *
+ *   - the Noise_XX handshake runs END TO END between the two peers, so the relay
+ *     carries ciphertext it cannot read, cannot forge and cannot replay into
+ *     anything. It is a pipe, not a party;
+ *   - the self-certifying PeerId and the protocol_id bound into the handshake are
+ *     checked exactly as usual, so a relay cannot impersonate either end;
+ *   - block framing, the send queue and its high-water mark, the establish
+ *     deadline, identify, and the peer table's duplicate resolution all apply
+ *     unchanged, because there is nothing here for them to know about;
+ *   - every subsystem — pub/sub, file transfer, PEX — works over a relayed peer
+ *     without a line of its own.
+ *
+ * Relaying at the message level instead (a third node forwarding application
+ * frames) would have meant a second handshake, a second authentication scheme and
+ * a second backpressure story — and would have handed the relay the plaintext.
+ *
+ * ── The two halves ──────────────────────────────────────────────────────────
+ * `Circuit` is the state of one relayed connection: the bytes in flight in each
+ * direction and the credit windows that bound them. `RelayLink` is the paper-thin
+ * adapter that presents that state to a Connection as a Link. They are separate
+ * because the Connection owns its Link outright (unique_ptr, destroyed on the
+ * reactor thread) while the module driving the relay protocol has to keep hold of
+ * the same circuit to feed it — so the state is shared and only the adapter is
+ * owned.
+ *
+ * `CircuitCarrier` is the other direction: what the circuit needs from whoever
+ * speaks the relay protocol. It is deliberately tiny and knows nothing about the
+ * wire format, which stays entirely in the module that implements it.
+ *
+ * ── Flow control, and why it is not optional ────────────────────────────────
+ * A relay reads from one peer and writes to another, and it cannot stop reading:
+ * the reactor drains a readable connection to the end. So without a bound, a slow
+ * receiver makes the relay's send queue to it grow until that peer is dropped as a
+ * slow consumer — losing all of its traffic, not just the circuit's, and letting
+ * any pair of peers spend a stranger's memory at will.
+ *
+ * The bound is an end-to-end credit window, granted by the receiver and spent by
+ * the sender, exactly as in a stream multiplexer. Each end advertises how much it
+ * is willing to have in flight; the sender may not exceed it, and the receiver
+ * grants more as it consumes. Two things follow:
+ *
+ *   - the relay can never hold more than about one window per circuit, whatever
+ *     either end does, so its memory is bounded by configuration rather than by
+ *     the goodwill of its users;
+ *   - a slow path makes the circuit slow instead of making it fail. The window
+ *     only ever binds when the far end is not keeping up, which is precisely when
+ *     something ought to give.
+ *
+ * Credit is returned as the bytes are read OUT of the circuit, not as they arrive,
+ * and in batches (kCreditGrantFraction of the window) so the grant costs one small
+ * message per window-worth of data rather than one per chunk.
+ *
+ * ── Threading ───────────────────────────────────────────────────────────────
+ * A Circuit is touched only by the reactor thread that owns its Connection, which
+ * is by construction the same thread that owns the carrier's connection (see
+ * node/circuit_service.h). It therefore holds no locks and no atomics, like
+ * everything else on this path. The module that owns circuits may keep its table
+ * of them under a mutex; the state below must not be reached from off that one
+ * thread.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/bytes.h"
+#include "librats/core/types.h"
+#include "librats/transport/link.h"
+
+#include <cstdint>
+#include <memory>
+
+namespace librats {
+
+/// What a circuit needs from whoever speaks the relay protocol on the wire.
+///
+/// Implemented by the relay module; called by Circuit on the reactor thread. None
+/// of these say anything about the wire format — the implementer frames the
+/// message and hands it to the carrier peer — so this header stays a transport
+/// header with no protocol in it.
+class CircuitCarrier {
+public:
+    virtual ~CircuitCarrier() = default;
+
+    /// Send `count` slices (together no larger than kMaxDataChunk) toward the far
+    /// end as one data message.
+    /// @return whether the carrier's own send queue still has room. False does NOT
+    ///         mean the data was dropped — it was queued like any other message —
+    ///         it means stop, and say so again through on_carrier_writable() once
+    ///         the queue drains. Exactly what PeerNetwork::send answers, which is
+    ///         what an implementation normally forwards.
+    virtual bool circuit_send_data(uint32_t circuit, const ByteView* slices, size_t count) = 0;
+
+    /// Grant the far end `bytes` more of our receive window.
+    virtual void circuit_send_credit(uint32_t circuit, uint32_t bytes) = 0;
+
+    /// Tell the far end (and the relay in between) that this circuit is over.
+    /// Called at most once per circuit.
+    virtual void circuit_send_close(uint32_t circuit, CloseReason reason) = 0;
+
+    /// The Link is gone: its Connection has been destroyed. The circuit will not
+    /// be read or written again and its bookkeeping can be dropped.
+    ///
+    /// The only one of these that is NOT guaranteed to arrive on the reactor
+    /// thread. It normally does — a Connection is destroyed by its reactor — but a
+    /// link handed to a reactor that never ran the adoption (the node was stopping)
+    /// is released when the task queue is destroyed instead, on whichever thread
+    /// takes the reactor down. An implementation must therefore be safe to call
+    /// here from any thread, and must not assume the circuit ever opened.
+    virtual void circuit_released(uint32_t circuit) = 0;
+};
+
+/// One relayed connection's byte stream and credit windows. See the file comment.
+class RATS_API Circuit {
+public:
+    /// Largest data message a circuit puts on the wire. Big enough that the
+    /// per-message overhead (a relay header, a frame header, an AEAD tag, and the
+    /// relay's own copy) is noise against the payload; small enough that one
+    /// circuit cannot monopolise the carrier's send queue for long, and that the
+    /// relay's per-message work stays granular.
+    static constexpr size_t kMaxDataChunk = 16 * 1024;
+
+    /// Receive window a circuit advertises unless told otherwise. This is the
+    /// memory ONE circuit can make the relay (and this node) hold, so it is the
+    /// knob that turns "how fast can a relayed peer go" into "how much is a relay
+    /// asked to carry": a 256 KiB window keeps a 100 ms round trip busy at roughly
+    /// 20 Mbit/s, which is far more than a fallback path is meant to be used for.
+    static constexpr uint32_t kDefaultWindow = 256 * 1024;
+
+    /// Credit is granted back once this much of the window has been consumed.
+    /// Halves mean one small grant per half-window of data, and leave the sender
+    /// the other half to work with while the grant is in flight.
+    static constexpr uint32_t kCreditGrantFraction = 2;
+
+    /// A circuit we are opening: the request is out, the far end has not answered.
+    /// Nothing may be written until on_accept() brings the window it will receive.
+    ///
+    /// @param id          the circuit's id on the carrier link (see the relay module).
+    /// @param carrier     how outbound bytes leave; a shared_ptr because a Connection
+    ///                    can outlive the module that opened the circuit (subsystems
+    ///                    stop before the reactors do).
+    /// @param recv_window what we are willing to have in flight toward us.
+    static std::shared_ptr<Circuit> opening(uint32_t id, std::shared_ptr<CircuitCarrier> carrier,
+                                            uint32_t recv_window = kDefaultWindow);
+
+    /// A circuit opened TO us: the far end is already there and its request carried
+    /// the window it will accept, so the stream is open from the first instant.
+    ///
+    /// Two factories rather than one flag plus a window that is sometimes ignored,
+    /// because "the circuit is open" and "we know what the far end will take" are
+    /// the same fact — an open circuit whose send window nobody set would be a
+    /// stream that silently refuses to carry anything.
+    static std::shared_ptr<Circuit> accepted(uint32_t id, std::shared_ptr<CircuitCarrier> carrier,
+                                             uint32_t peer_window,
+                                             uint32_t recv_window = kDefaultWindow);
+
+    Circuit(const Circuit&) = delete;
+    Circuit& operator=(const Circuit&) = delete;
+
+    uint32_t id() const noexcept { return id_; }
+    /// What we advertise to the far end as our receive window.
+    uint32_t recv_window() const noexcept { return recv_window_; }
+    bool     is_open() const noexcept { return state_ == State::Open; }
+    bool     is_closed() const noexcept { return state_ == State::Closed; }
+
+    // ── Fed by the relay module (reactor thread) ────────────────────────────
+    //
+    // Each of these returns the poll-equivalent events the circuit's Connection
+    // should now be given (PollIn / PollOut / PollErr), or 0 for none. The caller
+    // dispatches them — the circuit deliberately knows nothing about reactors.
+    // Returning the mask rather than raising it keeps that dependency out of the
+    // transport layer and lets the caller batch several changes into one wake.
+
+    /// Bytes arrived from the far end. A peer that overruns the window it was
+    /// granted is a protocol error and the circuit is failed rather than allowed
+    /// to grow: that window is the whole bound on what a circuit can cost.
+    uint32_t on_data(ByteView bytes);
+
+    /// The far end accepted the circuit and advertised `peer_window` bytes of
+    /// receive window. No-op unless the circuit is still pending.
+    uint32_t on_accept(uint32_t peer_window);
+
+    /// The far end granted `bytes` more of send window.
+    uint32_t on_credit(uint32_t bytes);
+
+    /// The circuit is over. `orderly` means the far end closed cleanly, so
+    /// whatever it already sent is still delivered before the end of stream is
+    /// reported; anything else fails the connection at once.
+    uint32_t on_closed(CloseReason reason, bool orderly);
+
+    /// The carrier's send queue, which had filled up, has room again.
+    uint32_t on_carrier_writable();
+
+    // ── Driven by the Connection through RelayLink (reactor thread) ─────────
+
+    Link::IoResult read(ByteSpan into);
+    Link::IoResult write(const ByteView* slices, size_t count);
+    void           want_write(bool on) noexcept { want_write_ = on; }
+    CloseReason    close_reason() const noexcept { return reason_; }
+    /// Begin teardown from our side: tell the far end, then refuse further I/O.
+    void           shutdown(CloseReason reason);
+    /// The Link is being destroyed; release the carrier's bookkeeping. Idempotent.
+    void           release();
+
+    /// Bytes waiting to be read out (diagnostics and tests).
+    size_t         pending_input() const noexcept { return inbox_.size() - inbox_read_; }
+    /// Send window still available (diagnostics and tests).
+    uint32_t       send_credit() const noexcept { return send_credit_; }
+
+private:
+    Circuit(uint32_t id, std::shared_ptr<CircuitCarrier> carrier, bool open,
+            uint32_t recv_window, uint32_t peer_window);
+
+    enum class State : uint8_t {
+        Pending,  ///< outbound: opened, waiting for the far end to accept
+        Open,     ///< bytes may flow
+        Closed,   ///< no further I/O; read() drains what is left, then reports the end
+    };
+
+    /// Consumed prefix tolerated before the inbox is compacted. The connection
+    /// normally drains the inbox to empty on every readable event, which resets it
+    /// for free; this only bounds the pathological case where it does not.
+    static constexpr size_t kCompactThreshold = 64 * 1024;
+
+    bool blocked() const noexcept { return credit_blocked_ || carrier_blocked_; }
+    /// PollOut, but only if anyone is waiting for it — see want_write().
+    uint32_t writable_event() const noexcept;
+
+    uint32_t                         id_;
+    std::shared_ptr<CircuitCarrier>  carrier_;
+    State                            state_;
+    CloseReason                      reason_ = CloseReason::PeerReset;
+    bool                             orderly_ = false;   ///< the far end closed cleanly
+    bool                             released_ = false;
+    bool                             close_sent_ = false;
+
+    // — inbound —
+    Bytes    inbox_;
+    size_t   inbox_read_ = 0;         ///< consumed prefix of inbox_
+    uint32_t recv_window_;            ///< what we advertised to the far end
+    uint32_t recv_in_flight_ = 0;     ///< delivered to us and not yet granted back
+    uint32_t recv_ungranted_ = 0;     ///< consumed, owed back to the far end
+
+    // — outbound —
+    uint32_t send_credit_ = 0;        ///< bytes the far end still allows us to send
+    bool     want_write_ = false;     ///< the Connection has more to write
+    bool     credit_blocked_ = false; ///< a write stopped for want of credit
+    bool     carrier_blocked_ = false;///< a write stopped on the carrier's queue
+};
+
+/// The Link a Connection holds for a relayed circuit.
+///
+/// Deliberately empty of logic: the state has to be reachable by the module that
+/// drives the relay protocol, which the Connection's unique_ptr would not allow,
+/// so everything lives in the shared Circuit and this is the handle.
+class RATS_API RelayLink final : public Link {
+public:
+    explicit RelayLink(std::shared_ptr<Circuit> circuit) : circuit_(std::move(circuit)) {}
+    ~RelayLink() override { circuit_->release(); }
+
+    TransportKind kind() const noexcept override { return TransportKind::Relay; }
+
+    IoResult read(ByteSpan into) override { return circuit_->read(into); }
+    IoResult write(const ByteView* slices, size_t count) override {
+        return circuit_->write(slices, count);
+    }
+
+    /// A circuit is "connected" once the far end has accepted it. The Connection
+    /// only asks after a PollOut, which the relay module raises on acceptance; a
+    /// refusal arrives as PollErr instead and never reaches here.
+    bool connect_completed() override { return circuit_->is_open(); }
+
+    void want_write(bool on) override { circuit_->want_write(on); }
+
+    /// No endpoint of its own, and deliberately not the relay's: identify pairs the
+    /// address a link reports with the peer's advertised listen port to build a
+    /// dialable address, and NatStatus reads it as our own NAT mapping. Both would
+    /// be wrong here — the address on this path belongs to the node in the middle.
+    /// Reporting nothing is what keeps a relayed peer out of that machinery.
+    std::optional<Address> remote_endpoint() const override { return std::nullopt; }
+
+    CloseReason error_reason() const override { return circuit_->close_reason(); }
+    void        close(CloseReason reason) override { circuit_->shutdown(reason); }
+
+    Circuit& circuit() noexcept { return *circuit_; }
+
+private:
+    std::shared_ptr<Circuit> circuit_;
+};
+
+} // namespace librats

package/native-src/src/librats/util/logger.h

@@ -29,6 +29,9 @@
     #endif
 #else
     #include <unistd.h>
+    #if defined(__ANDROID__)
+        #include <android/log.h>
+    #endif
 #endif
 
 namespace librats {
@@ -149,7 +152,24 @@ public:
         if (level < min_level_.load(std::memory_order_relaxed)) {
             return;
         }
-        
+
+#if defined(__ANDROID__)
+        // An Android app's stdout/stderr are discarded by default, so the cout/cerr
+        // sink below is invisible in logcat. Route console output through the platform
+        // logger instead: logcat supplies its own timestamp, level and coloring, so the
+        // bare message goes out under the module name as the tag. The file sink is
+        // unaffected and stays identical to every other platform.
+        if (console_logging_enabled_) {
+            __android_log_print(get_android_priority(level),
+                                module.empty() ? "librats" : module.c_str(),
+                                "%s", message.c_str());
+        }
+        if (file_logging_enabled_ && log_file_.is_open()) {
+            write_to_file(level, module, message);
+        }
+        return;
+#endif
+
         // Prepare console output with colors
         std::ostringstream console_oss;
         
@@ -239,6 +259,18 @@ private:
             default: return "UNKNOWN";
         }
     }
+
+#if defined(__ANDROID__)
+    int get_android_priority(LogLevel level) {
+        switch (level) {
+            case LogLevel::DEBUG: return ANDROID_LOG_DEBUG;
+            case LogLevel::INFO:  return ANDROID_LOG_INFO;
+            case LogLevel::WARN:  return ANDROID_LOG_WARN;
+            case LogLevel::ERROR: return ANDROID_LOG_ERROR;
+            default: return ANDROID_LOG_INFO;
+        }
+    }
+#endif
     
     std::string get_color_code(LogLevel level) {
         if (!colors_enabled_ || !is_terminal_) return "";
@@ -411,10 +443,9 @@ private:
             std::string old_name = log_file_path_ + "." + std::to_string(i);
             std::string new_name = log_file_path_ + "." + std::to_string(i + 1);
             
-            // Delete the oldest file if it exists
-            if (i == max_log_files_ - 1) {
-                std::remove(new_name.c_str());
-            }
+            // std::rename() does not replace an existing destination on Windows,
+            // so clear the target first - not just the oldest file.
+            std::remove(new_name.c_str());
             
             // Rename old file to new name
             std::rename(old_name.c_str(), new_name.c_str());
@@ -422,6 +453,7 @@ private:
         
         // Move current log file to .1
         std::string backup_name = log_file_path_ + ".1";
+        std::remove(backup_name.c_str());
         std::rename(log_file_path_.c_str(), backup_name.c_str());
     }
     

package/native-src/src/librats/util/network_monitor.cpp

@@ -25,7 +25,21 @@
     #include <cerrno>
 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
       defined(__OpenBSD__) || defined(__DragonFly__)
+    #ifdef __APPLE__
+        #include <TargetConditionals.h>
+    #endif
+    // Apple ships <net/route.h> in the macOS SDK only. On iOS the PF_ROUTE
+    // socket itself is usable but the message declarations are not public, so
+    // there is nothing to parse against — those targets take the polling
+    // fallback at the bottom of this file (backend_start() returns false).
+    // A native backend for iOS belongs on Network.framework's nw_path_monitor
+    // rather than on route messages.
+    #if !defined(__APPLE__) || (defined(TARGET_OS_OSX) && TARGET_OS_OSX)
     #define RATS_MONITOR_BSD_ROUTES 1
+    #endif
+#endif
+
+#if defined(RATS_MONITOR_BSD_ROUTES)
     #include <sys/types.h>
     #include <sys/socket.h>
     #include <net/route.h>

package/native-src/src/librats/util/network_utils.cpp

@@ -17,8 +17,17 @@
         #include <ifaddrs.h>
     #endif
 
+    #ifdef __APPLE__
+        #include <TargetConditionals.h>
+    #endif
+
     // macOS / BSD default-gateway lookup via the PF_ROUTE sysctl routing table.
-    #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
+    // Apple ships <net/route.h> in the macOS SDK only: on iOS (and tvOS/watchOS)
+    // the sysctl still exists but its declarations are not public, so those
+    // targets skip this branch and rely on append_gateway_heuristics() below,
+    // which every platform falls back to anyway.
+    #if (defined(__APPLE__) && defined(TARGET_OS_OSX) && TARGET_OS_OSX) || \
+        defined(__FreeBSD__) || defined(__NetBSD__) || \
         defined(__OpenBSD__) || defined(__DragonFly__)
         #define RATS_HAVE_BSD_ROUTES 1
         #include <sys/types.h>

package/native-src/src/librats/wire/frame.h

@@ -46,6 +46,7 @@ enum class MessageType : uint8_t {
     Typed     = 7,  ///< typed JSON message exchange (MessageJson)
     Pex       = 8,  ///< peer exchange — gossip of known peer addresses (PeerExchange)
     Punch     = 9,  ///< NAT hole-punch rendezvous, relayed peer→peer (HolePunch)
+    Relay     = 10, ///< relayed circuits: a peer's connection carried through a third node (Relay)
 };
 
 /// Fixed header of an inner message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "2.1.4",
+  "version": "2.3.0",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",