dnssd/avahi-publicservice.cpp

   1 /* This file is part of the KDE project
   2  *
   3  * Copyright (C) 2004, 2005 Jakub Stachowski <qbast@go2.pl>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "avahi-publicservice_p.h"
  22
  23 #include <QtCore/QCoreApplication>
  24 #include <QtCore/QStringList>
  25
  26 #include "publicservice.h"
  27 #ifdef HAVE_SYS_TYPES_H
  28 #include <sys/types.h>
  29 #endif
  30 #include "servicebrowser.h"
  31 #include "settings.h"
  32 #include "avahi_server_interface.h"
  33 #include "avahi_entrygroup_interface.h"
  34 #ifndef KDE_USE_FINAL
  35 Q_DECLARE_METATYPE(QList<QByteArray>)
  36 #endif
  37
  38 namespace DNSSD
  39 {
  40
  41 PublicService::PublicService(const QString& name, const QString& type, unsigned int port,
  42                               const QString& domain, const QStringList& subtypes)
  43                 : QObject(), ServiceBase(new PublicServicePrivate(this, name, type, domain, port))
  44 {
  45         K_D;
  46         if (domain.isNull()) d->m_domain="local.";
  47         d->m_subtypes=subtypes;
  48 }
  49
  50
  51 PublicService::~PublicService()
  52 {
  53     stop();
  54 }
  55
  56 void PublicServicePrivate::tryApply()
  57 {
  58     if (fillEntryGroup()) commit();
  59     else {
  60         m_parent->stop();
  61         emit m_parent->published(false);
  62     }
  63 }
  64
  65 void PublicService::setServiceName(const QString& serviceName)
  66 {
  67         K_D;
  68         d->m_serviceName = serviceName;
  69         if (d->m_running) {
  70             d->m_group->Reset();
  71             d->tryApply();
  72         }
  73 }
  74
  75 void PublicService::setDomain(const QString& domain)
  76 {
  77         K_D;
  78         d->m_domain = domain;
  79         if (d->m_running) {
  80             d->m_group->Reset();
  81             d->tryApply();
  82         }
  83 }
  84
  85
  86 void PublicService::setType(const QString& type)
  87 {
  88         K_D;
  89         d->m_type = type;
  90         if (d->m_running) {
  91             d->m_group->Reset();
  92             d->tryApply();
  93         }
  94 }
  95
  96 void PublicService::setSubTypes(const QStringList& subtypes)
  97 {
  98         K_D;
  99         d->m_subtypes = subtypes;
 100         if (d->m_running) {
 101             d->m_group->Reset();
 102             d->tryApply();
 103         }
 104 }
 105
 106 QStringList PublicService::subtypes() const
 107 {
 108         K_D;
 109         return d->m_subtypes;
 110 }
 111
 112 void PublicService::setPort(unsigned short port)
 113 {
 114         K_D;
 115         d->m_port = port;
 116         if (d->m_running) {
 117             d->m_group->Reset();
 118             d->tryApply();
 119         }
 120 }
 121
 122 void PublicService::setTextData(const QMap<QString,QByteArray>& textData)
 123 {
 124         K_D;
 125         d->m_textData = textData;
 126         if (d->m_running) {
 127             d->m_group->Reset();
 128             d->tryApply();
 129         }
 130 }
 131
 132 bool PublicService::isPublished() const
 133 {
 134         K_D;
 135         return d->m_published;
 136 }
 137
 138 bool PublicService::publish()
 139 {
 140         K_D;
 141         publishAsync();
 142         while (d->m_running && !d->m_published) QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 143         return d->m_published;
 144 }
 145
 146 void PublicService::stop()
 147 {
 148         K_D;
 149         if (d->m_group) d->m_group->Reset();
 150         d->m_published = false;
 151 }
 152 bool PublicServicePrivate::fillEntryGroup()
 153 {
 154     registerTypes();
 155     if (!m_group) {
 156         QDBusReply<QDBusObjectPath> rep=m_server->EntryGroupNew();
 157         if (!rep.isValid()) return false;
 158         m_group=new org::freedesktop::Avahi::EntryGroup("org.freedesktop.Avahi",rep.value().path(), QDBusConnection::systemBus());
 159         connect(m_group,SIGNAL(StateChanged(int,const QString&)), this, SLOT(groupStateChanged(int,const QString&)));
 160     }
 161     if (m_serviceName.isNull()) {
 162         QDBusReply<QString> rep=m_server->GetHostName();
 163         if (!rep.isValid()) return false;
 164         m_serviceName=rep.value();
 165     }
 166
 167     QList<QByteArray> txt;
 168     QMap<QString,QByteArray>::ConstIterator itEnd = m_textData.end();
 169     for (QMap<QString,QByteArray>::ConstIterator it = m_textData.begin(); it!=itEnd ; ++it)
 170         if (it.value().isNull()) txt.append(it.key().toAscii());
 171         else txt.append(it.key().toAscii()+'='+it.value());
 172     m_group->AddService(-1,-1, 0, m_serviceName, m_type , domainToDNS(m_domain) ,
 173         m_hostName, m_port,txt);
 174     Q_FOREACH(const QString &subtype, m_subtypes)
 175         m_group->AddServiceSubtype(-1,-1, 0, m_serviceName, m_type, domainToDNS(m_domain) , subtype);
 176     return true;
 177 }
 178
 179 void PublicServicePrivate::serverStateChanged(int s,const QString&)
 180 {
 181     if (!m_running) return;
 182     switch (s) {
 183         case AVAHI_SERVER_INVALID:
 184             m_parent->stop();
 185             emit m_parent->published(false);
 186             break;
 187         case AVAHI_SERVER_REGISTERING:
 188         case AVAHI_SERVER_COLLISION:
 189             m_group->Reset();
 190             m_collision=true;
 191             break;
 192         case AVAHI_SERVER_RUNNING:
 193             if (m_collision) {
 194                 m_collision=false;
 195                 tryApply();
 196             }
 197     }
 198 }
 199
 200 void PublicService::publishAsync()
 201 {
 202         K_D;
 203         if (d->m_running) stop();
 204
 205         if (!d->m_server) {
 206             d->m_server = new org::freedesktop::Avahi::Server("org.freedesktop.Avahi","/",QDBusConnection::systemBus());
 207             connect(d->m_server,SIGNAL(StateChanged(int,const QString&)),d,SLOT(serverStateChanged(int,const QString&)));
 208         }
 209
 210         int state=AVAHI_SERVER_INVALID;
 211         QDBusReply<int> rep=d->m_server->GetState();
 212
 213         if (rep.isValid()) state=rep.value();
 214
 215         d->m_running=true;
 216         d->m_collision=true; // make it look like server is getting out of collision to force registering
 217         d->serverStateChanged(state, QString());
 218 }
 219
 220
 221 void PublicServicePrivate::groupStateChanged(int s,  const QString& reason)
 222 {
 223     switch (s) {
 224     case AVAHI_ENTRY_GROUP_COLLISION: {
 225             QDBusReply<QString> rep=m_server->GetAlternativeServiceName(m_serviceName);
 226             if (rep.isValid())  m_parent->setServiceName(rep.value());
 227             else serverStateChanged(AVAHI_SERVER_INVALID, reason);
 228             break;
 229             }
 230     case AVAHI_ENTRY_GROUP_ESTABLISHED:
 231             m_published=true;
 232             emit m_parent->published(true);
 233             break;
 234     case AVAHI_ENTRY_GROUP_FAILURE:
 235             serverStateChanged(AVAHI_SERVER_INVALID, reason);
 236     default:
 237         break;
 238     }
 239 }
 240
 241 void PublicService::virtual_hook(int, void*)
 242 {
 243 }
 244
 245
 246 }
 247
 248 #include "publicservice.moc"
 249 #include "avahi-publicservice_p.moc"