+ if(reach_v4) {
+ SCNetworkReachabilitySetCallback(reach_v4, reachability_change_callback, &context);
+ SCNetworkReachabilityScheduleWithRunLoop(reach_v4, mesh->discovery.runloop, kCFRunLoopDefaultMode);
+ } else {
+ logger(mesh, MESHLINK_ERROR, "Could not create IPv4 network reachability watcher");
+ }
+
+ if(reach_v6) {
+ SCNetworkReachabilitySetCallback(reach_v6, reachability_change_callback, &context);
+ SCNetworkReachabilityScheduleWithRunLoop(reach_v6, mesh->discovery.runloop, kCFRunLoopDefaultMode);
+ } else {
+ logger(mesh, MESHLINK_ERROR, "Could not create IPv6 network reachability watcher");
+ }
+
+ CFRunLoopRun();
+
+ mesh->discovery.runloop = NULL;
+
+ if(reach_v4) {
+ SCNetworkReachabilityUnscheduleFromRunLoop(reach_v4, mesh->discovery.runloop, kCFRunLoopDefaultMode);
+ CFRelease(reach_v4);
+ }
+
+ if(reach_v6) {
+ SCNetworkReachabilityUnscheduleFromRunLoop(reach_v6, mesh->discovery.runloop, kCFRunLoopDefaultMode);
+ CFRelease(reach_v6);
+ }
+
+ return NULL;
+}
+#elif defined(RTM_NEWADDR)
+static void pfroute_parse_iface(meshlink_handle_t *mesh, const struct rt_msghdr *rtm) {
+ const struct if_msghdr *ifm = (const struct if_msghdr *)rtm;
+
+ if(ifm->ifm_flags & IFF_UP && ifm->ifm_flags & IFF_MULTICAST && !(ifm->ifm_flags & IFF_LOOPBACK)) {
+ iface_up(mesh, ifm->ifm_index);
+ } else {
+ iface_down(mesh, ifm->ifm_index);
+ }
+}
+
+static void pfroute_parse_addr(meshlink_handle_t *mesh, const struct rt_msghdr *rtm) {
+ const struct ifa_msghdr *ifam = (const struct ifa_msghdr *)rtm;
+ const char *p = (const char *)(ifam + 1);
+
+ for(unsigned int i = 1; i; i <<= 1) {
+ if(!(ifam->ifam_addrs & i)) {
+ continue;
+ }
+
+ const sockaddr_t *sa = (const sockaddr_t *)p;
+
+ if(i == RTA_IFA) {
+ discovery_address_t addr = {
+ .index = ifam->ifam_index,
+ };
+
+ if(sa->sa.sa_family == AF_INET) {
+ addr.address.in = sa->in;
+ addr.address.in.sin_port = ntohs(5353);
+ } else if(sa->sa.sa_family == AF_INET6) {
+ addr.address.in6 = sa->in6;
+ addr.address.in6.sin6_port = ntohs(5353);
+ } else {
+ addr.address.sa.sa_family = AF_UNKNOWN;
+ }
+
+ if(addr.address.sa.sa_family != AF_UNKNOWN) {
+ if(ifam->ifam_type == RTM_NEWADDR) {
+ addr_add(mesh, &addr);
+ } else {
+ addr_del(mesh, &addr);
+ }
+ }
+
+ break;
+ }
+
+ size_t len = (sa->sa.sa_len + 3) & ~3;
+ p += len;
+ }
+}
+
+static void pfroute_io_handler(event_loop_t *loop, void *data, int flags) {
+ (void)flags;
+ (void)data;
+ meshlink_handle_t *mesh = loop->data;
+
+ struct {
+ struct rt_msghdr rtm;
+ char data[2048];
+ } msg;
+
+ while(true) {
+ msg.rtm.rtm_version = 0;
+ ssize_t result = recv(mesh->discovery.pfroute_io.fd, &msg, sizeof(msg), MSG_DONTWAIT);
+
+ if(result <= 0) {
+ if(result == 0 || errno == EAGAIN || errno == EINTR) {
+ break;
+ }
+
+ logger(mesh, MESHLINK_ERROR, "Reading from PFROUTE socket failed: %s\n", strerror(errno));
+ io_set(loop, &mesh->discovery.pfroute_io, 0);
+ }
+
+ if(msg.rtm.rtm_version != RTM_VERSION) {
+ logger(mesh, MESHLINK_ERROR, "Invalid PFROUTE message version\n");
+ break;
+ }
+
+ switch(msg.rtm.rtm_type) {
+ case RTM_IFINFO:
+ pfroute_parse_iface(mesh, &msg.rtm);
+ break;
+
+ case RTM_NEWADDR:
+ case RTM_DELADDR:
+ pfroute_parse_addr(mesh, &msg.rtm);
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+#endif
+
+bool discovery_start(meshlink_handle_t *mesh) {
+ logger(mesh, MESHLINK_DEBUG, "discovery_start called\n");
+
+ assert(mesh);
+
+ // Set up multicast sockets for mDNS
+ static const int one = 1;
+ static const int ttl = 255;
+ static const uint8_t one8 = 1;
+ static const uint8_t ttl8 = 255;
+
+ int fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+
+ if(fd == -1) {
+ logger(mesh, MESHLINK_ERROR, "Error creating IPv4 socket: %s", strerror(errno));
+ } else {
+
+ sockaddr_t sa4 = {
+ .in.sin_family = AF_INET,
+ .in.sin_port = ntohs(5353),
+ };
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+#ifdef SO_REUSEPORT
+ setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one));
+#endif
+#ifdef IP_PKTINFO
+ setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one));
+#endif
+ setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one8, sizeof(one8));
+ setsockopt(fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl8, sizeof(ttl8));
+
+ if(bind(fd, &sa4.sa, SALEN(sa4.sa)) == -1) {
+ logger(mesh, MESHLINK_ERROR, "Error binding to IPv4 multicast socket: %s", strerror(errno));
+ } else {
+ io_add(&mesh->loop, &mesh->discovery.sockets[0], mdns_io_handler, &mesh->discovery.sockets[0], fd, IO_READ);
+ }
+ }
+
+ fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
+
+ if(fd == -1) {
+ logger(mesh, MESHLINK_ERROR, "Error creating IPv6 socket: %s", strerror(errno));
+ } else {
+ sockaddr_t sa6 = {
+ .in6.sin6_family = AF_INET6,
+ .in6.sin6_port = ntohs(5353),
+ };
+
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+#ifdef SO_REUSEPORT
+ setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one));
+#endif
+#ifdef IPV6_RECVPKTINFO
+ setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one));
+#endif
+ setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
+ setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one));
+ setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
+ setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl));
+
+ if(bind(fd, &sa6.sa, SALEN(sa6.sa)) == -1) {
+ logger(mesh, MESHLINK_ERROR, "Error binding to IPv6 multicast socket: %s", strerror(errno));
+ } else {
+ io_add(&mesh->loop, &mesh->discovery.sockets[1], mdns_io_handler, &mesh->discovery.sockets[1], fd, IO_READ);
+ }
+ }
+
+#if defined(__linux)
+ int sock = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
+
+ if(sock != -1) {
+ struct sockaddr_nl sa;
+ memset(&sa, 0, sizeof(sa));
+ sa.nl_family = AF_NETLINK;
+ sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR;
+
+ if(bind(sock, (struct sockaddr *)&sa, sizeof(sa)) != -1) {
+ io_add(&mesh->loop, &mesh->discovery.pfroute_io, netlink_io_handler, NULL, sock, IO_READ);
+ netlink_getlink(sock);
+ } else {
+ logger(mesh, MESHLINK_WARNING, "Could not bind AF_NETLINK socket: %s", strerror(errno));
+ scan_ifaddrs(mesh);
+ }
+ } else {
+ logger(mesh, MESHLINK_WARNING, "Could not open AF_NETLINK socket: %s", strerror(errno));
+ scan_ifaddrs(mesh);
+ }
+
+#elif defined(__APPLE__)
+ pthread_create(&mesh->discovery.thread, NULL, network_change_handler, mesh);
+ // TODO: Do we need to wait for the thread to start succesfully?
+ scan_ifaddrs(mesh);
+#elif defined(RTM_NEWADDR)
+ int sock = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC);
+
+ if(sock != -1) {
+ io_add(&mesh->loop, &mesh->discovery.pfroute_io, pfroute_io_handler, NULL, sock, IO_READ);
+ } else {
+ logger(mesh, MESHLINK_WARNING, "Could not open PF_ROUTE socket: %s", strerror(errno));
+ }
+
+ scan_ifaddrs(mesh);
+#endif
+
+ return true;
+}
+
+void discovery_stop(meshlink_handle_t *mesh) {
+ logger(mesh, MESHLINK_DEBUG, "discovery_stop called\n");
+
+ assert(mesh);
+
+ free(mesh->discovery.ifaces);
+ free(mesh->discovery.addresses);
+ mesh->discovery.ifaces = NULL;
+ mesh->discovery.addresses = NULL;
+ mesh->discovery.iface_count = 0;
+ mesh->discovery.address_count = 0;
+
+#if defined(__APPLE__)
+
+ if(mesh->discovery.runloop) {
+ CFRunLoopStop(mesh->discovery.runloop);
+ pthread_join(mesh->discovery.thread, NULL);
+ }
+
+#endif
+
+ if(mesh->discovery.pfroute_io.cb) {
+ close(mesh->discovery.pfroute_io.fd);
+ io_del(&mesh->loop, &mesh->discovery.pfroute_io);
+ }
+
+ for(int i = 0; i < 2; i++) {
+ if(mesh->discovery.sockets[i].cb) {
+ close(mesh->discovery.sockets[i].fd);
+ io_del(&mesh->loop, &mesh->discovery.sockets[i]);
+ }
+ }
+}
+
+void discovery_refresh(meshlink_handle_t *mesh) {
+ for(int i = 0; i < mesh->discovery.address_count; i++) {
+ if(mesh->discovery.addresses[i].up) {
+ send_mdns_packet(mesh, &mesh->discovery.addresses[i], false);
+ }
+ }