Compare commits

...

12 commits

Author SHA1 Message Date
Albert Vaca Cintora
665039055e Missing ifdef 2023-07-17 23:21:02 +02:00
Albert Vaca Cintora
cf87cdab8c Do not link KDNSSD 2023-07-17 23:18:20 +02:00
Albert Vaca Cintora
4fe4047b8e Formatting fixes 2023-07-17 23:09:58 +02:00
Albert Vaca Cintora
c7ce310299 WIP: IPv6 support 2023-07-17 23:06:44 +02:00
Albert Vaca Cintora
0a72020506 WIP: Return some ip in ip records 2023-07-17 23:06:35 +02:00
Albert Vaca Cintora
b682753f1b Fix windows build 2023-07-17 23:06:31 +02:00
Albert Vaca Cintora
c94215ce05 Rename things 2023-07-17 23:06:24 +02:00
Albert Vaca Cintora
bbf053ed5a WIP: Implement mdns server responses, missing a way to determine ip address 2023-07-17 23:06:20 +02:00
Albert Vaca Cintora
6ffc10f00a WIP: Continue to integrate with mdns.h 2023-07-17 23:06:11 +02:00
Albert Vaca Cintora
b8892f3860 Rename some stuff 2023-07-17 23:05:02 +02:00
Albert Vaca Cintora
0741a7db88 Add commented code to parse the fields we don't store 2023-07-17 23:04:58 +02:00
Albert Vaca Cintora
9a0b7ef78b WIP: Replacing 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
2023-07-17 23:04:39 +02:00
8 changed files with 2370 additions and 92 deletions

View file

@ -19,9 +19,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(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS DNSSD)
endif()
option(BLUETOOTH_ENABLED "Bluetooth support for kdeconnect" OFF)
if(BLUETOOTH_ENABLED)
@ -89,7 +86,6 @@ endif()
if (MDNS_ENABLED)
target_compile_definitions(kdeconnectcore PRIVATE -DKDECONNECT_MDNS)
target_link_libraries(kdeconnectcore PRIVATE KF5::DNSSD)
endif()
set_target_properties(kdeconnectcore PROPERTIES

View file

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

View file

@ -75,6 +75,9 @@ void LanLinkProvider::onNetworkConfigurationChanged(const QNetworkConfiguration
if (m_lastConfig != config && config.state() == QNetworkConfiguration::Active) {
m_lastConfig = config;
onNetworkChange();
#ifdef KDECONNECT_MDNS
m_mdnsDiscovery.onNetworkChange();
#endif
}
}
@ -184,7 +187,6 @@ void LanLinkProvider::broadcastUdpIdentityPacket()
#endif
}
QList<QHostAddress> LanLinkProvider::getBroadcastAddresses()
{
const QStringList customDevices = KdeConnectConfig::instance().customDevices();

1618
core/backends/lan/mdns.h Normal file

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,617 @@
/**
* 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) {
qWarning() << "Failed to open any client sockets";
return;
}
sendQuery(serviceType);
}
void Discoverer::stopDiscovering()
{
stopListeningForQueryResponses();
}
void Discoverer::stopListeningForQueryResponses()
{
qCDebug(KDECONNECT_CORE) << "Closing" << responseSocketNotifiers.size() << "sockets";
for (QSocketNotifier *socketNotifier : 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 : 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) {
qWarning() << "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) {
qWarning() << "Someone queried all services for" << recordTypeToStr(record_type);
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);
// Send the answer, unicast or multicast depending on flag in query
uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
printf(" --> answer %.*s (%s)\n", MDNS_STRING_FORMAT(answer.data.ptr.name), (unicast ? "unicast" : "multicast"));
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, NULL, 0, NULL, 0);
} else {
mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, 0, 0, 0, 0);
}
}
} else if (name == self.serviceType) {
qWarning() << "Someone queried my service type for" << recordTypeToStr(record_type);
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));
}
// Send the answer, unicast or multicast depending on flag in query
uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
printf(" --> answer %.*s (%s)\n", MDNS_STRING_FORMAT(answer.data.ptr.name), (unicast ? "unicast" : "multicast"));
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, 0, 0, additional.constData(), additional.length());
} else {
mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, 0, 0,
additional.constData(), additional.length());
}
}
} else if (name == self.serviceInstance) {
qWarning() << "Someone queried my service instance" << recordTypeToStr(record_type);
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));
}
// Send the answer, unicast or multicast depending on flag in query
uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
printf(" --> answer %.*s port %d (%s)\n", MDNS_STRING_FORMAT(answer.data.srv.name), answer.data.srv.port, (unicast ? "unicast" : "multicast"));
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, 0, 0, additional.constData(), additional.length());
} else {
mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, 0, 0,
additional.constData(), additional.length());
}
}
} else if (name == self.hostname) {
qWarning() << "Someone queried my host for" << recordTypeToStr(record_type);
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));
}
// Send the answer, unicast or multicast depending on flag in query
uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
printf(" --> answer %.*s IPv4 (%s)\n", MDNS_STRING_FORMAT(answer.name), (unicast ? "unicast" : "multicast"));
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, 0, 0, additional.constData(), additional.length());
} else {
mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, 0, 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));
}
// Send the answer, unicast or multicast depending on flag in query
uint16_t unicast = (rclass & MDNS_UNICAST_RESPONSE);
printf(" --> answer %.*s IPv6 (%s)\n", MDNS_STRING_FORMAT(answer.name), (unicast ? "unicast" : "multicast"));
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, 0, 0, additional.constData(), additional.length());
} else {
mdns_query_answer_multicast(sock, sendbuffer, sizeof(sendbuffer), answer, 0, 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()
{
qWarning() << "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) {
qWarning() << "Found ipv4" << sourceAddress;
self.addressesV4.append(sourceAddress);
} else if (sourceAddress.protocol() == QAbstractSocket::IPv6Protocol && sourceAddress != QHostAddress::LocalHostIPv6) {
qWarning() << "Found ipv6" << sourceAddress;
self.addressesV6.append(sourceAddress);
}
}
}
}
void Announcer::startAnnouncing()
{
int num_sockets = listenForQueries();
if (num_sockets <= 0) {
qWarning() << "Failed to open any 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, 0, 0, additional.constData(), additional.length());
if (socketNotifierV6)
mdns_goodbye_multicast(socketNotifierV6->socket(), buffer, sizeof(buffer), ptr_record, 0, 0, additional.constData(), additional.length());
} else {
qCDebug(KDECONNECT_CORE) << "Sending announce";
if (socketNotifier)
mdns_announce_multicast(socketNotifier->socket(), buffer, sizeof(buffer), ptr_record, 0, 0, additional.constData(), additional.length());
if (socketNotifierV6)
mdns_announce_multicast(socketNotifierV6->socket(), buffer, sizeof(buffer), ptr_record, 0, 0, additional.constData(), additional.length());
}
}
} // namespace MdnsWrapper

View 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 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

View file

@ -10,26 +10,28 @@
#include "kdeconnectconfig.h"
#include "lanlinkprovider.h"
#include <KDNSSD/DNSSD/PublicService>
#include <KDNSSD/DNSSD/RemoteService>
#include <KDNSSD/DNSSD/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,81 +42,20 @@ 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();
}

View file

@ -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