@lakutata/netif 0.0.0-stage → 3.1.4

package/native/addon.cpp

@@ -0,0 +1,195 @@
+//The addon of @lakutata/netif: what Node.js cannot do by itself, given to JavaScript by Node-API (through
+//node-addon-api). The errors of the system are thrown as errors with the code of the system (code, errno, syscall).
+#include <napi.h>
+
+#include <atomic>
+#include <memory>
+#include <system_error>
+
+#include "Interfaces.h"
+#include "Sockets.h"
+#include "Watcher.h"
+
+using namespace netif;
+
+namespace {
+
+//An error of the system as a JavaScript error: its message, the number (errno) and the call (syscall) it came from
+Napi::Error systemError(Napi::Env env, const std::system_error &error)
+{
+    Napi::Error thrown = Napi::Error::New(env, error.what());
+    thrown.Set("errno", Napi::Number::New(env, error.code().value()));
+    thrown.Set("syscall", Napi::String::New(env, error.what()));
+    return thrown;
+}
+
+Napi::Object addressObject(Napi::Env env, const Address &address)
+{
+    Napi::Object object = Napi::Object::New(env);
+    object.Set("address", address.address);
+    object.Set("family", address.family == 4 ? "IPv4" : "IPv6");
+    object.Set("prefixLength", address.prefixLength);
+    object.Set("tentative", address.tentative);
+    if (address.family == 6) object.Set("scopeid", address.scopeId);
+    return object;
+}
+
+//list(): every interface of the machine, as [{name, index, mac?, up, running, loopback, addresses}]
+Napi::Value List(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::vector<Interface> interfaces;
+    try {
+        interfaces = listInterfaces();
+    } catch (const std::system_error &error) {
+        throw systemError(env, error);
+    }
+    Napi::Array list = Napi::Array::New(env, interfaces.size());
+    for (size_t index = 0; index < interfaces.size(); index++) {
+        const Interface &entry = interfaces[index];
+        Napi::Object object = Napi::Object::New(env);
+        object.Set("name", entry.name);
+        object.Set("index", entry.index);
+        if (!entry.mac.empty()) object.Set("mac", entry.mac);
+        object.Set("up", entry.up);
+        object.Set("running", entry.running);
+        object.Set("loopback", entry.loopback);
+        Napi::Array addresses = Napi::Array::New(env, entry.addresses.size());
+        for (size_t position = 0; position < entry.addresses.size(); position++) {
+            addresses.Set(static_cast<uint32_t>(position), addressObject(env, entry.addresses[position]));
+        }
+        object.Set("addresses", addresses);
+        list.Set(static_cast<uint32_t>(index), object);
+    }
+    return list;
+}
+
+//bindSocket(name, family, stream, port, backlog): a socket bound to the interface of the name (Linux), as {fd, port}
+Napi::Value BindSocket(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    BoundSocket bound;
+    try {
+        bound = bindToInterface(info[0].As<Napi::String>().Utf8Value(), info[1].As<Napi::Number>().Int32Value(), info[2].As<Napi::Boolean>().Value(), static_cast<uint16_t>(info[3].As<Napi::Number>().Uint32Value()), info[4].As<Napi::Number>().Int32Value());
+    } catch (const std::system_error &error) {
+        throw systemError(env, error);
+    }
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("fd", bound.fd);
+    result.Set("port", bound.port);
+    return result;
+}
+
+//membership(fd, group, index, join): the socket joins or leaves the multicast group on the interface of the index (Linux)
+Napi::Value Membership(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    try {
+        membership(info[0].As<Napi::Number>().Int32Value(), info[1].As<Napi::String>().Utf8Value(), info[2].As<Napi::Number>().Uint32Value(), info[3].As<Napi::Boolean>().Value());
+    } catch (const std::system_error &error) {
+        throw systemError(env, error);
+    }
+    return env.Undefined();
+}
+
+//weakReception(index, family): null when the system refuses, through another interface, the packets for the addresses of
+//the interface of the index; otherwise {interface, setting}, the setting that makes it accept them
+Napi::Value WeakReceptionOf(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    std::optional<WeakReception> found;
+    try {
+        found = weakReception(info[0].As<Napi::Number>().Uint32Value(), info[1].As<Napi::Number>().Int32Value());
+    } catch (const std::system_error &error) {
+        throw systemError(env, error);
+    }
+    if (!found) return env.Null();
+    Napi::Object result = Napi::Object::New(env);
+    result.Set("interface", found->interfaceName);
+    result.Set("setting", found->setting);
+    return result;
+}
+
+//The watching of an environment (the main thread, or a worker): the notifications of the system, and the function they
+//call JavaScript by. A notification only signals a change: while one waits to be delivered, the next ones are dropped.
+//The function does not keep the event loop alive.
+struct Watching {
+    std::unique_ptr<Watcher> watcher;
+    Napi::ThreadSafeFunction function;
+    std::shared_ptr<std::atomic<bool>> pending = std::make_shared<std::atomic<bool>>(false);
+
+    //The notifications stopped first (no call once the watcher is gone), then the function released
+    void stop()
+    {
+        if (!watcher) return;
+        watcher.reset();
+        function.Release();
+    }
+};
+
+struct Environment {
+    Watching watching;
+};
+
+Environment &environmentOf(Napi::Env env)
+{
+    return **env.GetInstanceData<std::shared_ptr<Environment>>();
+}
+
+//watch(changed): the notifications of the changes of the interfaces start, changed() called (with no argument) at each
+//one; once only by environment
+Napi::Value Watch(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Watching &watching = environmentOf(env).watching;
+    if (watching.watcher) throw Napi::Error::New(env, "The interfaces are watched already");
+    if (!info[0].IsFunction()) throw Napi::TypeError::New(env, "watch() takes a function");
+    Napi::ThreadSafeFunction function = Napi::ThreadSafeFunction::New(env, info[0].As<Napi::Function>(), "lakutata-netif", 0, 1);
+    function.Unref(env);
+    std::shared_ptr<std::atomic<bool>> pending = watching.pending;
+    pending->store(false);
+    try {
+        watching.watcher = std::make_unique<Watcher>([function, pending]() mutable {
+            if (pending->exchange(true)) return;
+            napi_status status = function.NonBlockingCall([pending](Napi::Env, Napi::Function changed) {
+                pending->store(false);
+                changed.Call({});
+            });
+            if (status != napi_ok) pending->store(false);
+        });
+    } catch (const std::system_error &error) {
+        function.Release();
+        throw systemError(env, error);
+    }
+    watching.function = function;
+    return env.Undefined();
+}
+
+//unwatch(): the notifications stopped
+Napi::Value Unwatch(const Napi::CallbackInfo &info)
+{
+    environmentOf(info.Env()).watching.stop();
+    return info.Env().Undefined();
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    //Shared with the cleanup hook: alive whichever of the hook and the instance data goes first
+    auto environment = std::make_shared<Environment>();
+    env.SetInstanceData(new std::shared_ptr<Environment>(environment));
+    //Before the environment ends (a worker terminated, the process exiting): the notifications stopped
+    env.AddCleanupHook([environment]() {
+        environment->watching.stop();
+    });
+    exports.Set("list", Napi::Function::New(env, List));
+    exports.Set("watch", Napi::Function::New(env, Watch));
+    exports.Set("unwatch", Napi::Function::New(env, Unwatch));
+    exports.Set("bindSocket", Napi::Function::New(env, BindSocket));
+    exports.Set("membership", Napi::Function::New(env, Membership));
+    exports.Set("weakReception", Napi::Function::New(env, WeakReceptionOf));
+    return exports;
+}
+
+}
+
+NODE_API_MODULE(netif, Init)

package/native/darwin/Interfaces.cpp

@@ -0,0 +1,150 @@
+//The interfaces of macOS, read by getifaddrs(): the link entry of each interface (name, index, hardware address, flags),
+//then its addresses. The link state comes from the media of the interface (SIOCGIFMEDIA) where it has one (IFF_RUNNING
+//stays set on an Ethernet port without its cable), the duplicate address detection of an IPv6 address from its flags
+//(SIOCGIFAFLAG_IN6).
+#include "../Interfaces.h"
+
+#include <ifaddrs.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_media.h>
+#include <netinet/in.h>
+#include <netinet6/in6_var.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <map>
+#include <system_error>
+#include <utility>
+
+namespace netif {
+
+namespace {
+
+const char *const MASKED_MAC = "02:00:00:00:00:00";
+
+class Descriptor {
+public:
+    explicit Descriptor(int family) : fd(socket(family, SOCK_DGRAM, 0))
+    {
+    }
+
+    ~Descriptor()
+    {
+        if (fd >= 0) close(fd);
+    }
+
+    Descriptor(const Descriptor &) = delete;
+
+    Descriptor &operator=(const Descriptor &) = delete;
+
+    const int fd;
+};
+
+unsigned prefixLength(const sockaddr *netmask)
+{
+    if (!netmask) return 0;
+    const unsigned char *bytes = nullptr;
+    size_t length = 0;
+    if (netmask->sa_family == AF_INET) {
+        bytes = reinterpret_cast<const unsigned char *>(&reinterpret_cast<const sockaddr_in *>(netmask)->sin_addr);
+        length = 4;
+    } else if (netmask->sa_family == AF_INET6) {
+        bytes = reinterpret_cast<const unsigned char *>(&reinterpret_cast<const sockaddr_in6 *>(netmask)->sin6_addr);
+        length = 16;
+    } else {
+        return 0;
+    }
+    unsigned bits = 0;
+    for (size_t index = 0; index < length; index++) bits += static_cast<unsigned>(__builtin_popcount(bytes[index]));
+    return bits;
+}
+
+//The link is up: its media says so, or (no media) the interface runs
+bool linkActive(const Descriptor &probe, const char *name, unsigned int flags)
+{
+    if (probe.fd >= 0) {
+        ifmediareq media{};
+        std::strncpy(media.ifm_name, name, sizeof media.ifm_name - 1);
+        if (ioctl(probe.fd, SIOCGIFMEDIA, &media) == 0 && (media.ifm_status & IFM_AVALID)) return media.ifm_status & IFM_ACTIVE;
+    }
+    return flags & IFF_RUNNING;
+}
+
+bool tentative(const Descriptor &probe, const char *name, const sockaddr_in6 *address)
+{
+    if (probe.fd < 0) return false;
+    in6_ifreq request{};
+    std::strncpy(request.ifr_name, name, sizeof request.ifr_name - 1);
+    request.ifr_addr = *address;
+    if (ioctl(probe.fd, SIOCGIFAFLAG_IN6, &request) != 0) return false;
+    int flags = request.ifr_ifru.ifru_flags6;
+    if (flags & IN6_IFF_DUPLICATED) return true;
+    return (flags & IN6_IFF_TENTATIVE) && !(flags & IN6_IFF_OPTIMISTIC);
+}
+
+}
+
+std::vector<Interface> listInterfaces()
+{
+    ifaddrs *entries = nullptr;
+    if (getifaddrs(&entries) != 0) throw std::system_error(errno, std::generic_category(), "getifaddrs");
+    Descriptor probe4(AF_INET);
+    Descriptor probe6(AF_INET6);
+    std::vector<Interface> interfaces;
+    std::map<std::string, size_t> positions;
+    auto at = [&](const ifaddrs *entry) -> Interface & {
+        auto position = positions.find(entry->ifa_name);
+        if (position != positions.end()) return interfaces[position->second];
+        Interface created;
+        created.name = entry->ifa_name;
+        created.index = if_nametoindex(entry->ifa_name);
+        created.up = entry->ifa_flags & IFF_UP;
+        created.loopback = entry->ifa_flags & IFF_LOOPBACK;
+        created.running = linkActive(probe4, entry->ifa_name, entry->ifa_flags);
+        positions[created.name] = interfaces.size();
+        interfaces.push_back(std::move(created));
+        return interfaces.back();
+    };
+    for (const ifaddrs *entry = entries; entry; entry = entry->ifa_next) {
+        if (!entry->ifa_name) continue;
+        Interface &owner = at(entry);
+        if (!entry->ifa_addr) continue;
+        if (entry->ifa_addr->sa_family == AF_LINK) {
+            auto *link = reinterpret_cast<const sockaddr_dl *>(entry->ifa_addr);
+            if (link->sdl_index) owner.index = link->sdl_index;
+            owner.mac = macText(reinterpret_cast<const unsigned char *>(LLADDR(link)), link->sdl_alen);
+            //Newer macOS (27 at least) gives the processes without an entitlement 02:00:00:00:00:00 for every interface in
+            //place of its hardware address (os.networkInterfaces() too): no address then
+            if (owner.mac == MASKED_MAC) owner.mac.clear();
+        } else if (entry->ifa_addr->sa_family == AF_INET) {
+            Address address;
+            address.family = 4;
+            address.address = addressText(AF_INET, &reinterpret_cast<const sockaddr_in *>(entry->ifa_addr)->sin_addr);
+            address.prefixLength = prefixLength(entry->ifa_netmask);
+            owner.addresses.push_back(std::move(address));
+        } else if (entry->ifa_addr->sa_family == AF_INET6) {
+            sockaddr_in6 socketAddress = *reinterpret_cast<const sockaddr_in6 *>(entry->ifa_addr);
+            Address address;
+            address.family = 6;
+            address.prefixLength = prefixLength(entry->ifa_netmask);
+            address.tentative = tentative(probe6, entry->ifa_name, &socketAddress);
+            //A link-local address carries its scope in its second 16 bits inside the kernel (KAME): removed from the text
+            unsigned char *octets = socketAddress.sin6_addr.s6_addr;
+            if (octets[0] == 0xfe && (octets[1] & 0xc0) == 0x80) {
+                octets[2] = 0;
+                octets[3] = 0;
+                address.scopeId = owner.index;
+            }
+            address.address = addressText(AF_INET6, &socketAddress.sin6_addr);
+            owner.addresses.push_back(std::move(address));
+        }
+    }
+    freeifaddrs(entries);
+    return interfaces;
+}
+
+}

package/native/darwin/Sockets.cpp

@@ -0,0 +1,44 @@
+//macOS: no socket of an interface (IP_BOUND_IF only chooses the interface the packets leave by); the strong host model
+//of the system (net.inet.ip.check_interface = 2, its IPv6 counterpart) refuses the packets of an address that come
+//through another interface, as long as the forwarding of the family is off (XNU skips the check while it forwards).
+#include "../Sockets.h"
+
+#include <sys/sysctl.h>
+
+#include <cerrno>
+#include <system_error>
+
+namespace netif {
+
+namespace {
+
+int setting(const char *name)
+{
+    int value = 0;
+    size_t size = sizeof value;
+    if (sysctlbyname(name, &value, &size, nullptr, 0) != 0) return -1;
+    return value;
+}
+
+}
+
+BoundSocket bindToInterface(const std::string &, int, bool, uint16_t, int)
+{
+    throw std::system_error(ENOTSUP, std::generic_category(), "bind to an interface");
+}
+
+void membership(int, const std::string &, uint32_t, bool)
+{
+    throw std::system_error(ENOTSUP, std::generic_category(), "membership");
+}
+
+std::optional<WeakReception> weakReception(uint32_t, int family)
+{
+    const char *check = family == 6 ? "net.inet6.ip6.check_interface" : "net.inet.ip.check_interface";
+    const char *forwarding = family == 6 ? "net.inet6.ip6.forwarding" : "net.inet.ip.forwarding";
+    if (setting(check) != 2) return WeakReception{std::string(), std::string(check)};
+    if (setting(forwarding) != 0) return WeakReception{std::string(), std::string(forwarding)};
+    return std::nullopt;
+}
+
+}

package/native/darwin/Watcher.cpp

@@ -0,0 +1,113 @@
+//The notifications of macOS: the kernel events of the network (a PF_SYSTEM socket filtered to their class), read by a
+//thread of the addon, which a pipe wakes to stop. Of the events only the ones of the interfaces (attached, detached,
+//flags, link) and of their addresses count. The routing socket has no message for an interface attached or detached.
+#include "../Watcher.h"
+
+#include <net/net_kev.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <sys/kern_event.h>
+#include <sys/socket.h>
+#include <sys/sys_domain.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <system_error>
+#include <thread>
+#include <vector>
+
+namespace netif {
+
+struct Watcher::State {
+    int socket = -1;
+    int wake[2] = {-1, -1};
+    std::thread thread;
+};
+
+namespace {
+
+bool counts(const kern_event_msg *event)
+{
+    if (event->vendor_code != KEV_VENDOR_APPLE || event->kev_class != KEV_NETWORK_CLASS) return false;
+    switch (event->kev_subclass) {
+        case KEV_INET_SUBCLASS:
+            return event->event_code == KEV_INET_NEW_ADDR || event->event_code == KEV_INET_CHANGED_ADDR || event->event_code == KEV_INET_ADDR_DELETED || event->event_code == KEV_INET_SIFNETMASK;
+        case KEV_INET6_SUBCLASS:
+            return event->event_code == KEV_INET6_NEW_USER_ADDR || event->event_code == KEV_INET6_CHANGED_ADDR || event->event_code == KEV_INET6_ADDR_DELETED || event->event_code == KEV_INET6_NEW_LL_ADDR || event->event_code == KEV_INET6_NEW_RTADV_ADDR;
+        case KEV_DL_SUBCLASS:
+            return event->event_code == KEV_DL_SIFFLAGS || event->event_code == KEV_DL_SIFMEDIA || event->event_code == KEV_DL_IF_ATTACHED || event->event_code == KEV_DL_IF_DETACHED || event->event_code == KEV_DL_LINK_OFF || event->event_code == KEV_DL_LINK_ON || event->event_code == KEV_DL_LINK_ADDRESS_CHANGED;
+        default:
+            return false;
+    }
+}
+
+void closeAll(int socket, const int (&wake)[2])
+{
+    if (socket >= 0) close(socket);
+    for (int descriptor : wake) {
+        if (descriptor >= 0) close(descriptor);
+    }
+}
+
+}
+
+Watcher::Watcher(std::function<void()> changed) : state(std::make_unique<State>())
+{
+    state->socket = socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT);
+    if (state->socket < 0) throw std::system_error(errno, std::generic_category(), "socket(PF_SYSTEM)");
+    kev_request filter{KEV_VENDOR_APPLE, KEV_NETWORK_CLASS, KEV_ANY_SUBCLASS};
+    if (ioctl(state->socket, SIOCSKEVFILT, &filter) != 0 || pipe(state->wake) != 0) {
+        int error = errno;
+        closeAll(state->socket, state->wake);
+        state->socket = -1;
+        throw std::system_error(error, std::generic_category(), "SIOCSKEVFILT");
+    }
+    for (int descriptor : {state->socket, state->wake[0], state->wake[1]}) {
+        fcntl(descriptor, F_SETFD, FD_CLOEXEC);
+        fcntl(descriptor, F_SETFL, fcntl(descriptor, F_GETFL) | O_NONBLOCK);
+    }
+    State *watched = state.get();
+    state->thread = std::thread([watched, changed]() {
+        std::vector<char> buffer(8192);
+        pollfd descriptors[2] = {{watched->socket, 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 = read(watched->socket, buffer.data(), buffer.size());
+                if (received < 0) {
+                    if (errno == EINTR) continue;
+                    if (errno == ENOBUFS) any = true;
+                    break;
+                }
+                //The events of a read, one after the other
+                for (ssize_t offset = 0; offset + static_cast<ssize_t>(KEV_MSG_HEADER_SIZE) <= received;) {
+                    auto *event = reinterpret_cast<const kern_event_msg *>(buffer.data() + offset);
+                    if (event->total_size < KEV_MSG_HEADER_SIZE) break;
+                    any = any || counts(event);
+                    offset += event->total_size;
+                }
+            }
+            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();
+    closeAll(state->socket, state->wake);
+}
+
+}

package/native/linux/Interfaces.cpp

@@ -0,0 +1,133 @@
+//The interfaces of Linux, read by netlink: the dump of the links (name, index, hardware address, flags), then the one of
+//the addresses with their flags (a tentative IPv6 address is in its duplicate address detection). getifaddrs() gives no
+//flags of the addresses.
+#include "../Interfaces.h"
+#include "RouteNetlink.h"
+
+#include <linux/if_addr.h>
+#include <net/if.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <map>
+#include <system_error>
+#include <utility>
+
+namespace netif {
+
+Netlink::Netlink(uint32_t groups)
+{
+    descriptor = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
+    if (descriptor < 0) throw std::system_error(errno, std::generic_category(), "socket(AF_NETLINK)");
+    sockaddr_nl local{};
+    local.nl_family = AF_NETLINK;
+    local.nl_groups = groups;
+    if (bind(descriptor, reinterpret_cast<sockaddr *>(&local), sizeof local) < 0) {
+        int error = errno;
+        close(descriptor);
+        descriptor = -1;
+        throw std::system_error(error, std::generic_category(), "bind(AF_NETLINK)");
+    }
+}
+
+Netlink::~Netlink()
+{
+    if (descriptor >= 0) close(descriptor);
+}
+
+void Netlink::dump(uint16_t type, unsigned char family, const std::function<void(const nlmsghdr *)> &handler)
+{
+    struct {
+        nlmsghdr header;
+        rtgenmsg message;
+    } request{};
+    request.header.nlmsg_len = NLMSG_LENGTH(sizeof(rtgenmsg));
+    request.header.nlmsg_type = type;
+    request.header.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+    request.header.nlmsg_seq = ++sequence;
+    request.message.rtgen_family = family;
+    sockaddr_nl kernel{};
+    kernel.nl_family = AF_NETLINK;
+    if (sendto(descriptor, &request, request.header.nlmsg_len, 0, reinterpret_cast<sockaddr *>(&kernel), sizeof kernel) < 0) {
+        throw std::system_error(errno, std::generic_category(), "send(netlink)");
+    }
+    std::vector<char> buffer(65536);
+    for (;;) {
+        ssize_t received = recv(descriptor, buffer.data(), buffer.size(), 0);
+        if (received < 0) {
+            if (errno == EINTR) continue;
+            throw std::system_error(errno, std::generic_category(), "recv(netlink)");
+        }
+        int remaining = static_cast<int>(received);
+        for (auto *header = reinterpret_cast<nlmsghdr *>(buffer.data()); NLMSG_OK(header, remaining); header = NLMSG_NEXT(header, remaining)) {
+            if (header->nlmsg_seq != sequence) continue;
+            if (header->nlmsg_type == NLMSG_DONE) return;
+            if (header->nlmsg_type == NLMSG_ERROR) {
+                auto *error = static_cast<const nlmsgerr *>(NLMSG_DATA(header));
+                if (error->error == 0) continue;
+                throw std::system_error(-error->error, std::generic_category(), "netlink dump");
+            }
+            handler(header);
+        }
+    }
+}
+
+std::vector<Interface> listInterfaces()
+{
+    Netlink netlink;
+    std::vector<Interface> interfaces;
+    std::map<uint32_t, size_t> positions;
+    netlink.dump(RTM_GETLINK, AF_UNSPEC, [&](const nlmsghdr *header) {
+        if (header->nlmsg_type != RTM_NEWLINK) return;
+        auto *info = static_cast<const ifinfomsg *>(NLMSG_DATA(header));
+        Interface entry;
+        entry.index = static_cast<uint32_t>(info->ifi_index);
+        entry.up = info->ifi_flags & IFF_UP;
+        entry.running = info->ifi_flags & IFF_RUNNING;
+        entry.loopback = info->ifi_flags & IFF_LOOPBACK;
+        int length = static_cast<int>(IFLA_PAYLOAD(header));
+        for (auto *attribute = IFLA_RTA(info); RTA_OK(attribute, length); attribute = RTA_NEXT(attribute, length)) {
+            if (attribute->rta_type == IFLA_IFNAME) {
+                entry.name = static_cast<const char *>(RTA_DATA(attribute));
+            } else if (attribute->rta_type == IFLA_ADDRESS) {
+                entry.mac = macText(static_cast<const unsigned char *>(RTA_DATA(attribute)), RTA_PAYLOAD(attribute));
+            }
+        }
+        positions[entry.index] = interfaces.size();
+        interfaces.push_back(std::move(entry));
+    });
+    netlink.dump(RTM_GETADDR, AF_UNSPEC, [&](const nlmsghdr *header) {
+        if (header->nlmsg_type != RTM_NEWADDR) return;
+        auto *info = static_cast<const ifaddrmsg *>(NLMSG_DATA(header));
+        if (info->ifa_family != AF_INET && info->ifa_family != AF_INET6) return;
+        auto position = positions.find(info->ifa_index);
+        if (position == positions.end()) return;
+        const void *local = nullptr;
+        const void *address = nullptr;
+        uint32_t flags = info->ifa_flags;
+        int length = static_cast<int>(IFA_PAYLOAD(header));
+        for (auto *attribute = IFA_RTA(info); RTA_OK(attribute, length); attribute = RTA_NEXT(attribute, length)) {
+            if (attribute->rta_type == IFA_LOCAL) local = RTA_DATA(attribute);
+            else if (attribute->rta_type == IFA_ADDRESS) address = RTA_DATA(attribute);
+#ifdef IFA_FLAGS
+            else if (attribute->rta_type == IFA_FLAGS) flags = *static_cast<const uint32_t *>(RTA_DATA(attribute));
+#endif
+        }
+        //IPv4: the local address is IFA_LOCAL (IFA_ADDRESS is the peer of a point-to-point link); IPv6: IFA_ADDRESS
+        const void *bytes = info->ifa_family == AF_INET && local ? local : (address ? address : local);
+        if (!bytes) return;
+        Address entry;
+        entry.family = info->ifa_family == AF_INET ? 4 : 6;
+        entry.address = addressText(info->ifa_family, bytes);
+        entry.prefixLength = info->ifa_prefixlen;
+        //An optimistic address (RFC 4429) is usable while its detection runs
+        entry.tentative = (flags & IFA_F_DADFAILED) || ((flags & IFA_F_TENTATIVE) && !(flags & IFA_F_OPTIMISTIC));
+        auto *octets = static_cast<const unsigned char *>(bytes);
+        if (entry.family == 6 && octets[0] == 0xfe && (octets[1] & 0xc0) == 0x80) entry.scopeId = info->ifa_index;
+        interfaces[position->second].addresses.push_back(std::move(entry));
+    });
+    return interfaces;
+}
+
+}

package/native/linux/RouteNetlink.h

@@ -0,0 +1,38 @@
+//A netlink socket of the routing family (NETLINK_ROUTE): the dumps of the links and the addresses the interfaces are
+//read from, and the socket of the notifications of their changes. Not named Netlink.h: native is an include directory,
+//and a file system ignoring case would take that file for <linux/netlink.h>
+#pragma once
+
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+#include <cstdint>
+#include <functional>
+
+namespace netif {
+
+class Netlink {
+public:
+    //A socket for dumps (groups 0), or one joined to the given groups of notifications (RTMGRP_*)
+    explicit Netlink(uint32_t groups = 0);
+
+    ~Netlink();
+
+    Netlink(const Netlink &) = delete;
+
+    Netlink &operator=(const Netlink &) = delete;
+
+    int fd() const
+    {
+        return descriptor;
+    }
+
+    //Every message of a dump of the given request type (RTM_GETLINK, RTM_GETADDR), given to the handler
+    void dump(uint16_t type, unsigned char family, const std::function<void(const nlmsghdr *)> &handler);
+
+private:
+    int descriptor = -1;
+    uint32_t sequence = 0;
+};
+
+}