Replace KDNSSD with mdns.h

KDNSSD only works with Avahi (so, only on Linux) while mdns.h is a
header-only library [1] that implements mdns from scratch and should
work on all platforms.

[1] https://github.com/mjansson/mdns

core/CMakeLists.txt

@@ -11,9 +11,6 @@ add_subdirectory(backends/lan)
 add_subdirectory(backends/loopback)
 
 option(MDNS_ENABLED "Use MDNS for device discovery (under development)" OFF)
-if (MDNS_ENABLED)
-    find_package(KF${QT_MAJOR_VERSION} ${KF_MIN_VERSION} REQUIRED COMPONENTS DNSSD)
-endif()
 
 option(BLUETOOTH_ENABLED "Bluetooth support for kdeconnect" OFF)
 if(BLUETOOTH_ENABLED)
@@ -86,7 +83,6 @@ endif()
 
 if (MDNS_ENABLED)
     target_compile_definitions(kdeconnectcore PRIVATE -DKDECONNECT_MDNS)
-    target_link_libraries(kdeconnectcore PRIVATE KF${QT_MAJOR_VERSION}::DNSSD)
 endif()
 
 set_target_properties(kdeconnectcore PROPERTIES

core/backends/lan/CMakeLists.txt

@@ -12,6 +12,7 @@ if (MDNS_ENABLED)
     set(backends_kdeconnect_SRCS
         ${backends_kdeconnect_SRCS}
         backends/lan/mdnsdiscovery.cpp
+        backends/lan/mdns_wrapper.cpp
     )
 endif()
 

core/backends/lan/lanlinkprovider.cpp

@@ -74,12 +74,18 @@ LanLinkProvider::LanLinkProvider(bool testMode, quint16 udpBroadcastPort, quint1
         if (m_lastConfig != config && config.state() == QNetworkConfiguration::Active) {
             m_lastConfig = config;
             onNetworkChange();
+#ifdef KDECONNECT_MDNS
+            m_mdnsDiscovery.onNetworkChange();
+#endif
         }
     });
 #else
     const auto checkNetworkChange = [this]() {
         if (QNetworkInformation::instance()->reachability() == QNetworkInformation::Reachability::Online) {
             onNetworkChange();
+#ifdef KDECONNECT_MDNS
+            m_mdnsDiscovery.onNetworkChange();
+#endif
         }
     };
     // Detect when a network interface changes status, so we announce ourselves in the new network

core/backends/lan/mdns_wrapper.cpp

@@ -0,0 +1,594 @@
+/**
+ * SPDX-FileCopyrightText: 2023 Albert Vaca Cintora <albertvaka@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+ */
+
+#include "mdns_wrapper.h"
+
+#include "core_debug.h"
+
+#include "mdns.h"
+
+#include <errno.h>
+
+#include <QHostInfo>
+#include <QNetworkInterface>
+#include <QSocketNotifier>
+
+namespace MdnsWrapper
+{
+
+const char *recordTypeToStr(int rtype)
+{
+    switch (rtype) {
+    case MDNS_RECORDTYPE_PTR:
+        return "PTR";
+    case MDNS_RECORDTYPE_SRV:
+        return "SRV";
+    case MDNS_RECORDTYPE_TXT:
+        return "TXT";
+    case MDNS_RECORDTYPE_A:
+        return "A";
+    case MDNS_RECORDTYPE_AAAA:
+        return "AAAA";
+    case MDNS_RECORDTYPE_ANY:
+        return "ANY";
+    default:
+        return "UNKNOWN";
+    }
+}
+
+const char *entryTypeToStr(int entry)
+{
+    switch (entry) {
+    case MDNS_ENTRYTYPE_QUESTION:
+        return "QUESTION";
+    case MDNS_ENTRYTYPE_ANSWER:
+        return "ANSWER";
+    case MDNS_ENTRYTYPE_AUTHORITY:
+        return "AUTHORITY";
+    case MDNS_ENTRYTYPE_ADDITIONAL:
+        return "ADDITIONAL";
+    default:
+        return "UNKNOWN";
+    }
+}
+
+static sockaddr_in qHostAddressToSockaddr(QHostAddress hostAddress)
+{
+    Q_ASSERT(hostAddress.protocol() == QAbstractSocket::IPv4Protocol);
+    sockaddr_in socketAddress;
+    memset(&socketAddress, 0, sizeof(socketAddress));
+    socketAddress.sin_family = AF_INET;
+    socketAddress.sin_addr.s_addr = htonl(hostAddress.toIPv4Address());
+    return socketAddress;
+}
+
+static sockaddr_in6 qHostAddressToSockaddr6(QHostAddress hostAddress)
+{
+    Q_ASSERT(hostAddress.protocol() == QAbstractSocket::IPv6Protocol);
+    sockaddr_in6 socketAddress;
+    memset(&socketAddress, 0, sizeof(socketAddress));
+    socketAddress.sin6_family = AF_INET6;
+    Q_IPV6ADDR ipv6Address = hostAddress.toIPv6Address();
+    for (int i = 0; i < 16; ++i) {
+        socketAddress.sin6_addr.s6_addr[i] = ipv6Address[i];
+    }
+    return socketAddress;
+}
+
+// Callback that handles responses to a query
+static int query_callback(int sock, const struct sockaddr* from, size_t addrlen, mdns_entry_type_t entry_type,
+               uint16_t query_id, uint16_t record_type, uint16_t rclass, uint32_t ttl, const void* data,
+               size_t size, size_t name_offset, size_t name_length, size_t record_offset,
+               size_t record_length, void* user_data) {
+    Q_UNUSED(sock);
+    Q_UNUSED(addrlen);
+    Q_UNUSED(query_id);
+    Q_UNUSED(entry_type);
+    Q_UNUSED(rclass);
+    Q_UNUSED(ttl);
+    Q_UNUSED(name_offset);
+    Q_UNUSED(name_length);
+
+    //qCDebug(KDECONNECT_CORE) << "Received DNS record of type" << recordTypeToStr(record_type) << "from socket" << sock << "with type" << entryTypeToStr(entry_type);
+
+    Discoverer::MdnsService *discoveredService = (Discoverer::MdnsService *)user_data;
+
+    switch (record_type) {
+    case MDNS_RECORDTYPE_PTR: {
+        // We don't use mdns_record_parse_ptr() because we want to extract just the service name instead of the full "<service-name>.<_service-type>._tcp.local." string
+        mdns_string_pair_t serviceNamePos = mdns_get_next_substring(data, size, record_offset);
+        discoveredService->name = QString::fromLatin1((char *)data + serviceNamePos.offset, serviceNamePos.length);
+        //static char serviceNameBuffer[256];
+        //mdns_string_t serviceName = mdns_record_parse_ptr(data, size, record_offset, record_length, serviceNameBuffer, sizeof(serviceNameBuffer));
+        //discoveredService->name = QString::fromLatin1(serviceName.str, serviceName.length);
+        if (discoveredService->address == QHostAddress::Null) {
+            discoveredService->address = QHostAddress(from); // In case we don't receive a A record, use from as address
+        }
+    } break;
+    case MDNS_RECORDTYPE_SRV: {
+        static char nameBuffer[256];
+        mdns_record_srv_t record = mdns_record_parse_srv(data, size, record_offset, record_length, nameBuffer, sizeof(nameBuffer));
+        // We can use the IP to connect so we don't need to store the "<hostname>.local." address.
+        //discoveredService->qualifiedHostname = QString::fromLatin1(record.name.str, record.name.length);
+        discoveredService->port = record.port;
+    } break;
+    case MDNS_RECORDTYPE_A: {
+        sockaddr_in addr;
+        mdns_record_parse_a(data, size, record_offset, record_length, &addr);
+        discoveredService->address = QHostAddress(ntohl(addr.sin_addr.s_addr));
+    } break;
+    case MDNS_RECORDTYPE_AAAA:
+        // Ignore IPv6 for now
+        //sockaddr_in6 addr6;
+        //mdns_record_parse_aaaa(data, size, record_offset, record_length, &addr6);
+        break;
+    case MDNS_RECORDTYPE_TXT: {
+        mdns_record_txt_t records[24];
+        size_t parsed = mdns_record_parse_txt(data, size, record_offset, record_length, records, sizeof(records) / sizeof(mdns_record_txt_t));
+        for (size_t itxt = 0; itxt < parsed; ++itxt) {
+            QString key = QString::fromLatin1(records[itxt].key.str, records[itxt].key.length);
+            QString value = QString::fromLatin1(records[itxt].value.str, records[itxt].value.length);
+            discoveredService->txtRecords[key] = value;
+        }
+    } break;
+    default:
+        // Ignore unknown record types
+        break;
+    }
+
+    return 0;
+}
+
+void Discoverer::startDiscovering(const QString &serviceType)
+{
+    int num_sockets = listenForQueryResponses();
+    if (num_sockets <= 0) {
+        qCWarning(KDECONNECT_CORE) << "Failed to open any MDNS server sockets";
+        return;
+    }
+    sendQuery(serviceType);
+}
+
+void Discoverer::stopDiscovering()
+{
+    stopListeningForQueryResponses();
+}
+
+void Discoverer::stopListeningForQueryResponses()
+{
+    qCDebug(KDECONNECT_CORE) << "Closing" << responseSocketNotifiers.size() << "sockets";
+    for (QSocketNotifier *socketNotifier : qAsConst(responseSocketNotifiers)) {
+        mdns_socket_close(socketNotifier->socket());
+        delete socketNotifier;
+    }
+    responseSocketNotifiers.clear();
+}
+
+int Discoverer::listenForQueryResponses()
+{
+    // Open a socket for each interface
+    QVector<int> sockets;
+    for (const QNetworkInterface &iface : QNetworkInterface::allInterfaces()) {
+        int flags = iface.flags();
+        if (!(flags & QNetworkInterface::IsUp) || !(flags & QNetworkInterface::CanMulticast) || (flags & QNetworkInterface::IsLoopBack)) {
+            continue;
+        }
+        for (const QNetworkAddressEntry &ifaceAddress : iface.addressEntries()) {
+            QHostAddress sourceAddress = ifaceAddress.ip();
+            if (sourceAddress.protocol() == QAbstractSocket::IPv4Protocol && sourceAddress != QHostAddress::LocalHost) {
+                qCDebug(KDECONNECT_CORE) << "Opening socket for address" << sourceAddress;
+                struct sockaddr_in saddr = qHostAddressToSockaddr(sourceAddress);
+                int socket = mdns_socket_open_ipv4(&saddr);
+                sockets.append(socket);
+            } else if (sourceAddress.protocol() == QAbstractSocket::IPv6Protocol && sourceAddress != QHostAddress::LocalHostIPv6) {
+                qCDebug(KDECONNECT_CORE) << "Opening socket for address6" << sourceAddress;
+                struct sockaddr_in6 saddr = qHostAddressToSockaddr6(sourceAddress);
+                int socket = mdns_socket_open_ipv6(&saddr);
+                sockets.append(socket);
+            }
+        }
+    }
+
+    // Start listening on all sockets
+    for (int socket : sockets) {
+        QSocketNotifier *socketNotifier = new QSocketNotifier(socket, QSocketNotifier::Read);
+        QObject::connect(socketNotifier, &QSocketNotifier::activated, [this](QSocketDescriptor socket) {
+            MdnsService discoveredService;
+
+            static char buffer[2048];
+            size_t num_records = mdns_query_recv(socket, buffer, sizeof(buffer), query_callback, (void *)&discoveredService, 0);
+            Q_UNUSED(num_records);
+
+            // qCDebug(KDECONNECT_CORE) << "Discovered service" << discoveredService.name << "at" << discoveredService.address << "in" <<  num_records <<
+            // "records via socket" << socket;
+
+            Q_EMIT serviceFound(discoveredService);
+        });
+        responseSocketNotifiers.append(socketNotifier);
+    }
+
+    qCDebug(KDECONNECT_CORE) << "Opened" << sockets.size() << "sockets to listen for MDNS query responses";
+
+    return sockets.size();
+}
+
+void Discoverer::sendQuery(const QString &serviceType)
+{
+    qCDebug(KDECONNECT_CORE) << "Sending MDNS query for service" << serviceType;
+
+    mdns_query_t query;
+    QByteArray serviceTypeBytes = serviceType.toLatin1();
+    query.name = serviceTypeBytes.constData();
+    query.length = serviceTypeBytes.length();
+    query.type = MDNS_RECORDTYPE_PTR;
+
+    static char buffer[2048];
+    for (QSocketNotifier *socketNotifier : qAsConst(responseSocketNotifiers)) {
+        int socket = socketNotifier->socket();
+        qCDebug(KDECONNECT_CORE) << "Sending mDNS query via socket" << socket;
+        int ret = mdns_multiquery_send(socket, &query, 1, buffer, sizeof(buffer), 0);
+        if (ret < 0) {
+            qCWarning(KDECONNECT_CORE) << "Failed to send mDNS query:" << strerror(errno);
+        }
+    }
+}
+
+const QByteArray dnsSdName = QByteArray("_services._dns-sd._udp.local.");
+
+static mdns_string_t createMdnsString(const QByteArray &str)
+{
+    return mdns_string_t{str.constData(), (size_t)str.length()};
+}
+
+static QHostAddress findBestAddressMatch(QVector<QHostAddress> hostAddresses, const struct sockaddr *fromAddress)
+{
+    if (hostAddresses.size() == 1 || fromAddress == nullptr) {
+        return hostAddresses[0];
+    }
+    // FIXME
+    return hostAddresses[0];
+}
+
+static mdns_record_t createMdnsRecord(const Announcer::AnnouncedInfo &self,
+                                      mdns_record_type_t record_type,
+                                      const struct sockaddr *fromAddress = nullptr, // used to determine IP to set in A and AAAA records
+                                      QHash<QByteArray, QByteArray>::const_iterator txtIterator = {})
+{
+    mdns_record_t answer;
+    answer.type = record_type;
+    answer.rclass = 0;
+    answer.ttl = 0;
+    switch (record_type) {
+    case MDNS_RECORDTYPE_PTR: // maps "<_service-type>._tcp.local." to "<service-name>.<_service-type>._tcp.local."
+        answer.name = createMdnsString(self.serviceType);
+        answer.data.ptr.name = createMdnsString(self.serviceInstance);
+        break;
+    case MDNS_RECORDTYPE_SRV: // maps "<service-name>.<_service-type>._tcp.local." to "<hostname>.local." and port
+        answer.name = createMdnsString(self.serviceInstance);
+        answer.data.srv.name = createMdnsString(self.hostname);
+        answer.data.srv.port = self.port;
+        answer.data.srv.priority = 0;
+        answer.data.srv.weight = 0;
+        break;
+    case MDNS_RECORDTYPE_A: // maps "<hostname>.local." to IPv4
+        answer.name = createMdnsString(self.hostname);
+        answer.data.a.addr = qHostAddresstoSockaddr(findBestAddressMatch(self.addressesV4, fromAddress));
+        break;
+    case MDNS_RECORDTYPE_AAAA: // maps "<hostname>.local." to IPv6
+        answer.name = createMdnsString(self.hostname);
+        answer.data.aaaa.addr = qHostAddresstoSockaddr6(findBestAddressMatch(self.addressesV6, fromAddress));
+        break;
+    case MDNS_RECORDTYPE_TXT:
+        answer.name = createMdnsString(self.serviceInstance);
+        answer.type = MDNS_RECORDTYPE_TXT;
+        answer.data.txt.key = createMdnsString(txtIterator.key());
+        answer.data.txt.value = createMdnsString(txtIterator.value());
+        break;
+    default:
+        Q_ASSERT(false);
+    }
+    return answer;
+}
+
+// Callback handling questions incoming on service sockets
+static int service_callback(int sock, const struct sockaddr* from, size_t addrlen, mdns_entry_type_t entry_type,
+                 uint16_t query_id, uint16_t record_type, uint16_t rclass, uint32_t ttl, const void* data,
+                 size_t size, size_t name_offset, size_t name_length, size_t record_offset,
+                 size_t record_length, void* user_data) {
+    Q_UNUSED(ttl);
+    Q_UNUSED(name_length);
+    Q_UNUSED(record_offset);
+    Q_UNUSED(record_length);
+    static char sendbuffer[2024];
+
+    const Announcer::AnnouncedInfo &self = *((Announcer::AnnouncedInfo *)user_data);
+
+    if (entry_type != MDNS_ENTRYTYPE_QUESTION) {
+        return 0;
+    }
+
+    static char nameBuffer[256];
+    mdns_string_t nameMdnsString = mdns_string_extract(data, size, &name_offset, nameBuffer, sizeof(nameBuffer));
+    QByteArray name = QByteArray(nameMdnsString.str, nameMdnsString.length);
+
+    if (name == dnsSdName) {
+        if ((record_type == MDNS_RECORDTYPE_PTR) || (record_type == MDNS_RECORDTYPE_ANY)) {
+            // The PTR query was for the DNS-SD domain, send answer with a PTR record for the service name we advertise.
+
+            mdns_record_t answer = createMdnsRecord(self, MDNS_RECORDTYPE_PTR);
+
+            uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
+            if (unicast) {
+                mdns_query_answer_unicast(sock, from, addrlen, sendbuffer, sizeof(sendbuffer), query_id,
+                                          (mdns_record_type_t)record_type, nameMdnsString.str, nameMdnsString.length,
+                                          answer, nullptr, 0, nullptr, 0);
+            } else {
+                mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, nullptr, 0, nullptr, 0);
+            }
+        }
+    } else if (name == self.serviceType) {
+        if ((record_type == MDNS_RECORDTYPE_PTR) || (record_type == MDNS_RECORDTYPE_ANY)) {
+            // The PTR query was for our service, answer a PTR record reverse mapping the queried service name
+            // to our service instance name and add additional records containing the SRV record mapping the
+            // service instance name to our qualified hostname and port, as well as any IPv4/IPv6 and TXT records
+
+            mdns_record_t answer = createMdnsRecord(self, MDNS_RECORDTYPE_PTR);
+
+            QVector<mdns_record_t> additional;
+            additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_SRV));
+            if (!self.addressesV4.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_A, from));
+            }
+            if (!self.addressesV6.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_AAAA, from));
+            }
+
+            for (auto txtIterator = self.txtRecords.cbegin(); txtIterator != self.txtRecords.cend(); txtIterator++) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_TXT, nullptr, txtIterator));
+            }
+
+            uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
+            if (unicast) {
+                mdns_query_answer_unicast(sock, from, addrlen, sendbuffer, sizeof(sendbuffer), query_id,
+                                          (mdns_record_type_t)record_type, nameMdnsString.str, nameMdnsString.length,
+                                          answer, nullptr, 0, additional.constData(), additional.length());
+            } else {
+                mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, nullptr, 0,
+                                            additional.constData(), additional.length());
+            }
+        }
+    } else if (name == self.serviceInstance) {
+        if ((record_type == MDNS_RECORDTYPE_SRV) || (record_type == MDNS_RECORDTYPE_ANY)) {
+            // The SRV query was for our service instance, answer a SRV record mapping the service
+            // instance name to our qualified hostname (typically "<hostname>.local.") and port, as
+            // well as any IPv4/IPv6 address for the hostname as A/AAAA records and TXT records
+
+            mdns_record_t answer = createMdnsRecord(self, MDNS_RECORDTYPE_SRV);
+
+            QVector<mdns_record_t> additional;
+            if (!self.addressesV4.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_A, from));
+            }
+            if (!self.addressesV6.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_AAAA, from));
+            }
+
+            for (auto txtIterator = self.txtRecords.cbegin(); txtIterator != self.txtRecords.cend(); txtIterator++) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_TXT, nullptr, txtIterator));
+            }
+
+            uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
+            if (unicast) {
+                mdns_query_answer_unicast(sock, from, addrlen, sendbuffer, sizeof(sendbuffer), query_id,
+                                          (mdns_record_type_t)record_type, nameMdnsString.str, nameMdnsString.length,
+                                          answer, nullptr, 0, additional.constData(), additional.length());
+            } else {
+                mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, nullptr, 0,
+                                            additional.constData(), additional.length());
+            }
+        }
+    } else if (name == self.hostname) {
+        if (((record_type == MDNS_RECORDTYPE_A) || (record_type == MDNS_RECORDTYPE_ANY)) && !self.addressesV4.empty()) {
+            // The A query was for our qualified hostname and we have an IPv4 address, answer with an A
+            // record mapping the hostname to an IPv4 address, as well as an AAAA record and TXT records
+
+            mdns_record_t answer = createMdnsRecord(self, MDNS_RECORDTYPE_A, from);
+
+            QVector<mdns_record_t> additional;
+            if (!self.addressesV6.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_AAAA, from));
+            }
+
+            for (auto txtIterator = self.txtRecords.cbegin(); txtIterator != self.txtRecords.cend(); txtIterator++) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_TXT, nullptr, txtIterator));
+            }
+
+            uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
+            if (unicast) {
+                mdns_query_answer_unicast(sock, from, addrlen, sendbuffer, sizeof(sendbuffer), query_id,
+                                          (mdns_record_type_t)record_type, nameMdnsString.str, nameMdnsString.length,
+                                          answer, nullptr, 0, additional.constData(), additional.length());
+            } else {
+                mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, nullptr, 0,
+                                            additional.constData(), additional.length());
+            }
+        } else if (((record_type == MDNS_RECORDTYPE_AAAA) || (record_type == MDNS_RECORDTYPE_ANY)) && !self.addressesV6.empty()) {
+            // The AAAA query was for our qualified hostname and we have an IPv6 address, answer with an AAAA
+            // record mapping the hostname to an IPv4 address, as well as an A record and TXT records
+
+            mdns_record_t answer = createMdnsRecord(self, MDNS_RECORDTYPE_AAAA, from);
+
+            QVector<mdns_record_t> additional;
+            if (!self.addressesV4.empty()) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_A, from));
+            }
+
+            for (auto txtIterator = self.txtRecords.cbegin(); txtIterator != self.txtRecords.cend(); txtIterator++) {
+                additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_TXT, nullptr, txtIterator));
+            }
+
+            uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
+            if (unicast) {
+                mdns_query_answer_unicast(sock, from, addrlen, sendbuffer, sizeof(sendbuffer), query_id,
+                                          (mdns_record_type_t)record_type, nameMdnsString.str, nameMdnsString.length,
+                                          answer, nullptr, 0, additional.constData(), additional.length());
+            } else {
+                mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, nullptr, 0,
+                                            additional.constData(), additional.length());
+            }
+        }
+    } // else request is not for me
+    return 0;
+}
+
+// Open sockets to listen to incoming mDNS queries on port 5353
+// When recieving, each socket can recieve data from all network interfaces
+// Thus we only need to open one socket for each address family
+int Announcer::listenForQueries()
+{
+    auto callback = [this](QSocketDescriptor socket) {
+        static char buffer[2048];
+        mdns_socket_listen(socket, buffer, sizeof(buffer), service_callback, &self);
+    };
+
+    int numSockets = 0;
+
+    {
+        struct sockaddr_in sock_addr;
+        memset(&sock_addr, 0, sizeof(struct sockaddr_in));
+        sock_addr.sin_family = AF_INET;
+#ifdef _WIN32
+        sock_addr.sin_addr = in4addr_any;
+#else
+        sock_addr.sin_addr.s_addr = INADDR_ANY;
+#endif
+        sock_addr.sin_port = htons(MDNS_PORT);
+#ifdef __APPLE__
+        sock_addr.sin_len = sizeof(struct sockaddr_in);
+#endif
+        int socket = mdns_socket_open_ipv4(&sock_addr);
+        if (socket >= 0) {
+            socketNotifier = new QSocketNotifier(socket, QSocketNotifier::Read);
+            QObject::connect(socketNotifier, &QSocketNotifier::activated, callback);
+            numSockets++;
+        }
+    }
+
+    {
+        struct sockaddr_in6 sock_addr;
+        memset(&sock_addr, 0, sizeof(struct sockaddr_in6));
+        sock_addr.sin6_family = AF_INET6;
+        sock_addr.sin6_addr = in6addr_any;
+        sock_addr.sin6_port = htons(MDNS_PORT);
+#ifdef __APPLE__
+        sock_addr.sin6_len = sizeof(struct sockaddr_in6);
+#endif
+        int socket = mdns_socket_open_ipv6(&sock_addr);
+        if (socket >= 0) {
+            socketNotifierV6 = new QSocketNotifier(socket, QSocketNotifier::Read);
+            QObject::connect(socketNotifierV6, &QSocketNotifier::activated, callback);
+            numSockets++;
+        }
+    }
+
+    return numSockets;
+}
+
+Announcer::Announcer(const QString &serviceName, const QString &serviceType, uint16_t port)
+{
+    self.serviceType = serviceType.toLatin1();
+    if (!self.serviceType.endsWith('.')) {
+        // mdns.h needs all the qualified names to end with dot for some reason
+        self.serviceType.append('.');
+    }
+    self.serviceInstance = serviceName.toLatin1() + '.' + self.serviceType;
+    self.hostname = QHostInfo::localHostName().toLatin1() + ".local.";
+    self.port = port;
+    detectHostAddresses();
+}
+
+void Announcer::detectHostAddresses()
+{
+    self.addressesV4.clear();
+    self.addressesV6.clear();
+    for (const QNetworkInterface &iface : QNetworkInterface::allInterfaces()) {
+        int flags = iface.flags();
+        if (!(flags & QNetworkInterface::IsUp) || !(flags & QNetworkInterface::CanMulticast) || (flags & QNetworkInterface::IsLoopBack)) {
+            continue;
+        }
+        for (const QNetworkAddressEntry &ifaceAddress : iface.addressEntries()) {
+            QHostAddress sourceAddress = ifaceAddress.ip();
+            if (sourceAddress.protocol() == QAbstractSocket::IPv4Protocol && sourceAddress != QHostAddress::LocalHost) {
+                self.addressesV4.append(sourceAddress);
+            } else if (sourceAddress.protocol() == QAbstractSocket::IPv6Protocol && sourceAddress != QHostAddress::LocalHostIPv6) {
+                self.addressesV6.append(sourceAddress);
+            }
+        }
+    }
+}
+
+void Announcer::startAnnouncing()
+{
+    int num_sockets = listenForQueries();
+    if (num_sockets <= 0) {
+        qCWarning(KDECONNECT_CORE) << "Failed to open any MDNS client sockets";
+        return;
+    }
+    sendMulticastAnnounce(false);
+}
+
+void Announcer::stopAnnouncing()
+{
+    sendMulticastAnnounce(true);
+    stopListeningForQueries();
+}
+
+void Announcer::stopListeningForQueries()
+{
+    if (socketNotifier != nullptr) {
+        delete socketNotifier;
+        socketNotifier = nullptr;
+    }
+    if (socketNotifierV6 != nullptr) {
+        delete socketNotifierV6;
+        socketNotifierV6 = nullptr;
+    }
+}
+
+void Announcer::sendMulticastAnnounce(bool isGoodbye)
+{
+    mdns_record_t ptr_record = createMdnsRecord(self, MDNS_RECORDTYPE_PTR);
+
+    QVector<mdns_record_t> additional;
+    additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_SRV));
+    if (!self.addressesV4.empty()) {
+        additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_A));
+    }
+    if (!self.addressesV6.empty()) {
+        additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_AAAA));
+    }
+
+    for (auto txtIterator = self.txtRecords.cbegin(); txtIterator != self.txtRecords.cend(); txtIterator++) {
+        additional.append(createMdnsRecord(self, MDNS_RECORDTYPE_TXT, nullptr, txtIterator));
+    }
+
+    static char buffer[2048];
+    if (isGoodbye) {
+        qCDebug(KDECONNECT_CORE) << "Sending goodbye";
+        if (socketNotifier)
+            mdns_goodbye_multicast(socketNotifier->socket(), buffer, sizeof(buffer), ptr_record, nullptr, 0, additional.constData(), additional.length());
+        if (socketNotifierV6)
+            mdns_goodbye_multicast(socketNotifierV6->socket(), buffer, sizeof(buffer), ptr_record, nullptr, 0, additional.constData(), additional.length());
+    } else {
+        qCDebug(KDECONNECT_CORE) << "Sending announce";
+        if (socketNotifier)
+            mdns_announce_multicast(socketNotifier->socket(), buffer, sizeof(buffer), ptr_record, nullptr, 0, additional.constData(), additional.length());
+        if (socketNotifierV6)
+            mdns_announce_multicast(socketNotifierV6->socket(), buffer, sizeof(buffer), ptr_record, nullptr, 0, additional.constData(), additional.length());
+    }
+}
+
+} // namespace MdnsWrapper

core/backends/lan/mdns_wrapper.h

@@ -0,0 +1,100 @@
+/**
+ * SPDX-FileCopyrightText: 2023 Albert Vaca Cintora <albertvaka@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+ */
+
+#ifndef KDECONNECT_MDNS_WRAPPER_H
+#define KDECONNECT_MDNS_WRAPPER_H
+
+#include <QHostAddress>
+#include <QMap>
+#include <QSocketNotifier>
+#include <QString>
+#include <QVector>
+
+/*
+ * A Qt wrapper for the mdns.h header-only library
+ * from https://github.com/mjansson/mdns
+ */
+namespace MdnsWrapper
+{
+
+class Discoverer : public QObject
+{
+    Q_OBJECT
+
+public:
+    struct MdnsService {
+        QString name;
+        uint16_t port;
+        QHostAddress address;
+        QMap<QString, QString> txtRecords;
+    };
+
+    // serviceType must be of the form "_<name>._<tcp/udp>.local"
+    void startDiscovering(const QString &serviceType);
+    void stopDiscovering();
+
+    void sendQuery(const QString &serviceName);
+
+Q_SIGNALS:
+    void serviceFound(const MdnsWrapper::Discoverer::MdnsService &service);
+
+private:
+    int listenForQueryResponses();
+    void stopListeningForQueryResponses();
+
+    QVector<QSocketNotifier *> responseSocketNotifiers;
+};
+
+class Announcer : public QObject
+{
+    Q_OBJECT
+
+public:
+    struct AnnouncedInfo {
+        QByteArray serviceType; // ie: "<_service-type>._tcp.local."
+        QByteArray serviceInstance; // ie: "<service-name>.<_service-type>._tcp.local."
+        QByteArray hostname; // ie: "<hostname>.local."
+        QVector<QHostAddress> addressesV4;
+        QVector<QHostAddress> addressesV6;
+        uint16_t port;
+        QHash<QByteArray, QByteArray> txtRecords;
+    };
+
+    // serviceType must be of the form "_<name>._<tcp/udp>.local"
+    Announcer(const QString &serviceName, const QString &serviceType, uint16_t port);
+
+    void putTxtRecord(const QString &key, const QString &value)
+    {
+        self.txtRecords[key.toLatin1()] = value.toLatin1();
+    }
+
+    void startAnnouncing();
+    void stopAnnouncing();
+
+    void sendMulticastAnnounce(bool isGoodbye);
+
+public Q_SLOTS:
+    // notify that network interfaces changed since the creation of this Announcer
+    void onNetworkChange()
+    {
+        detectHostAddresses();
+    }
+
+private:
+    int listenForQueries();
+    void stopListeningForQueries();
+
+    void detectHostAddresses();
+
+    AnnouncedInfo self;
+
+    QSocketNotifier *socketNotifier = nullptr;
+    QSocketNotifier *socketNotifierV6 = nullptr;
+};
+
+} // namespace MdnsWrapper
+
+#endif

core/backends/lan/mdnsdiscovery.cpp

@@ -10,26 +10,28 @@
 #include "kdeconnectconfig.h"
 #include "lanlinkprovider.h"
 
-#include <KDNSSD/PublicService>
+#include "mdns_wrapper.h"
-#include <KDNSSD/RemoteService>
-#include <KDNSSD/ServiceBrowser>
 
-const QString kServiceName = QStringLiteral("_kdeconnect._udp");
+const QString kServiceType = QStringLiteral("_kdeconnect._udp.local");
 
 MdnsDiscovery::MdnsDiscovery(LanLinkProvider *lanLinkProvider)
     : lanLinkProvider(lanLinkProvider)
+    , mdnsAnnouncer(KdeConnectConfig::instance().deviceId(), kServiceType, LanLinkProvider::UDP_PORT)
 {
-    switch (KDNSSD::ServiceBrowser::isAvailable()) {
+    KdeConnectConfig &config = KdeConnectConfig::instance();
-    case KDNSSD::ServiceBrowser::Stopped:
+    mdnsAnnouncer.putTxtRecord(QStringLiteral("id"), config.deviceId());
-        qCWarning(KDECONNECT_CORE) << "mDNS or Avahi daemons are not running, mDNS discovery not available";
+    mdnsAnnouncer.putTxtRecord(QStringLiteral("name"), config.name());
-        break;
+    mdnsAnnouncer.putTxtRecord(QStringLiteral("type"), config.deviceType().toString());
-    case KDNSSD::ServiceBrowser::Working:
+    mdnsAnnouncer.putTxtRecord(QStringLiteral("protocol"), QString::number(NetworkPacket::s_protocolVersion));
-        qCDebug(KDECONNECT_CORE) << "mDNS discovery is available";
+
-        break;
+    connect(&mdnsDiscoverer, &MdnsWrapper::Discoverer::serviceFound, [lanLinkProvider](const MdnsWrapper::Discoverer::MdnsService &service) {
-    case KDNSSD::ServiceBrowser::Unsupported:
+        if (KdeConnectConfig::instance().deviceId() == service.name) {
-        qCWarning(KDECONNECT_CORE) << "mDNS discovery not available (library built without DNS-SD support)";
+            qCDebug(KDECONNECT_CORE) << "Discovered myself, ignoring";
-        break;
+            return;
         }
+        lanLinkProvider->sendUdpIdentityPacket(QList<QHostAddress>{service.address});
+        qCDebug(KDECONNECT_CORE) << "Discovered" << service.name << "at" << service.address;
+    });
 }
 
 MdnsDiscovery::~MdnsDiscovery()
@@ -40,83 +42,22 @@ MdnsDiscovery::~MdnsDiscovery()
 
 void MdnsDiscovery::startAnnouncing()
 {
-    if (m_publisher != nullptr) {
+    mdnsAnnouncer.startAnnouncing();
-        qCDebug(KDECONNECT_CORE) << "MDNS already announcing";
-        return;
-    }
-    qCDebug(KDECONNECT_CORE) << "MDNS start announcing";
-
-    KdeConnectConfig &config = KdeConnectConfig::instance();
-
-    m_publisher = new KDNSSD::PublicService(config.deviceId(), kServiceName, LanLinkProvider::UDP_PORT, QStringLiteral("local"));
-    m_publisher->setParent(this);
-
-    // We can't fit the device certificate in this field, so this is not enough info to create a Device and won't be used.
-    QMap<QString, QByteArray> data;
-    data[QStringLiteral("id")] = config.deviceId().toUtf8();
-    data[QStringLiteral("name")] = config.name().toUtf8();
-    data[QStringLiteral("type")] = config.deviceType().toString().toUtf8();
-    data[QStringLiteral("protocol")] = QString::number(NetworkPacket::s_protocolVersion).toUtf8();
-    m_publisher->setTextData(data);
-
-    connect(m_publisher, &KDNSSD::PublicService::published, [](bool successful) {
-        if (successful) {
-            qCDebug(KDECONNECT_CORE) << "MDNS published successfully";
-        } else {
-            qCWarning(KDECONNECT_CORE) << "MDNS failed to publish";
-        }
-    });
-
-    m_publisher->publishAsync();
 }
 
 void MdnsDiscovery::stopAnnouncing()
 {
-    if (m_publisher != nullptr) {
+    mdnsAnnouncer.stopAnnouncing();
-        qCDebug(KDECONNECT_CORE) << "MDNS stop announcing";
-        delete m_publisher;
-        m_publisher = nullptr;
-    }
 }
 
 void MdnsDiscovery::startDiscovering()
 {
-    if (m_serviceBrowser != nullptr) {
+    mdnsDiscoverer.startDiscovering(kServiceType);
-        qCDebug(KDECONNECT_CORE) << "MDNS already discovering";
-        return;
-    }
-    qCDebug(KDECONNECT_CORE) << "MDNS start discovering";
-
-    m_serviceBrowser = new KDNSSD::ServiceBrowser(kServiceName, true);
-
-    connect(m_serviceBrowser, &KDNSSD::ServiceBrowser::serviceAdded, [this](KDNSSD::RemoteService::Ptr service) {
-        if (KdeConnectConfig::instance().deviceId() == service->serviceName()) {
-            qCDebug(KDECONNECT_CORE) << "Discovered myself, ignoring";
-            return;
-        }
-        qCDebug(KDECONNECT_CORE) << "Discovered " << service->serviceName() << " at " << service->hostName();
-        QHostAddress address(service->hostName());
-        lanLinkProvider->sendUdpIdentityPacket(QList<QHostAddress>{address});
-    });
-
-    connect(m_serviceBrowser, &KDNSSD::ServiceBrowser::serviceRemoved, [](KDNSSD::RemoteService::Ptr service) {
-        qCDebug(KDECONNECT_CORE) << "Lost " << service->serviceName();
-    });
-
-    connect(m_serviceBrowser, &KDNSSD::ServiceBrowser::finished, []() {
-        qCDebug(KDECONNECT_CORE) << "Finished discovery";
-    });
-
-    m_serviceBrowser->startBrowse();
 }
 
 void MdnsDiscovery::stopDiscovering()
 {
-    if (m_serviceBrowser != nullptr) {
+    mdnsDiscoverer.stopDiscovering();
-        qCDebug(KDECONNECT_CORE) << "MDNS stop discovering";
-        delete m_serviceBrowser;
-        m_serviceBrowser = nullptr;
-    }
 }
 
 #include "moc_mdnsdiscovery.cpp"

core/backends/lan/mdnsdiscovery.h

@@ -11,12 +11,9 @@
 
 #include "kdeconnectcore_export.h"
 
+#include "mdns_wrapper.h"
+
 class LanLinkProvider;
-namespace KDNSSD
-{
-class PublicService;
-class ServiceBrowser;
-};
 
 class KDECONNECTCORE_EXPORT MdnsDiscovery : public QObject
 {
@@ -32,10 +29,16 @@ public:
     void stopAnnouncing();
     void startAnnouncing();
 
+public Q_SLOTS:
+    void onNetworkChange()
+    {
+        mdnsAnnouncer.onNetworkChange();
+    }
+
 private:
     LanLinkProvider *lanLinkProvider = nullptr;
-    KDNSSD::PublicService *m_publisher = nullptr;
+    MdnsWrapper::Discoverer mdnsDiscoverer;
-    KDNSSD::ServiceBrowser *m_serviceBrowser = nullptr;
+    MdnsWrapper::Announcer mdnsAnnouncer;
 };
 
 #endif // KDECONNECT_SERVER_H