librats 1.0.2 → 2.2.0

package/native-src/src/{network_utils.cpp → librats/util/network_utils.cpp}

@@ -31,8 +31,8 @@
 
 
 
-#include "network_utils.h"
-#include "logger.h"
+#include "librats/util/network_utils.h"
+#include "librats/util/logger.h"
 #include <cstring>
 #include <iostream>
 #include <vector>
@@ -278,7 +278,18 @@ std::string resolve_hostname_v6(const std::string& hostname) {
         LOG_NETUTILS_DEBUG("Already an IPv6 address: " << hostname);
         return hostname;
     }
-    
+
+    // An IPv4 literal has no genuine IPv6 form, so report "no v6" and let the
+    // caller dial it over IPv4. Without this, macOS/BSD getaddrinfo() synthesises
+    // an IPv4-mapped "::ffff:a.b.c.d" for a numeric IPv4 host even without
+    // AI_V4MAPPED (Linux/Windows return an error here). That made us dial IPv4
+    // endpoints over an AF_INET6 socket, so getpeername()/remote_ip() reported
+    // "::ffff:127.0.0.1" instead of "127.0.0.1"
+    if (is_valid_ipv4(hostname)) {
+        LOG_NETUTILS_DEBUG("IPv4 literal has no IPv6 form: " << hostname);
+        return "";
+    }
+
     struct addrinfo hints, *result;
     memset(&hints, 0, sizeof(hints));
     hints.ai_family = AF_INET6;
@@ -396,13 +407,11 @@ bool is_hostname(const std::string& str) {
     return true;
 }
 
-bool is_public_ip(const std::string& ip) {
-    if (ip.empty()) return false;
+bool is_public_ip(const IpAddress& ip) {
+    const ByteView bytes = ip.bytes();
 
-    if (is_valid_ipv6(ip)) {
-        struct in6_addr a;
-        if (inet_pton(AF_INET6, ip.c_str(), &a) != 1) return false;
-        const uint8_t* b = a.s6_addr;
+    if (ip.is_v6()) {
+        const uint8_t* b = bytes.data();
         bool all_zero = true;
         for (int i = 0; i < 16; ++i) { if (b[i]) { all_zero = false; break; } }
         if (all_zero) return false;                              // ::  (unspecified)
@@ -415,20 +424,26 @@ bool is_public_ip(const std::string& ip) {
         return true;
     }
 
-    struct in_addr a;
-    if (inet_pton(AF_INET, ip.c_str(), &a) != 1) return false;
-    uint32_t h = ntohl(a.s_addr);
-    uint8_t o1 = static_cast<uint8_t>((h >> 24) & 0xff);
-    uint8_t o2 = static_cast<uint8_t>((h >> 16) & 0xff);
-    if (o1 == 0) return false;                                   // 0.0.0.0/8
-    if (o1 == 127) return false;                                 // loopback
-    if (o1 == 10) return false;                                  // 10.0.0.0/8
-    if (o1 == 172 && o2 >= 16 && o2 <= 31) return false;         // 172.16.0.0/12
-    if (o1 == 192 && o2 == 168) return false;                    // 192.168.0.0/16
-    if (o1 == 169 && o2 == 254) return false;                    // 169.254.0.0/16 link-local
-    if (o1 == 100 && o2 >= 64 && o2 <= 127) return false;        // 100.64.0.0/10 CGNAT
-    if (o1 >= 224) return false;                                 // multicast / reserved
-    return true;
+    if (ip.is_v4()) {
+        const uint8_t* b = bytes.data();
+        const uint8_t o1 = b[0], o2 = b[1];
+        if (o1 == 0) return false;                                   // 0.0.0.0/8
+        if (o1 == 127) return false;                                 // loopback
+        if (o1 == 10) return false;                                  // 10.0.0.0/8
+        if (o1 == 172 && o2 >= 16 && o2 <= 31) return false;         // 172.16.0.0/12
+        if (o1 == 192 && o2 == 168) return false;                    // 192.168.0.0/16
+        if (o1 == 169 && o2 == 254) return false;                    // 169.254.0.0/16 link-local
+        if (o1 == 100 && o2 >= 64 && o2 <= 127) return false;        // 100.64.0.0/10 CGNAT
+        if (o1 >= 224) return false;                                 // multicast / reserved
+        return true;
+    }
+
+    return false;  // unspecified
+}
+
+bool is_public_ip(const std::string& ip) {
+    const auto a = IpAddress::parse(ip);
+    return a && is_public_ip(*a);
 }
 
 std::vector<std::string> get_local_interface_addresses() {

package/native-src/src/{network_utils.h → librats/util/network_utils.h}

@@ -1,5 +1,8 @@
 #pragma once
 
+#include "librats/util/rats_export.h"
+#include "librats/core/ip_address.h"
+
 #include <string>
 #include <vector>
 
@@ -11,35 +14,35 @@ namespace network_utils {
  * @param hostname The hostname to resolve (can be hostname or IP address)
  * @return IP address string, or empty string on error
  */
-std::string resolve_hostname(const std::string& hostname);
+RATS_API std::string resolve_hostname(const std::string& hostname);
 
 /**
  * Resolve hostname to IPv6 address
  * @param hostname The hostname to resolve (can be hostname or IPv6 address)
  * @return IPv6 address string, or empty string on error
  */
-std::string resolve_hostname_v6(const std::string& hostname);
+RATS_API std::string resolve_hostname_v6(const std::string& hostname);
 
 /**
  * Check if a string is a valid IPv4 address
  * @param ip_str The string to validate
  * @return true if valid IPv4 address, false otherwise
  */
-bool is_valid_ipv4(const std::string& ip_str);
+RATS_API bool is_valid_ipv4(const std::string& ip_str);
 
 /**
  * Check if a string is a valid IPv6 address
  * @param ip_str The string to validate
  * @return true if valid IPv6 address, false otherwise
  */
-bool is_valid_ipv6(const std::string& ip_str);
+RATS_API bool is_valid_ipv6(const std::string& ip_str);
 
 /**
  * Check if a string is a hostname (not an IP address)
  * @param str The string to check
  * @return true if it's a hostname, false if it's an IP address
  */
-bool is_hostname(const std::string& str);
+RATS_API bool is_hostname(const std::string& str);
 
 /**
  * Check whether an IP address is publicly routable (not a private/reserved range).
@@ -52,13 +55,17 @@ bool is_hostname(const std::string& str);
  * forwarding to detect a double-NAT gateway whose reported "external" IP is itself
  * private and therefore not a usable public endpoint.
  */
-bool is_public_ip(const std::string& ip);
+RATS_API bool is_public_ip(const std::string& ip);
+
+/// Byte-based overload: classifies directly from the address bytes, with no textual
+/// re-parse. The string overload above is a thin wrapper that parses then delegates.
+RATS_API bool is_public_ip(const IpAddress& ip);
 
 /**
  * Get all local network interface addresses (IPv4 and IPv6)
  * @return Vector of local IP addresses from all network interfaces
  */
-std::vector<std::string> get_local_interface_addresses();
+RATS_API std::vector<std::string> get_local_interface_addresses();
 
 /**
  * Get the default IPv4 gateway address(es) of the host.
@@ -72,7 +79,7 @@ std::vector<std::string> get_local_interface_addresses();
  *
  * @return Vector of gateway IPv4 addresses, most specific first. May be empty.
  */
-std::vector<std::string> get_default_gateways();
+RATS_API std::vector<std::string> get_default_gateways();
 
 } // namespace network_utils
 } // namespace librats

package/native-src/src/{os.cpp → librats/util/os.cpp}

@@ -1,10 +1,11 @@
-#include "os.h"
-#include "logger.h"
+#include "librats/util/os.h"
+#include "librats/util/logger.h"
 #include <iostream>
 #include <sstream>
 #include <fstream>
 #include <thread>
 #include <cstdlib>
+#include <cstring>
 
 #ifdef _WIN32
     #include <windows.h>
@@ -85,26 +86,55 @@ std::string get_hostname() {
     return "Unknown";
 }
 
+// Reads the CPU name the kernel published in the registry. Works on every
+// Windows architecture, and is the only option on ARM64 (no CPUID there).
+static std::string get_cpu_model_from_registry() {
+    HKEY key;
+    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
+                      "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
+                      0, KEY_READ, &key) != ERROR_SUCCESS) {
+        return "Unknown";
+    }
+
+    char name[256] = {0};
+    DWORD size = sizeof(name) - 1;
+    DWORD type = 0;
+    LONG result = RegQueryValueExA(key, "ProcessorNameString", nullptr, &type,
+                                   reinterpret_cast<LPBYTE>(name), &size);
+    RegCloseKey(key);
+
+    if (result != ERROR_SUCCESS || type != REG_SZ) {
+        return "Unknown";
+    }
+
+    std::string model(name);
+    // Trim whitespace
+    size_t first = model.find_first_not_of(" \t");
+    if (first == std::string::npos) {
+        return "Unknown";
+    }
+    model = model.substr(first, model.find_last_not_of(" \t") - first + 1);
+    return model;
+}
+
 std::string get_cpu_model() {
+#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__x86_64__)
     int CPUInfo[4] = {-1};
-    unsigned nExIds, i = 0;
-    char CPUBrandString[0x40];
-    
+    char CPUBrandString[0x40] = {0};
+
     __cpuid(CPUInfo, 0x80000000);
-    nExIds = CPUInfo[0];
-    
-    for (i = 0x80000000; i <= nExIds; ++i) {
-        __cpuid(CPUInfo, i);
-        
-        if (i == 0x80000002)
-            memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));
-        else if (i == 0x80000003)
-            memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));
-        else if (i == 0x80000004)
-            memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));
+    unsigned nExIds = static_cast<unsigned>(CPUInfo[0]);
+
+    if (nExIds >= 0x80000004) {
+        for (unsigned i = 0x80000002; i <= 0x80000004; ++i) {
+            __cpuid(CPUInfo, static_cast<int>(i));
+            memcpy(CPUBrandString + (i - 0x80000002) * sizeof(CPUInfo), CPUInfo, sizeof(CPUInfo));
+        }
+        return std::string(CPUBrandString);
     }
-    
-    return std::string(CPUBrandString);
+#endif
+    // ARM/ARM64 (and x86 CPUs without the brand string leaf)
+    return get_cpu_model_from_registry();
 }
 
 int get_cpu_cores() {

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

@@ -0,0 +1,69 @@
+#pragma once
+
+// How this copy of librats was built: RATS_SEARCH_FEATURES, RATS_STORAGE and — for
+// the shared build — RATS_IMPORT_DLL, generated by CMake. Included here because
+// nearly every public header pulls in rats_export.h, so the macros are set before
+// anything tests them (RATS_API below included). See features.h.in for why the
+// compile definitions in CMakeLists.txt are not sufficient on their own.
+#include "librats/util/features.h"
+
+/**
+ * @file rats_export.h
+ * @brief Symbol visibility for the shared build.
+ *
+ * RATS_API marks the supported public surface — the types and functions that
+ * cross the library boundary. It is what makes `RATS_SHARED_LIBRARY=ON` usable:
+ * on MSVC a symbol without __declspec(dllexport) simply is not in the DLL, so an
+ * unmarked class links fine in a static build and fails to link in a shared one.
+ *
+ * Three states, selected by the build:
+ *   - RATS_EXPORT_DLL — set PRIVATE while compiling the shared library itself.
+ *     Tested first, so it wins over the RATS_IMPORT_DLL that features.h also
+ *     defines in a shared build.
+ *   - RATS_IMPORT_DLL — consumers of the shared library get __declspec(dllimport).
+ *     It arrives from the generated features.h (and, redundantly, as an INTERFACE
+ *     define on the exported target), so it reaches a consumer whether or not it
+ *     goes through the CMake target — Conan's CMakeDeps and vcpkg's MSBuild
+ *     integration both bypass ratsConfig.cmake.
+ *   - neither — the static build, where RATS_API expands to nothing.
+ *
+ * Marking a class exports every member, including private ones and the vtable;
+ * that is deliberate, because inline members in these headers reach privates.
+ * A class whose members are all defined inline in the header needs no marking —
+ * the consumer's compiler emits them. The abstract interfaces (Subsystem,
+ * PeerNetwork, ConnectionDelegate, …) are marked anyway: MSVC warns C4275 when an
+ * exported class derives from a non-exported base.
+ *
+ */
+
+#ifdef _WIN32
+  #if defined(RATS_EXPORT_DLL)
+    #define RATS_API __declspec(dllexport)
+  #elif defined(RATS_IMPORT_DLL)
+    #define RATS_API __declspec(dllimport)
+  #else
+    #define RATS_API
+  #endif
+
+  #if defined(_MSC_VER) && (defined(RATS_EXPORT_DLL) || defined(RATS_IMPORT_DLL))
+    // C4251: an exported class has a std:: data member that is not itself
+    // exported (Node alone has vector/mutex/thread/unique_ptr/atomic members).
+    // C4275: an exported class derives from a non-exported base.
+    //
+    // Both warn about the same thing: the layout of those members must match on
+    // both sides of the DLL. That is already a hard requirement here — the public
+    // API passes std::string/std::vector/std::function by value, so a consumer
+    // must build with the same toolset, the same runtime (/MD) and the same
+    // _ITERATOR_DEBUG_LEVEL regardless. Conan and vcpkg enforce it via the
+    // profile/triplet. Silenced for the whole translation unit rather than
+    // per-class so consumers including these headers stay warning-clean.
+    #pragma warning(disable: 4251)
+    #pragma warning(disable: 4275)
+  #endif
+#else
+  #if __GNUC__ >= 4
+    #define RATS_API __attribute__((visibility("default")))
+  #else
+    #define RATS_API
+  #endif
+#endif

package/native-src/src/{version.cpp → librats/util/version.cpp}

@@ -1,7 +1,7 @@
-#include "version.h"
+#include "librats/util/version.h"
 #include <iostream>
 #include <iomanip>
-#include "rats_export.h"
+#include "librats/util/rats_export.h"
 
 namespace librats {
     namespace version {

package/native-src/src/{version.h.in → librats/util/version.h.in}

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "rats_export.h"
+#include "librats/util/rats_export.h"
 
 // This file is auto-generated by CMake. Do not edit manually.
 #define LIBRATS_VERSION_MAJOR @VERSION_MAJOR@

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

@@ -0,0 +1,76 @@
+#include "librats/wire/frame.h"
+#include "librats/core/socket.h"  // htonl/htons/ntohl/ntohs (winsock or arpa/inet)
+
+#include <cstring>
+
+namespace librats {
+namespace framer {
+
+// ── Outer block ─────────────────────────────────────────────────────────────
+
+void encode_block_header(uint8_t* out, size_t body_size) {
+    const uint32_t net_len = htonl(static_cast<uint32_t>(body_size));
+    std::memcpy(out, &net_len, kLengthPrefixSize);
+}
+
+void encode_block(Bytes& out, ByteView body) {
+    const size_t at = out.size();
+    out.resize(at + kLengthPrefixSize + body.size());
+
+    uint8_t* p = out.data() + at;
+    encode_block_header(p, body.size());
+    if (!body.empty()) std::memcpy(p + kLengthPrefixSize, body.data(), body.size());
+}
+
+Block try_take_block(const uint8_t* data, size_t size) {
+    Block out;
+    if (size < kLengthPrefixSize) { out.status = Block::Incomplete; return out; }
+
+    uint32_t net_len = 0;
+    std::memcpy(&net_len, data, 4);
+    const uint32_t len = ntohl(net_len);
+
+    if (len > kMaxBlockSize) { out.status = Block::Error; return out; }
+
+    const size_t total = kLengthPrefixSize + len;
+    out.needed = total;  // the prefix is in: we now know the whole block's size
+    if (size < total) { out.status = Block::Incomplete; return out; }
+
+    out.status   = Block::Ok;
+    out.consumed = total;
+    out.body     = ByteView(data + kLengthPrefixSize, len);
+    return out;
+}
+
+// ── Inner message ───────────────────────────────────────────────────────────
+
+void encode_message(Bytes& out, FrameHeader header, ByteView payload) {
+    const size_t at = out.size();
+    out.resize(at + kHeaderSize + payload.size());
+
+    uint8_t* p = out.data() + at;
+    *p++ = static_cast<uint8_t>(header.type);
+    *p++ = header.flags;
+    const uint16_t net_ch = htons(header.channel);
+    std::memcpy(p, &net_ch, 2);
+    p += 2;
+    if (!payload.empty()) std::memcpy(p, payload.data(), payload.size());
+}
+
+Message parse_message(ByteView inner) {
+    Message out;
+    if (inner.size() < kHeaderSize) return out;  // ok stays false
+
+    const uint8_t* p = inner.data();
+    out.frame.header.type  = static_cast<MessageType>(p[0]);
+    out.frame.header.flags = p[1];
+    uint16_t net_ch = 0;
+    std::memcpy(&net_ch, p + 2, 2);
+    out.frame.header.channel = ntohs(net_ch);
+    out.frame.payload = ByteView(p + kHeaderSize, inner.size() - kHeaderSize);
+    out.ok = true;
+    return out;
+}
+
+} // namespace framer
+} // namespace librats

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

@@ -0,0 +1,111 @@
+#pragma once
+
+/**
+ * @file frame.h
+ * @brief Two-level wire framing: outer length-prefixed blocks, inner messages.
+ *
+ * The wire is a stream of length-prefixed **blocks**:
+ *
+ *   ┌──────────────┬───────────────────────────┐
+ *   │ length (u32) │            body            │
+ *   │   4 bytes    │       length bytes         │
+ *   └──────────────┴───────────────────────────┘
+ *
+ * A block's body is opaque at this layer. The Connection uses it for two things:
+ *
+ *   - during the handshake, the body is a raw handshake message (Noise / id);
+ *   - once established, the body is the Session-encrypted bytes of an inner
+ *     **message**, which has its own fixed 4-byte header:
+ *
+ *       ┌──────┬───────┬─────────┬───────────────┐
+ *       │ type │ flags │ channel │   payload …   │
+ *       │  u8  │  u8   │   u16   │               │
+ *       └──────┴───────┴─────────┴───────────────┘
+ *
+ * Splitting "outer block" from "inner message" keeps encryption clean: the
+ * cipher wraps the whole inner message (type included), and the block layer
+ * never needs to understand it. Decoding is zero-copy — views point into the
+ * caller's buffer and are valid only until it is consumed.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/bytes.h"
+
+#include <cstdint>
+
+namespace librats {
+
+/// Inner-message kind. Application traffic uses App, addressed by `channel`.
+enum class MessageType : uint8_t {
+    App       = 1,
+    Control   = 2,  ///< core control plane (peer exchange…)
+    Gossip    = 3,
+    FileChunk = 4,
+    Ping      = 5,  ///< liveness / RTT (PingService)
+    Storage   = 6,  ///< distributed key-value store (StorageManager)
+    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.
+struct FrameHeader {
+    MessageType type    = MessageType::App;
+    uint8_t     flags   = 0;
+    uint16_t    channel = 0;  ///< interned application channel id (0 for non-App)
+};
+
+/// A decoded inner message. `payload` is a non-owning view into the source bytes.
+struct Frame {
+    FrameHeader header;
+    ByteView    payload;
+};
+
+namespace framer {
+
+constexpr size_t   kLengthPrefixSize = 4;
+constexpr size_t   kHeaderSize       = 4;                  ///< type+flags+channel
+constexpr uint32_t kMaxBlockSize     = 64u * 1024 * 1024;  ///< body cap
+
+// ── Outer block (length-prefixed opaque body) ───────────────────────────────
+
+/// Append `[u32 len][body]` to `out`.
+RATS_API void encode_block(Bytes& out, ByteView body);
+
+/// Write just the `[u32 len]` prefix into `out` (exactly kLengthPrefixSize bytes).
+/// The send path uses this to queue the prefix as its own gather slice, so the body
+/// — an encrypted frame, possibly megabytes — never has to be copied to be framed.
+RATS_API void encode_block_header(uint8_t* out, size_t body_size);
+
+struct RATS_API Block {
+    enum Status { Ok, Incomplete, Error } status = Incomplete;
+    size_t   consumed = 0;  ///< bytes to consume from the buffer (when Ok)
+    ByteView body{};        ///< the block body (when Ok); views the input
+
+    /// Total size of this block on the wire (prefix + body), known as soon as the
+    /// prefix has been read; 0 while the prefix itself is still incomplete. On an
+    /// Incomplete block this is what the receive path needs before it can parse,
+    /// so it can size the buffer for the whole block in one allocation instead of
+    /// climbing to it 1.5x at a time.
+    size_t   needed = 0;
+};
+
+/// Try to take one block from the front of `[data, data+size)` without copying.
+RATS_API Block try_take_block(const uint8_t* data, size_t size);
+
+// ── Inner message (fixed header + payload, no length prefix) ─────────────────
+
+/// Append `[type][flags][channel][payload]` to `out` (no length prefix).
+RATS_API void encode_message(Bytes& out, FrameHeader header, ByteView payload);
+
+struct Message {
+    bool  ok = false;
+    Frame frame{};
+};
+
+/// Parse an inner message from `inner` (header + payload). `ok` false if short.
+RATS_API Message parse_message(ByteView inner);
+
+} // namespace framer
+} // namespace librats

package/native-src/src/librats/wire/message_router.cpp

@@ -0,0 +1,45 @@
+#include "librats/wire/message_router.h"
+#include "librats/util/logger.h"
+
+namespace librats {
+
+uint16_t MessageRouter::channel_id(std::string_view name) {
+    // FNV-1a (32-bit) folded to 16 bits — deterministic across nodes/runs.
+    uint32_t hash = 2166136261u;
+    for (char c : name) {
+        hash ^= static_cast<uint8_t>(c);
+        hash *= 16777619u;
+    }
+    const uint16_t id = static_cast<uint16_t>((hash >> 16) ^ (hash & 0xFFFF));
+    return id == 0 ? 1 : id;  // reserve 0 for "no channel"
+}
+
+void MessageRouter::on_channel(std::string_view name, Handler handler) {
+    const uint16_t id = channel_id(name);
+    auto existing = channel_names_.find(id);
+    if (existing != channel_names_.end() && existing->second != name) {
+        LOG_WARN("router", "Channel id collision: '" << name << "' and '"
+                 << existing->second << "' both hash to " << id);
+    }
+    channel_names_[id] = std::string(name);
+    by_channel_[id] = std::move(handler);
+}
+
+void MessageRouter::on_type(MessageType type, Handler handler) {
+    by_type_[static_cast<uint8_t>(type)] = std::move(handler);
+}
+
+bool MessageRouter::dispatch(const Peer& peer, const Frame& frame) const {
+    if (frame.header.type == MessageType::App) {
+        auto it = by_channel_.find(frame.header.channel);
+        if (it == by_channel_.end()) return false;
+        it->second(peer, frame.payload);
+        return true;
+    }
+    const auto& handler = by_type_[static_cast<uint8_t>(frame.header.type)];
+    if (!handler) return false;
+    handler(peer, frame.payload);
+    return true;
+}
+
+} // namespace librats

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

@@ -0,0 +1,47 @@
+#pragma once
+
+/**
+ * @file message_router.h
+ * @brief Routes decoded inner frames to handlers.
+ *
+ * App frames are dispatched by their `channel`; everything else by MessageType.
+ * Application channels are named; the name is hashed to a stable 16-bit id with
+ * a deterministic function so the SAME name maps to the SAME id on every node
+ * (no shared registry needed). Distinct names can in principle collide in the
+ * 16-bit space — on_channel() logs if a new name collides with a registered one.
+ */
+
+#include "librats/util/rats_export.h"
+#include "librats/core/bytes.h"
+#include "librats/wire/frame.h"
+#include "librats/peer/peer.h"
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace librats {
+
+class RATS_API MessageRouter {
+public:
+    using Handler = std::function<void(const Peer&, ByteView)>;
+
+    /// Deterministic 16-bit channel id (FNV-1a) for a channel name.
+    static uint16_t channel_id(std::string_view name);
+
+    void on_channel(std::string_view name, Handler handler);
+    void on_type(MessageType type, Handler handler);
+
+    /// Dispatch one decoded frame to its handler, if any. Returns true if handled.
+    bool dispatch(const Peer& peer, const Frame& frame) const;
+
+private:
+    std::unordered_map<uint16_t, Handler>     by_channel_;
+    std::unordered_map<uint16_t, std::string> channel_names_;  // for collision checks
+    std::array<Handler, 256>                  by_type_{};
+};
+
+} // namespace librats

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librats",
-  "version": "1.0.2",
+  "version": "2.2.0",
   "description": "Node.js bindings for librats - A high-performance peer-to-peer networking library",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -24,11 +24,12 @@
     "networking",
     "dht",
     "gossipsub",
+    "pubsub",
     "file-transfer",
     "mdns",
-    "stun",
-    "ice",
-    "nat-traversal",
+    "nat-pmp",
+    "upnp",
+    "noise",
     "encryption",
     "native"
   ],

package/scripts/build-librats.js

@@ -133,6 +133,7 @@ try {
     
     let cmakeArgs = [
         '-DRATS_BUILD_TESTS=OFF',
+        '-DRATS_BUILD_CLIENT=OFF',
         '-DRATS_BUILD_EXAMPLES=OFF',
         '-DRATS_STATIC_LIBRARY=ON',
         '-DRATS_BINDINGS=ON',