@lakutata/netif 0.0.0-stage → 3.1.5

package/native/linux/Sockets.cpp

@@ -0,0 +1,89 @@
+//The sockets of Linux bound to an interface (SO_BINDTODEVICE, by its name: SO_BINDTOIFINDEX needs Linux 5.0) and their
+//multicast groups. Linux receives the packets of an address through any interface: there is no strong host model to
+//rely on, the binding is what refuses the other interfaces.
+#include "../Sockets.h"
+
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <system_error>
+
+namespace netif {
+
+namespace {
+
+[[noreturn]] void fail(int fd, const char *call)
+{
+    int error = errno;
+    if (fd >= 0) close(fd);
+    throw std::system_error(error, std::generic_category(), call);
+}
+
+}
+
+BoundSocket bindToInterface(const std::string &name, int family, bool stream, uint16_t port, int backlog)
+{
+    int domain = family == 6 ? AF_INET6 : AF_INET;
+    int fd = socket(domain, (stream ? SOCK_STREAM : SOCK_DGRAM) | SOCK_CLOEXEC, 0);
+    if (fd < 0) fail(-1, "socket");
+    int on = 1;
+    //As Node.js does for its TCP servers: a port in TIME_WAIT can be listened on again
+    if (stream && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) != 0) fail(fd, "setsockopt(SO_REUSEADDR)");
+    if (family == 6 && setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof on) != 0) fail(fd, "setsockopt(IPV6_V6ONLY)");
+    if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, name.c_str(), static_cast<socklen_t>(name.size())) != 0) fail(fd, "setsockopt(SO_BINDTODEVICE)");
+    sockaddr_storage address{};
+    socklen_t length;
+    if (family == 6) {
+        auto *in6 = reinterpret_cast<sockaddr_in6 *>(&address);
+        in6->sin6_family = AF_INET6;
+        in6->sin6_addr = in6addr_any;
+        in6->sin6_port = htons(port);
+        length = sizeof(sockaddr_in6);
+    } else {
+        auto *in4 = reinterpret_cast<sockaddr_in *>(&address);
+        in4->sin_family = AF_INET;
+        in4->sin_addr.s_addr = htonl(INADDR_ANY);
+        in4->sin_port = htons(port);
+        length = sizeof(sockaddr_in);
+    }
+    if (bind(fd, reinterpret_cast<sockaddr *>(&address), length) != 0) fail(fd, "bind");
+    if (stream && listen(fd, backlog) != 0) fail(fd, "listen");
+    length = sizeof address;
+    if (getsockname(fd, reinterpret_cast<sockaddr *>(&address), &length) != 0) fail(fd, "getsockname");
+    BoundSocket bound;
+    bound.fd = fd;
+    bound.port = ntohs(family == 6 ? reinterpret_cast<sockaddr_in6 *>(&address)->sin6_port : reinterpret_cast<sockaddr_in *>(&address)->sin_port);
+    return bound;
+}
+
+void membership(int fd, const std::string &group, uint32_t index, bool join)
+{
+    group_req request{};
+    request.gr_interface = index;
+    int level;
+    if (inet_pton(AF_INET, group.c_str(), &reinterpret_cast<sockaddr_in *>(&request.gr_group)->sin_addr) == 1) {
+        reinterpret_cast<sockaddr_in *>(&request.gr_group)->sin_family = AF_INET;
+        level = IPPROTO_IP;
+    } else if (inet_pton(AF_INET6, group.c_str(), &reinterpret_cast<sockaddr_in6 *>(&request.gr_group)->sin6_addr) == 1) {
+        reinterpret_cast<sockaddr_in6 *>(&request.gr_group)->sin6_family = AF_INET6;
+        level = IPPROTO_IPV6;
+    } else {
+        throw std::system_error(EINVAL, std::generic_category(), "inet_pton");
+    }
+    if (setsockopt(fd, level, join ? MCAST_JOIN_GROUP : MCAST_LEAVE_GROUP, &request, sizeof request) != 0) {
+        throw std::system_error(errno, std::generic_category(), join ? "setsockopt(MCAST_JOIN_GROUP)" : "setsockopt(MCAST_LEAVE_GROUP)");
+    }
+}
+
+//Linux has no strong host model: the binding decides
+std::optional<WeakReception> weakReception(uint32_t, int)
+{
+    return WeakReception{std::string(), std::string("the weak host model of Linux")};
+}
+
+}

package/native/linux/Watcher.cpp

@@ -0,0 +1,70 @@
+//The notifications of Linux: a netlink socket joined to the groups of the links and of the IPv4 and IPv6 addresses,
+//read by a thread of the addon, which a pipe wakes to stop. An overrun of the socket (ENOBUFS) is a change too.
+#include "../Watcher.h"
+#include "RouteNetlink.h"
+
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <system_error>
+#include <thread>
+#include <vector>
+
+namespace netif {
+
+struct Watcher::State {
+    Netlink socket{RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR};
+    int wake[2] = {-1, -1};
+    std::thread thread;
+};
+
+Watcher::Watcher(std::function<void()> changed) : state(std::make_unique<State>())
+{
+    if (pipe2(state->wake, O_CLOEXEC | O_NONBLOCK) != 0) throw std::system_error(errno, std::generic_category(), "pipe2");
+    State *watched = state.get();
+    state->thread = std::thread([watched, changed]() {
+        std::vector<char> buffer(65536);
+        pollfd descriptors[2] = {{watched->socket.fd(), POLLIN, 0}, {watched->wake[0], POLLIN, 0}};
+        for (;;) {
+            if (poll(descriptors, 2, -1) < 0) {
+                if (errno == EINTR) continue;
+                return;
+            }
+            if (descriptors[1].revents) return;
+            if (!descriptors[0].revents) continue;
+            bool any = false;
+            for (;;) {
+                ssize_t received = recv(watched->socket.fd(), buffer.data(), buffer.size(), MSG_DONTWAIT);
+                if (received < 0) {
+                    if (errno == EINTR) continue;
+                    if (errno == ENOBUFS) any = true;
+                    break;
+                }
+                int remaining = static_cast<int>(received);
+                for (auto *header = reinterpret_cast<nlmsghdr *>(buffer.data()); NLMSG_OK(header, remaining); header = NLMSG_NEXT(header, remaining)) {
+                    uint16_t type = header->nlmsg_type;
+                    if (type == RTM_NEWLINK || type == RTM_DELLINK || type == RTM_NEWADDR || type == RTM_DELADDR) any = true;
+                }
+            }
+            if (any) changed();
+        }
+    });
+}
+
+Watcher::~Watcher()
+{
+    if (state->wake[1] >= 0) {
+        char byte = 1;
+        while (write(state->wake[1], &byte, 1) < 0 && errno == EINTR) {
+        }
+    }
+    if (state->thread.joinable()) state->thread.join();
+    for (int descriptor : state->wake) {
+        if (descriptor >= 0) close(descriptor);
+    }
+}
+
+}

package/native/windows/Interfaces.cpp

@@ -0,0 +1,78 @@
+//The interfaces of Windows, read by GetAdaptersAddresses(): the name of an interface is the name of its network
+//connection (以太网, Ethernet 2…, in the language of the system). A disabled adapter is not listed: listed is enabled. The
+//duplicate address detection of an address is its DadState.
+#include "../Interfaces.h"
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+
+#include <system_error>
+#include <utility>
+#include <vector>
+
+namespace netif {
+
+namespace {
+
+std::string utf8(const wchar_t *text)
+{
+    if (!text || !*text) return std::string();
+    int length = WideCharToMultiByte(CP_UTF8, 0, text, -1, nullptr, 0, nullptr, nullptr);
+    if (length <= 1) return std::string();
+    std::string converted(static_cast<size_t>(length - 1), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, text, -1, converted.data(), length, nullptr, nullptr);
+    return converted;
+}
+
+}
+
+std::vector<Interface> listInterfaces()
+{
+    const ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
+    std::vector<unsigned char> buffer(16384);
+    ULONG size = static_cast<ULONG>(buffer.size());
+    ULONG result = ERROR_BUFFER_OVERFLOW;
+    //The size asked can grow between two calls (an adapter added meanwhile)
+    for (int attempt = 0; attempt < 4 && result == ERROR_BUFFER_OVERFLOW; attempt++) {
+        buffer.resize(size);
+        result = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, reinterpret_cast<IP_ADAPTER_ADDRESSES *>(buffer.data()), &size);
+    }
+    std::vector<Interface> interfaces;
+    if (result == ERROR_NO_DATA) return interfaces;
+    if (result != NO_ERROR) throw std::system_error(static_cast<int>(result), std::system_category(), "GetAdaptersAddresses");
+    for (auto *adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES *>(buffer.data()); adapter; adapter = adapter->Next) {
+        Interface entry;
+        entry.name = utf8(adapter->FriendlyName);
+        entry.index = adapter->IfIndex ? adapter->IfIndex : adapter->Ipv6IfIndex;
+        entry.mac = macText(adapter->PhysicalAddress, adapter->PhysicalAddressLength);
+        entry.up = true;
+        entry.running = adapter->OperStatus == IfOperStatusUp;
+        entry.loopback = adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK;
+        for (auto *unicast = adapter->FirstUnicastAddress; unicast; unicast = unicast->Next) {
+            const sockaddr *socketAddress = unicast->Address.lpSockaddr;
+            if (!socketAddress) continue;
+            Address address;
+            if (socketAddress->sa_family == AF_INET) {
+                address.family = 4;
+                address.address = addressText(AF_INET, &reinterpret_cast<const sockaddr_in *>(socketAddress)->sin_addr);
+            } else if (socketAddress->sa_family == AF_INET6) {
+                auto *in6 = reinterpret_cast<const sockaddr_in6 *>(socketAddress);
+                address.family = 6;
+                address.address = addressText(AF_INET6, &in6->sin6_addr);
+                //The scope the system gives (as os.networkInterfaces() does): the interface of a link-local address, the
+                //site of a site-local one (fec0::/10)
+                address.scopeId = in6->sin6_scope_id;
+            } else {
+                continue;
+            }
+            address.prefixLength = unicast->OnLinkPrefixLength;
+            address.tentative = unicast->DadState != IpDadStatePreferred && unicast->DadState != IpDadStateDeprecated;
+            entry.addresses.push_back(std::move(address));
+        }
+        interfaces.push_back(std::move(entry));
+    }
+    return interfaces;
+}
+
+}

package/native/windows/Sockets.cpp

@@ -0,0 +1,56 @@
+//Windows: no socket of an interface (IP_UNICAST_IF only chooses the interface the packets leave by); the strong host
+//model of the system refuses the packets of an address that come through another interface. Whether a packet is taken
+//depends on the settings of the interface it came through: every other interface of the family has to receive with the
+//strong host model and not forward (whether forwarding suspends the model is not documented: counted as weak).
+#include "../Sockets.h"
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+
+#include <system_error>
+
+namespace netif {
+
+namespace {
+
+std::string aliasOf(const NET_LUID &luid)
+{
+    wchar_t alias[NDIS_IF_MAX_STRING_SIZE + 1] = {0};
+    if (ConvertInterfaceLuidToAlias(&luid, alias, NDIS_IF_MAX_STRING_SIZE + 1) != NO_ERROR) return std::string();
+    int length = WideCharToMultiByte(CP_UTF8, 0, alias, -1, nullptr, 0, nullptr, nullptr);
+    if (length <= 1) return std::string();
+    std::string converted(static_cast<size_t>(length - 1), '\0');
+    WideCharToMultiByte(CP_UTF8, 0, alias, -1, converted.data(), length, nullptr, nullptr);
+    return converted;
+}
+
+}
+
+BoundSocket bindToInterface(const std::string &, int, bool, uint16_t, int)
+{
+    throw std::system_error(ERROR_NOT_SUPPORTED, std::system_category(), "bind to an interface");
+}
+
+void membership(int, const std::string &, uint32_t, bool)
+{
+    throw std::system_error(ERROR_NOT_SUPPORTED, std::system_category(), "membership");
+}
+
+std::optional<WeakReception> weakReception(uint32_t index, int family)
+{
+    PMIB_IPINTERFACE_TABLE table = nullptr;
+    DWORD result = GetIpInterfaceTable(family == 6 ? AF_INET6 : AF_INET, &table);
+    if (result != NO_ERROR) throw std::system_error(static_cast<int>(result), std::system_category(), "GetIpInterfaceTable");
+    std::optional<WeakReception> found;
+    for (ULONG position = 0; position < table->NumEntries && !found; position++) {
+        const MIB_IPINTERFACE_ROW &row = table->Table[position];
+        if (row.InterfaceIndex == index) continue;
+        if (row.WeakHostReceive) found = WeakReception{aliasOf(row.InterfaceLuid), "WeakHostReceive"};
+        else if (row.ForwardingEnabled) found = WeakReception{aliasOf(row.InterfaceLuid), "Forwarding"};
+    }
+    FreeMibTable(table);
+    return found;
+}
+
+}

package/native/windows/Watcher.cpp

@@ -0,0 +1,53 @@
+//The notifications of Windows: the changes of the IP interfaces (their arrival, removal and settings: the link state,
+//the weak host model, the forwarding) and of the unicast addresses, whose callbacks run in threads of the system.
+//CancelMibChangeNotify2 waits for the callbacks running: called by the destructor only, never from a callback.
+#include "../Watcher.h"
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+
+#include <system_error>
+
+namespace netif {
+
+struct Watcher::State {
+    std::function<void()> changed;
+    HANDLE interfaces = nullptr;
+    HANDLE addresses = nullptr;
+};
+
+namespace {
+
+VOID NETIOAPI_API_ onInterface(PVOID context, PMIB_IPINTERFACE_ROW, MIB_NOTIFICATION_TYPE)
+{
+    (*static_cast<std::function<void()> *>(context))();
+}
+
+VOID NETIOAPI_API_ onAddress(PVOID context, PMIB_UNICASTIPADDRESS_ROW, MIB_NOTIFICATION_TYPE)
+{
+    (*static_cast<std::function<void()> *>(context))();
+}
+
+}
+
+Watcher::Watcher(std::function<void()> changed) : state(std::make_unique<State>())
+{
+    state->changed = std::move(changed);
+    DWORD result = NotifyIpInterfaceChange(AF_UNSPEC, onInterface, &state->changed, FALSE, &state->interfaces);
+    if (result != NO_ERROR) throw std::system_error(static_cast<int>(result), std::system_category(), "NotifyIpInterfaceChange");
+    result = NotifyUnicastIpAddressChange(AF_UNSPEC, onAddress, &state->changed, FALSE, &state->addresses);
+    if (result != NO_ERROR) {
+        CancelMibChangeNotify2(state->interfaces);
+        state->interfaces = nullptr;
+        throw std::system_error(static_cast<int>(result), std::system_category(), "NotifyUnicastIpAddressChange");
+    }
+}
+
+Watcher::~Watcher()
+{
+    if (state->addresses) CancelMibChangeNotify2(state->addresses);
+    if (state->interfaces) CancelMibChangeNotify2(state->interfaces);
+}
+
+}

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@lakutata/netif",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.1.5",
+  "description": "Listen on a network interface instead of an address: servers of Node.js (http, https, Express, Fastify) and UDP sockets follow an interface whatever its addresses, through their changes and the unplugging of the interface; the interfaces of the machine with their state, and events when they change. A native addon for Linux, macOS and Windows.",
+  "keywords": [
+    "lakutata",
+    "network-interface",
+    "netif",
+    "bind-to-device",
+    "so_bindtodevice",
+    "listen",
+    "interface",
+    "nic",
+    "ip-address",
+    "ipv6",
+    "udp",
+    "multicast",
+    "native",
+    "typescript"
+  ],
+  "homepage": "https://lakutata.com/packages/netif",
+  "bugs": {
+    "url": "https://github.com/lakutata/lakutata/issues",
+    "email": "admin@lakutata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lakutata/lakutata.git",
+    "directory": "packages/netif"
+  },
+  "author": "alex.ma",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/cjs/exports/Netif.js",
+  "types": "./dist/cjs/exports/Netif.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/exports/Netif.d.ts",
+        "default": "./dist/esm/exports/Netif.js"
+      },
+      "require": {
+        "types": "./dist/cjs/exports/Netif.d.ts",
+        "default": "./dist/cjs/exports/Netif.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "gypfile": true,
+  "scripts": {
+    "install": "node-gyp rebuild -j max",
+    "build:native": "node-gyp rebuild -j max",
+    "clean": "node -e \"require('node:fs').rmSync('dist', {recursive: true, force: true})\"",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs-pkg": "node ../../scripts/package-build/cjs-package.mjs",
+    "build:addon": "node scripts/addon.mjs",
+    "build:js": "npm run build:cjs && npm run build:esm && npm run build:cjs-pkg && npm run build:addon",
+    "rebuild": "npm run clean && npm run build:js",
+    "compile": "npm run rebuild",
+    "test:unit": "npm run compile && node --test --test-timeout=60000 \"dist/esm/tests/**/*.spec.js\"",
+    "test:bun": "sh test-env/bun.sh",
+    "test:electron": "electron test-env/electron/main.mjs"
+  },
+  "engines": {
+    "node": ">=18.10.0"
+  },
+  "files": [
+    "dist",
+    "!dist/*/tests",
+    "binding.gyp",
+    "native",
+    "*.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.9.2"
+  },
+  "peerDependencies": {
+    "@lakutata/core": "~3.1.5"
+  }
+}