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
This commit is contained in:
Albert Vaca Cintora
parent
132ae2ca7c
commit
3485e3aa44
8 changed files with 2350 additions and 91 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ if (MDNS_ENABLED)
|
|||
set(backends_kdeconnect_SRCS
|
||||
${backends_kdeconnect_SRCS}
|
||||
backends/lan/mdnsdiscovery.cpp
|
||||
backends/lan/mdns_wrapper.cpp
|
||||
)
|
||||
endif()
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
1618
core/backends/lan/mdns.h
Normal file
1618
core/backends/lan/mdns.h
Normal file
File diff suppressed because it is too large
Load diff
594
core/backends/lan/mdns_wrapper.cpp
Normal file
594
core/backends/lan/mdns_wrapper.cpp
Normal file
|
|
@ -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
|
||||
100
core/backends/lan/mdns_wrapper.h
Normal file
100
core/backends/lan/mdns_wrapper.h
Normal file
|
|
@ -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
|
||||
|
|
@ -10,26 +10,28 @@
|
|||
#include "kdeconnectconfig.h"
|
||||
#include "lanlinkprovider.h"
|
||||
|
||||
#include <KDNSSD/PublicService>
|
||||
#include <KDNSSD/RemoteService>
|
||||
#include <KDNSSD/ServiceBrowser>
|
||||
#include "mdns_wrapper.h"
|
||||
|
||||
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()) {
|
||||
case KDNSSD::ServiceBrowser::Stopped:
|
||||
qCWarning(KDECONNECT_CORE) << "mDNS or Avahi daemons are not running, mDNS discovery not available";
|
||||
break;
|
||||
case KDNSSD::ServiceBrowser::Working:
|
||||
qCDebug(KDECONNECT_CORE) << "mDNS discovery is available";
|
||||
break;
|
||||
case KDNSSD::ServiceBrowser::Unsupported:
|
||||
qCWarning(KDECONNECT_CORE) << "mDNS discovery not available (library built without DNS-SD support)";
|
||||
break;
|
||||
KdeConnectConfig &config = KdeConnectConfig::instance();
|
||||
mdnsAnnouncer.putTxtRecord(QStringLiteral("id"), config.deviceId());
|
||||
mdnsAnnouncer.putTxtRecord(QStringLiteral("name"), config.name());
|
||||
mdnsAnnouncer.putTxtRecord(QStringLiteral("type"), config.deviceType().toString());
|
||||
mdnsAnnouncer.putTxtRecord(QStringLiteral("protocol"), QString::number(NetworkPacket::s_protocolVersion));
|
||||
|
||||
connect(&mdnsDiscoverer, &MdnsWrapper::Discoverer::serviceFound, [lanLinkProvider](const MdnsWrapper::Discoverer::MdnsService &service) {
|
||||
if (KdeConnectConfig::instance().deviceId() == service.name) {
|
||||
qCDebug(KDECONNECT_CORE) << "Discovered myself, ignoring";
|
||||
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) {
|
||||
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();
|
||||
mdnsAnnouncer.startAnnouncing();
|
||||
}
|
||||
|
||||
void MdnsDiscovery::stopAnnouncing()
|
||||
{
|
||||
if (m_publisher != nullptr) {
|
||||
qCDebug(KDECONNECT_CORE) << "MDNS stop announcing";
|
||||
delete m_publisher;
|
||||
m_publisher = nullptr;
|
||||
}
|
||||
mdnsAnnouncer.stopAnnouncing();
|
||||
}
|
||||
|
||||
void MdnsDiscovery::startDiscovering()
|
||||
{
|
||||
if (m_serviceBrowser != nullptr) {
|
||||
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();
|
||||
mdnsDiscoverer.startDiscovering(kServiceType);
|
||||
}
|
||||
|
||||
void MdnsDiscovery::stopDiscovering()
|
||||
{
|
||||
if (m_serviceBrowser != nullptr) {
|
||||
qCDebug(KDECONNECT_CORE) << "MDNS stop discovering";
|
||||
delete m_serviceBrowser;
|
||||
m_serviceBrowser = nullptr;
|
||||
}
|
||||
mdnsDiscoverer.stopDiscovering();
|
||||
}
|
||||
|
||||
#include "moc_mdnsdiscovery.cpp"
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
KDNSSD::ServiceBrowser *m_serviceBrowser = nullptr;
|
||||
MdnsWrapper::Discoverer mdnsDiscoverer;
|
||||
MdnsWrapper::Announcer mdnsAnnouncer;
|
||||
};
|
||||
|
||||
#endif // KDECONNECT_SERVER_H
|
||||
|
|
|
|||
Loading…
Reference in a new issue