File indexing completed on 2024-04-28 15:22:05

 /*
     This file is part of the KDE project
 
     SPDX-FileCopyrightText: 2004, 2005 Jakub Stachowski <qbast@go2.pl>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "avahi-publicservice_p.h"
 
 #include <QCoreApplication>
 #include <QStringList>
 
 #include "publicservice.h"
 
 #include <config-kdnssd.h>
 #if HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 #include "avahi_entrygroup_interface.h"
 #include "avahi_server_interface.h"
 #include "servicebrowser.h"
 
 namespace KDNSSD
 {
 PublicService::PublicService(const QString &name, const QString &type, unsigned int port, const QString &domain, const QStringList &subtypes)
     : QObject()
     , ServiceBase(new PublicServicePrivate(this, name, type, domain, port))
 {
     KDNSSD_D;
     if (domain.isNull()) {
         d->m_domain = "local.";
     }
     d->m_subtypes = subtypes;
 }
 
 PublicService::~PublicService()
 {
     stop();
 }
 
 void PublicServicePrivate::tryApply()
 {
     if (fillEntryGroup()) {
         commit();
     } else {
         m_parent->stop();
         Q_EMIT m_parent->published(false);
     }
 }
 
 void PublicServicePrivate::gotGlobalStateChanged(int state, const QString &error, QDBusMessage msg)
 {
     if (!isOurMsg(msg)) {
         return;
     }
     groupStateChanged(state, error);
 }
 
 void PublicService::setServiceName(const QString &serviceName)
 {
     KDNSSD_D;
     d->m_serviceName = serviceName;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 void PublicService::setDomain(const QString &domain)
 {
     KDNSSD_D;
     d->m_domain = domain;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 void PublicService::setType(const QString &type)
 {
     KDNSSD_D;
     d->m_type = type;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 void PublicService::setSubTypes(const QStringList &subtypes)
 {
     KDNSSD_D;
     d->m_subtypes = subtypes;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 QStringList PublicService::subtypes() const
 {
     KDNSSD_D;
     return d->m_subtypes;
 }
 
 void PublicService::setPort(unsigned short port)
 {
     KDNSSD_D;
     d->m_port = port;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 void PublicService::setTextData(const QMap<QString, QByteArray> &textData)
 {
     KDNSSD_D;
     d->m_textData = textData;
     if (d->m_running) {
         d->m_group->Reset();
         d->tryApply();
     }
 }
 
 bool PublicService::isPublished() const
 {
     KDNSSD_D;
     return d->m_published;
 }
 
 bool PublicService::publish()
 {
     KDNSSD_D;
     publishAsync();
     while (d->m_running && !d->m_published) {
         QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
     }
     return d->m_published;
 }
 
 void PublicService::stop()
 {
     KDNSSD_D;
     if (d->m_group) {
         d->m_group->Reset();
     }
     d->m_running = false;
     d->m_published = false;
 }
 bool PublicServicePrivate::fillEntryGroup()
 {
     registerTypes();
     if (!m_group) {
         // Do not race!
         // https://github.com/lathiat/avahi/issues/9
         // Avahi's DBus API is incredibly racey with signals getting fired
         // immediately after a request was made even though we may not yet be
         // listening. In lieu of a proper upstream fix for this we'll unfortunately
         // have to resort to this hack:
         // We register to all signals regardless of path and then filter them once
         // we know what "our" path is. This is much more fragile than a proper
         // QDBusInterface assisted signal connection but unfortunately the only way
         // we can reliably prevent signals getting lost in the race.
         // This uses a fancy trick whereby using QDBusMessage as last argument will
         // give us the correct signal argument types as well as the underlying
         // message so that we may check the message path.
         QDBusConnection::systemBus().connect("org.freedesktop.Avahi",
                                              "",
                                              "org.freedesktop.Avahi.EntryGroup",
                                              "StateChanged",
                                              this,
                                              SLOT(gotGlobalStateChanged(int, QString, QDBusMessage)));
         m_dbusObjectPath.clear();
 
         QDBusReply<QDBusObjectPath> rep = m_server->EntryGroupNew();
         if (!rep.isValid()) {
             return false;
         }
 
         m_dbusObjectPath = rep.value().path();
 
         m_group = new org::freedesktop::Avahi::EntryGroup("org.freedesktop.Avahi", m_dbusObjectPath, QDBusConnection::systemBus());
     }
     if (m_serviceName.isNull()) {
         QDBusReply<QString> rep = m_server->GetHostName();
         if (!rep.isValid()) {
             return false;
         }
         m_serviceName = rep.value();
     }
 
     QList<QByteArray> txt;
     QMap<QString, QByteArray>::ConstIterator itEnd = m_textData.constEnd();
     for (QMap<QString, QByteArray>::ConstIterator it = m_textData.constBegin(); it != itEnd; ++it)
         if (it.value().isNull()) {
             txt.append(it.key().toLatin1());
         } else {
             txt.append(it.key().toLatin1() + '=' + it.value());
         }
 
     for (;;) {
         QDBusReply<void> ret = m_group->AddService(-1, -1, 0, m_serviceName, m_type, domainToDNS(m_domain), m_hostName, m_port, txt);
         if (ret.isValid()) {
             break;
         }
 
         // serious error, bail out
         if (ret.error().name() != QLatin1String("org.freedesktop.Avahi.CollisionError")) {
             return false;
         }
 
         // name collision, try another
         QDBusReply<QString> rep = m_server->GetAlternativeServiceName(m_serviceName);
         if (rep.isValid()) {
             m_serviceName = rep.value();
         } else {
             return false;
         }
     }
 
     for (const QString &subtype : std::as_const(m_subtypes)) {
         m_group->AddServiceSubtype(-1, -1, 0, m_serviceName, m_type, domainToDNS(m_domain), subtype);
     }
     return true;
 }
 
 void PublicServicePrivate::serverStateChanged(int s, const QString &)
 {
     if (!m_running) {
         return;
     }
     switch (s) {
     case AVAHI_SERVER_INVALID:
         m_parent->stop();
         Q_EMIT m_parent->published(false);
         break;
     case AVAHI_SERVER_REGISTERING:
     case AVAHI_SERVER_COLLISION:
         if (m_group) {
             m_group->Reset();
         }
         m_collision = true;
         break;
     case AVAHI_SERVER_RUNNING:
         if (m_collision) {
             m_collision = false;
             tryApply();
         }
     }
 }
 
 void PublicService::publishAsync()
 {
     KDNSSD_D;
     if (d->m_running) {
         stop();
     }
 
     if (!d->m_server) {
         d->m_server = new org::freedesktop::Avahi::Server(QStringLiteral("org.freedesktop.Avahi"), QStringLiteral("/"), QDBusConnection::systemBus());
         connect(d->m_server, SIGNAL(StateChanged(int, QString)), d, SLOT(serverStateChanged(int, QString)));
     }
 
     int state = AVAHI_SERVER_INVALID;
     QDBusReply<int> rep = d->m_server->GetState();
 
     if (rep.isValid()) {
         state = rep.value();
     }
     d->m_running = true;
     d->m_collision = true; // make it look like server is getting out of collision to force registering
     d->serverStateChanged(state, QString());
 }
 
 void PublicServicePrivate::groupStateChanged(int s, const QString &reason)
 {
     switch (s) {
     case AVAHI_ENTRY_GROUP_COLLISION: {
         QDBusReply<QString> rep = m_server->GetAlternativeServiceName(m_serviceName);
         if (rep.isValid()) {
             m_parent->setServiceName(rep.value());
         } else {
             serverStateChanged(AVAHI_SERVER_INVALID, reason);
         }
         break;
     }
     case AVAHI_ENTRY_GROUP_ESTABLISHED:
         m_published = true;
         Q_EMIT m_parent->published(true);
         break;
     case AVAHI_ENTRY_GROUP_FAILURE:
         serverStateChanged(AVAHI_SERVER_INVALID, reason);
         break;
     }
 }
 
 void PublicService::virtual_hook(int, void *)
 {
 }
 
 }
 
 #include "moc_avahi-publicservice_p.cpp"
 #include "moc_publicservice.cpp"