torcbonjour.cpp

Go to the documentation of this file.

/* Class TorcBonjour
*
* Copyright (C) Mark Kendall 2012-18
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

// Qt
#include <QCoreApplication>
#include <QtEndian>
#include <QMap>

// Torc
#include "torclogging.h"
#include "torcevent.h"
#include "torclocalcontext.h"
#include "torcadminthread.h"
#include "torcnetwork.h"
#include "torcbonjour.h"

// Std
#include <stdlib.h>
#include <arpa/inet.h>

TorcBonjour* gBonjour = nullptr;                            
QMutex*      gBonjourLock = new QMutex(QMutex::Recursive);  

void DNSSD_API BonjourRegisterCallback (DNSServiceRef        Ref,
                                        DNSServiceFlags      Flags,
                                        DNSServiceErrorType  Errorcode,
                                        const char          *Name,
                                        const char          *Type,
                                        const char          *Domain,
                                        void                *Object);
void DNSSD_API BonjourBrowseCallback   (DNSServiceRef        Ref,
                                        DNSServiceFlags      Flags,
                                        uint32_t             InterfaceIndex,
                                        DNSServiceErrorType  ErrorCode,
                                        const char          *Name,
                                        const char          *Type,
                                        const char          *Domain,
                                        void                *Object);
void DNSSD_API BonjourResolveCallback  (DNSServiceRef        Ref,
                                        DNSServiceFlags      Flags,
                                        uint32_t             InterfaceIndex,
                                        DNSServiceErrorType  ErrorCode,
                                        const char          *Fullname,
                                        const char          *HostTarget,
                                        uint16_t             Port,
                                        uint16_t             TxtLen,
                                        const unsigned char *TxtRecord,
                                        void                *Object);

TorcBonjourService::TorcBonjourService()
  : m_serviceType(Service),
    m_dnssRef(nullptr),
    m_name(QByteArray()),
    m_type(QByteArray()),
    m_txt(QByteArray()),
    m_domain(QByteArray()),
    m_interfaceIndex(0),
    m_host(QByteArray()),
    m_ipAddresses(QList<QHostAddress>()),
    m_port(0),
    m_lookupID(-1),
    m_fd(-1),
    m_socketNotifier(nullptr)
{
    // the default constructor only exists to keep QMap happy - it should never be used
    LOG(VB_GENERAL, LOG_WARNING, QStringLiteral("Invalid TorcBonjourService object"));
}

TorcBonjourService::TorcBonjourService(const TorcBonjourService &Other)
  : m_serviceType(Other.m_serviceType),
    m_dnssRef(Other.m_dnssRef),
    m_name(Other.m_name),
    m_type(Other.m_type),
    m_txt(Other.m_txt),
    m_domain(Other.m_domain),
    m_interfaceIndex(Other.m_interfaceIndex),
    m_host(Other.m_host),
    m_ipAddresses(Other.m_ipAddresses),
    m_port(0),             // NB
    m_lookupID(-1),        // NB
    m_fd(-1),              // NB
    m_socketNotifier(nullptr) // NB
{
}

TorcBonjourService& TorcBonjourService::operator =(const TorcBonjourService &Other)
{
    m_serviceType    = Other.m_serviceType;
    m_dnssRef        = Other.m_dnssRef;
    m_name           = Other.m_name;
    m_type           = Other.m_type;
    m_txt            = Other.m_txt;
    m_domain         = Other.m_domain;
    m_interfaceIndex = Other.m_interfaceIndex;
    m_host           = Other.m_host;
    m_ipAddresses    = Other.m_ipAddresses;
    m_port           = 0;    // NB
    m_lookupID       = -1;   // NB
    m_fd             = -1;   // NB
    m_socketNotifier = nullptr; // NB
    return *this;
}

TorcBonjourService::TorcBonjourService(ServiceType BonjourType, DNSServiceRef DNSSRef, const QByteArray &Name, const QByteArray &Type)
  : m_serviceType(BonjourType),
    m_dnssRef(DNSSRef),
    m_name(Name),
    m_type(Type),
    m_txt(QByteArray()),
    m_domain(QByteArray()),
    m_interfaceIndex(0),
    m_host(QByteArray()),
    m_ipAddresses(QList<QHostAddress>()),
    m_port(0),
    m_lookupID(-1),
    m_fd(-1),
    m_socketNotifier(nullptr)
{
}

TorcBonjourService::TorcBonjourService(ServiceType BonjourType,
                   const QByteArray &Name, const QByteArray &Type,
                   const QByteArray &Domain, uint32_t InterfaceIndex)
  : m_serviceType(BonjourType),
    m_dnssRef(nullptr),
    m_name(Name),
    m_type(Type),
    m_txt(QByteArray()),
    m_domain(Domain),
    m_interfaceIndex(InterfaceIndex),
    m_host(QByteArray()),
    m_ipAddresses(QList<QHostAddress>()),
    m_port(0),
    m_lookupID(-1),
    m_fd(-1),
    m_socketNotifier(nullptr)
{
}

void TorcBonjourService::SetFileDescriptor(int FileDescriptor, TorcBonjour *Object)
{
    if (FileDescriptor != -1 && Object)
    {
        m_fd = FileDescriptor;
        m_socketNotifier = new QSocketNotifier(FileDescriptor, QSocketNotifier::Read, Object);
        QObject::connect(m_socketNotifier, &QSocketNotifier::activated, Object, &TorcBonjour::socketReadyRead);
        m_socketNotifier->setEnabled(true);
    }
}

bool TorcBonjourService::IsResolved(void)
{
    return m_port && !m_ipAddresses.isEmpty();
}

void TorcBonjourService::Deregister(void)
{
    if (m_socketNotifier)
        m_socketNotifier->setEnabled(false);

    if (m_lookupID != -1)
    {
        LOG(VB_NETWORK, LOG_WARNING, QStringLiteral("Host lookup for '%1' is not finished - cancelling").arg(m_host.constData()));
        QHostInfo::abortHostLookup(m_lookupID);
        m_lookupID = -1;
    }

    if (m_dnssRef)
    {
        // Unregister
        if (m_serviceType == Browse)
        {
            LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Cancelling browse for '%1'")
                .arg(m_type.constData()));
        }
        else if (m_serviceType == Service)
        {
            LOG(VB_GENERAL, LOG_INFO,
                QStringLiteral("De-registering service '%1' on '%2'")
                .arg(m_type.constData(), m_name.constData()));
        }
        else if (m_serviceType == Resolve)
        {
            LOG(VB_NETWORK, LOG_INFO, QStringLiteral("Cancelling resolve for '%1'")
                .arg(m_type.constData()));
        }

        DNSServiceRefDeallocate(m_dnssRef);
        m_dnssRef = nullptr;
    }

    if (m_socketNotifier)
        m_socketNotifier->deleteLater();
    m_socketNotifier = nullptr;
}

void BonjourRegisterCallback(DNSServiceRef Ref, DNSServiceFlags Flags,
                     DNSServiceErrorType Errorcode,
                     const char *Name,   const char *Type,
                     const char *Domain, void *Object)
{
    (void)Ref;
    (void)Flags;
    (void)Domain;

    TorcBonjour *bonjour = static_cast<TorcBonjour*>(Object);
    if (kDNSServiceErr_NoError != Errorcode)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Callback Error: %1").arg(Errorcode));
    }
    else if (bonjour)
    {
        LOG(VB_GENERAL, LOG_INFO,
            QStringLiteral("Service registration complete: name '%1' type '%2'")
            .arg(QString::fromUtf8(Name), QString::fromUtf8(Type)));
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("BonjourRegisterCallback for unknown object."));
    }
}

void BonjourBrowseCallback(DNSServiceRef Ref, DNSServiceFlags Flags,
                           uint32_t InterfaceIndex,
                           DNSServiceErrorType ErrorCode, const char *Name,
                           const char *Type, const char *Domain, void *Object)
{
    TorcBonjour *bonjour = static_cast<TorcBonjour*>(Object);
    if (!bonjour)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Received browse callback for unknown object"));
        return;
    }

    if (ErrorCode != kDNSServiceErr_NoError)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Browse callback error"));
        return;
    }

    TorcBonjourService service(TorcBonjourService::Resolve, Name, Type, Domain, InterfaceIndex);
    if (Flags & kDNSServiceFlagsAdd)
        bonjour->AddBrowseResult(Ref, service);
    else
        bonjour->RemoveBrowseResult(Ref, service);

    if (!(Flags & kDNSServiceFlagsMoreComing))
    {
        // no idea
    }
}

void BonjourResolveCallback(DNSServiceRef Ref, DNSServiceFlags Flags,
                            uint32_t InterfaceIndex, DNSServiceErrorType ErrorCode,
                            const char *Fullname, const char *HostTarget,
                            uint16_t Port, uint16_t TxtLen,
                            const unsigned char *TxtRecord, void *Object)
{
    (void)Flags;
    (void) InterfaceIndex;

    TorcBonjour *bonjour = static_cast<TorcBonjour*>(Object);
    if (!bonjour)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Received resolve callback for unknown object"));
        return;
    }

    bonjour->Resolve(Ref, ErrorCode, Fullname, HostTarget, Port, TxtLen, TxtRecord);
}

TorcBonjour* TorcBonjour::Instance(void)
{
    QMutexLocker locker(gBonjourLock);
    if (gBonjour)
        return gBonjour;

    gBonjour = new TorcBonjour();
    return gBonjour;
}

void TorcBonjour::Suspend(bool Suspend)
{
    QMutexLocker locker(gBonjourLock);
    if (gBonjour)
        QMetaObject::invokeMethod(gBonjour, "SuspendPriv", Qt::AutoConnection, Q_ARG(bool, Suspend));
}

void TorcBonjour::TearDown(void)
{
    QMutexLocker locker(gBonjourLock);
    delete gBonjour;
    gBonjour = nullptr;
}

QByteArray TorcBonjour::MapToTxtRecord(const QMap<QByteArray, QByteArray> &Map)
{
    QByteArray result;

    QMap<QByteArray,QByteArray>::const_iterator it = Map.constBegin();
    for ( ; it != Map.constEnd(); ++it)
    {
        QByteArray record(1, it.key().size() + it.value().size() + 1);
        record.append(it.key() + "=" + it.value());
        result.append(record);
    }

    return result;
}

QMap<QByteArray,QByteArray> TorcBonjour::TxtRecordToMap(const QByteArray &TxtRecord)
{
    QMap<QByteArray,QByteArray> result;

    int position = 0;
    while (position < TxtRecord.size())
    {
        int size = TxtRecord[position++];
        QList<QByteArray> records = TxtRecord.mid(position, size).split('=');
        position += size;

        if (records.size() == 2)
            result.insert(records[0], records[1]);
    }

    return result;
}

TorcBonjour::TorcBonjour()
  : QObject(nullptr),
    m_suspended(false),
    m_serviceLock(QMutex::Recursive),
    m_services(QMap<quint32,TorcBonjourService>()),
    m_discoveredLock(QMutex::Recursive),
    m_discoveredServices(QMap<quint32,TorcBonjourService>())
{
    // the Avahi compatability layer on *nix will spam us with warnings
    qputenv("AVAHI_COMPAT_NOWARN", "1");

    // listen for network enabled/disabled events
    gLocalContext->AddObserver(this);
}

TorcBonjour::~TorcBonjour()
{
    // stop listening for network events
    gLocalContext->RemoveObserver(this);

    LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Closing Bonjour"));

    // deregister any outstanding services (should be empty)
    {
        QMutexLocker locker(&m_serviceLock);
        if (!m_suspended)
            foreach(TorcBonjourService service, m_services)
                service.Deregister();
        m_services.clear();
    }

    // deallocate resolve queries
    {
        QMutexLocker locker(&m_discoveredLock);
        foreach(TorcBonjourService service, m_discoveredServices)
            service.Deregister();
        m_discoveredServices.clear();
    }
}

quint32 TorcBonjour::Register(quint16 Port, const QByteArray &Type, const QByteArray &Name,
                              const QMap<QByteArray, QByteArray> &TxtRecords, quint32 Reference)
{
    QByteArray txt = MapToTxtRecord(TxtRecords);
    return Register(Port, Type, Name, txt, Reference);
}

quint32 TorcBonjour::Register(quint16 Port, const QByteArray &Type, const QByteArray &Name, const QByteArray &Txt, quint32 Reference)
{
    if (m_suspended)
    {
        QMutexLocker locker(&m_serviceLock);

        TorcBonjourService service(TorcBonjourService::Service, nullptr, Name, Type);
        service.m_txt  = Txt;
        service.m_port = Port;
        quint32 reference = Reference;
        // find a unique reference
        while (!reference || m_services.contains(reference))
            reference++;
        m_services.insert(reference, service);

        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Bonjour service registration deferred until Bonjour resumed"));
        return reference;
    }

    DNSServiceRef dnssref = nullptr;
    DNSServiceErrorType result = kDNSServiceErr_NameConflict;
    int tries = 0;

    // the avahi compatability layer doesn't appear to be automatically renaming as it should
    while (tries < 20 && kDNSServiceErr_NameConflict == result)
    {
        QByteArray name(Name);
        if (tries > 0)
            name.append(QStringLiteral(" [%1]").arg(tries + 1));
        result = DNSServiceRegister(&dnssref, 0,
                                    0, (const char*)name.constData(),
                                    (const char*)Type.constData(),
                                    nullptr, nullptr, htons(Port), Txt.size(), (void*)Txt.constData(),
                                    BonjourRegisterCallback, this);
        tries++;
    }

    if (kDNSServiceErr_NoError != result)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Register error: %1").arg(result));
        if (dnssref)
            DNSServiceRefDeallocate(dnssref);
    }
    else
    {
        QMutexLocker locker(&m_serviceLock);
        quint32 reference = Reference;
        while (!reference || m_services.contains(reference))
            reference++;
        TorcBonjourService service(TorcBonjourService::Service, dnssref, Name, Type);
        service.m_txt  = Txt;
        service.m_port = Port;
        m_services.insert(reference, service);
        m_services[reference].SetFileDescriptor(DNSServiceRefSockFD(dnssref), this);
        return reference;
    }

    LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Failed to register service."));
    return 0;
}

quint32 TorcBonjour::Browse(const QByteArray &Type, quint32 Reference /*=0*/)
{
    static QByteArray dummy("browser");

    if (m_suspended)
    {
        QMutexLocker locker(&m_serviceLock);

        TorcBonjourService service(TorcBonjourService::Browse, nullptr, dummy, Type);
        quint32 reference = Reference;
        while (!reference || m_services.contains(reference))
            reference++;
        m_services.insert(reference, service);

        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Bonjour browse request deferred until Bonjour resumed"));
        return reference;
    }

    DNSServiceRef dnssref = nullptr;
    DNSServiceErrorType result = DNSServiceBrowse(&dnssref, 0,
                                                  kDNSServiceInterfaceIndexAny,
                                                  Type, nullptr, BonjourBrowseCallback, this);
    if (kDNSServiceErr_NoError != result)
    {
        LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Browse error: %1").arg(result));
        if (dnssref)
            DNSServiceRefDeallocate(dnssref);
    }
    else
    {
        QMutexLocker locker(&m_serviceLock);
        quint32 reference = Reference;
        while (!reference || m_services.contains(reference))
            reference++;
        TorcBonjourService service(TorcBonjourService::Browse, dnssref, dummy, Type);
        m_services.insert(reference, service);
        m_services[reference].SetFileDescriptor(DNSServiceRefSockFD(dnssref), this);
        LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Browsing for '%1'").arg(Type.constData()));
        return reference;
    }

    LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Failed to browse for '%1'").arg(Type.constData()));
    return 0;
}

void TorcBonjour::Deregister(quint32 Reference)
{
    if (!Reference)
        return;

    QByteArray type;

    {
        QMutexLocker locker(&m_serviceLock);
        if (m_services.contains(Reference))
        {
            type = m_services[Reference].m_type;
            m_services[Reference].Deregister();
            m_services.remove(Reference);
        }
    }

    if (type.isEmpty())
    {
        LOG(VB_GENERAL, LOG_WARNING, QStringLiteral("Trying to de-register an unknown service."));
        return;
    }

    // Remove any resolve requests associated with this type
    {
        QMutexLocker locker(&m_discoveredLock);
        QMutableMapIterator<quint32,TorcBonjourService> it(m_discoveredServices);
        while (it.hasNext())
        {
            it.next();
            if (it.value().m_type == type)
            {
                it.value().Deregister();
                it.remove();
            }
        }
    }
}

void TorcBonjour::socketReadyRead(int Socket)
{
    {
        // match Socket to an announced service
        QMutexLocker lock(&m_serviceLock);
        QMap<quint32,TorcBonjourService>::const_iterator it = m_services.constBegin();
        for ( ; it != m_services.constEnd(); ++it)
        {
            if ((*it).m_fd == Socket)
            {
                DNSServiceErrorType res = DNSServiceProcessResult((*it).m_dnssRef);
                if (kDNSServiceErr_NoError != res)
                    LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Read Error: %1").arg(res));
                return;
            }
        }
    }

    {
        // match Socket to a discovered service
        QMutexLocker lock(&m_discoveredLock);
        QMap<quint32,TorcBonjourService>::const_iterator it = m_discoveredServices.constBegin();
        for ( ; it != m_discoveredServices.constEnd(); ++it)
        {
            if ((*it).m_fd == Socket)
            {
                DNSServiceErrorType res = DNSServiceProcessResult((*it).m_dnssRef);
                if (kDNSServiceErr_NoError != res)
                    LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Read Error: %1").arg(res));
                return;
            }
        }
    }

    LOG(VB_GENERAL, LOG_WARNING, QStringLiteral("Read request on unknown socket"));
}

void TorcBonjour::SuspendPriv(bool Suspend)
{
    if (Suspend)
    {
        if (m_suspended)
        {
            LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Bonjour already suspended"));
            return;
        }

        LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Suspending bonjour activities"));

        m_suspended = true;

        {
            QMutexLocker locker(&m_serviceLock);

            // close the services but retain the necessary details
            QMap<quint32,TorcBonjourService> services;
            QMap<quint32,TorcBonjourService>::const_iterator it = m_services.constBegin();
            for (; it != m_services.constEnd(); ++it)
            {
                TorcBonjourService service((*it).m_serviceType, nullptr, (*it).m_name, (*it).m_type);
                service.m_txt  = (*it).m_txt;
                service.m_port = (*it).m_port;
                services.insert(it.key(), service);
            }
            foreach(TorcBonjourService service, m_services)
                service.Deregister();
            m_services.clear();
            m_services = services;
        }
    }
    else
    {
        if (!m_suspended)
        {
            LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Cannot resume - not suspended"));
            return;
        }

        LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Resuming bonjour activities"));

        {
            QMutexLocker locker(&m_serviceLock);

            m_suspended = false;

            QMap<quint32,TorcBonjourService> services = m_services;
            m_services.clear();

            QMap<quint32,TorcBonjourService>::const_iterator it = services.constBegin();
            for (; it != services.constEnd(); ++it)
            {
                if ((*it).m_serviceType == TorcBonjourService::Service)
                    (void)Register((*it).m_port, (*it).m_type, (*it).m_name, (*it).m_txt, it.key());
                else
                    (void)Browse((*it).m_type, it.key());
            }
        }
    }
}

void TorcBonjour::AddBrowseResult(DNSServiceRef Reference, const TorcBonjourService &Service)
{
    {
        // validate against known browsers
        QMutexLocker locker(&m_serviceLock);
        bool found = false;
        QMap<quint32,TorcBonjourService>::const_iterator it = m_services.constBegin();
        for ( ; it != m_services.constEnd(); ++it)
        {
            if ((*it).m_dnssRef == Reference)
            {
                found = true;
                break;
            }
        }

        if (!found)
        {
            LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Browser result for unknown browser"));
            return;
        }
    }

    {
        // have we already seen this service?
        QMutexLocker locker(&m_discoveredLock);
        QMap<quint32,TorcBonjourService>::const_iterator it = m_discoveredServices.constBegin();
        for( ; it != m_discoveredServices.constEnd(); ++it)
        {
            if ((*it).m_name == Service.m_name &&
                (*it).m_type == Service.m_type &&
                (*it).m_domain == Service.m_domain &&
                (*it).m_interfaceIndex == Service.m_interfaceIndex)
            {
                LOG(VB_NETWORK, LOG_INFO, QStringLiteral("Service '%1' already discovered - ignoring")
                    .arg(Service.m_name.constData()));
                return;
            }
        }

        // kick off resolve
        DNSServiceRef reference = nullptr;
        DNSServiceErrorType error =
            DNSServiceResolve(&reference, 0, Service.m_interfaceIndex,
                              Service.m_name.constData(), Service.m_type.constData(),
                              Service.m_domain.constData(), BonjourResolveCallback,
                              this);
        if (error != kDNSServiceErr_NoError)
        {
            LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Service resolution call failed"));
            if (reference)
                DNSServiceRefDeallocate(reference);
        }
        else
        {
            // add it to our list
            TorcBonjourService service = Service;
            quint32 ref = 1;
            while (m_discoveredServices.contains(ref))
                ref++;
            service.m_dnssRef = reference;
            m_discoveredServices.insert(ref, service);
            m_discoveredServices[ref].SetFileDescriptor(DNSServiceRefSockFD(reference), this);
            LOG(VB_NETWORK, LOG_INFO, QStringLiteral("Resolving '%1'").arg(service.m_name.constData()));
        }
    }
}

void TorcBonjour::RemoveBrowseResult(DNSServiceRef Reference,
                        const TorcBonjourService &Service)
{
    {
        // validate against known browsers
        QMutexLocker locker(&m_serviceLock);
        bool found = false;
        QMap<quint32,TorcBonjourService>::const_iterator it = m_services.constBegin();
        for ( ; it != m_services.constEnd(); ++it)
        {
            if ((*it).m_dnssRef == Reference)
            {
                found = true;
                break;
            }
        }

        if (!found)
        {
            LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Browser result for unknown browser"));
            return;
        }
    }

    {
        // validate against known services
        QMutexLocker locker(&m_discoveredLock);
        QMutableMapIterator<quint32,TorcBonjourService> it(m_discoveredServices);
        while (it.hasNext())
        {
            it.next();
            if (it.value().m_type == Service.m_type &&
                it.value().m_name == Service.m_name &&
                it.value().m_domain == Service.m_domain &&
                it.value().m_interfaceIndex == Service.m_interfaceIndex)
            {
                QVariantMap data;
                data.insert(TORC_BONJOUR_NAME, it.value().m_name.constData());
                data.insert(TORC_BONJOUR_TYPE, it.value().m_type.constData());
                data.insert(TORC_BONJOUR_TXT, it.value().m_txt);
                data.insert(TORC_BONJOUR_HOST, it.value().m_host);
                TorcEvent event(Torc::ServiceWentAway, data);
                gLocalContext->Notify(event);

                LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Service '%1' on '%2' went away")
                    .arg(it.value().m_type.constData(),
                         it.value().m_host.isEmpty() ? it.value().m_name.constData() : it.value().m_host.constData()));
                it.value().Deregister();
                it.remove();
            }
        }
    }
}

void TorcBonjour::Resolve(DNSServiceRef Reference, DNSServiceErrorType ErrorType, const char *Fullname,
             const char *HostTarget, uint16_t Port, uint16_t TxtLen,
             const unsigned char *TxtRecord)
{
    (void)Fullname;

    if (!Reference)
        return;

    {
        QMutexLocker locker(&m_discoveredLock);
        foreach(TorcBonjourService service, m_discoveredServices)
        {
            if (service.m_dnssRef == Reference)
            {
                if (ErrorType != kDNSServiceErr_NoError)
                {
                    LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Failed to resolve '%1' (Error %2)").arg(service.m_name.constData()).arg(ErrorType));
                    QVariantMap data;
                    data.insert(TORC_BONJOUR_NAME, service.m_name.constData());
                    data.insert(TORC_BONJOUR_TYPE, service.m_type.constData());
                    data.insert(TORC_BONJOUR_PORT, service.m_port);
                    data.insert(TORC_BONJOUR_TXT, service.m_txt);
                    data.insert(TORC_BONJOUR_HOST, service.m_host.constData());
                    // as per HostLookup below - resolve may have failed due to a network disruption and the service is no
                    // longer available. Signal removal - if it wasn't already known it won't matter.
                    TorcEvent event(Torc::ServiceWentAway, data);
                    gLocalContext->Notify(event);
                    return;
                }

                uint16_t port = ntohs(Port);
                service.m_host = HostTarget;
                service.m_port = port;
                LOG(VB_NETWORK, LOG_INFO, QStringLiteral("%1 (%2) resolved to %3:%4")
                    .arg(service.m_name.constData(), service.m_type.constData(), HostTarget).arg(port));
                QString name(HostTarget);
                service.m_lookupID = QHostInfo::lookupHost(name, this, SLOT(HostLookup(QHostInfo)));
                service.m_txt      = QByteArray((const char *)TxtRecord, TxtLen);
                return;
            }
        }
    }
}

void TorcBonjour::HostLookup(const QHostInfo &HostInfo)
{
    // search for the lookup id
    QMutexLocker locker(&m_discoveredLock);
    foreach(TorcBonjourService service, m_discoveredServices)
    {
        if (service.m_lookupID == HostInfo.lookupId())
        {
            service.m_lookupID = -1;

            // igore if errored
            if (HostInfo.error() != QHostInfo::NoError)
            {
                LOG(VB_GENERAL, LOG_ERR, QStringLiteral("Lookup failed for '%1' with error '%2'").arg(HostInfo.hostName(), HostInfo.errorString()));
                return;
            }

            service.m_ipAddresses = HostInfo.addresses();
            LOG(VB_GENERAL, LOG_INFO, QStringLiteral("Service '%1' on '%2:%3' resolved to %4 address(es) on interface %5")
                .arg(service.m_type.constData(), service.m_host.constData())
                .arg(service.m_port)
                .arg(service.m_ipAddresses.size())
                .arg(service.m_interfaceIndex));

            QStringList addresses;

            foreach (const QHostAddress &address, service.m_ipAddresses)
            {
                LOG(VB_NETWORK, LOG_INFO, QStringLiteral("Address: %1").arg(address.toString()));
                addresses << address.toString();
            }

            QVariantMap data;
            data.insert(TORC_BONJOUR_NAME, service.m_name.constData());
            data.insert(TORC_BONJOUR_TYPE, service.m_type.constData());
            data.insert(TORC_BONJOUR_PORT, service.m_port);
            data.insert(TORC_BONJOUR_ADDRESSES, addresses);
            data.insert(TORC_BONJOUR_TXT, service.m_txt);
            data.insert(TORC_BONJOUR_HOST, service.m_host.constData());
            if (!addresses.isEmpty())
            {
                TorcEvent event(Torc::ServiceDiscovered, data);
                gLocalContext->Notify(event);
            }
            else
            {
                LOG(VB_GENERAL, LOG_WARNING, QStringLiteral("No valid addresses resolved for Service '%1' on '%2:%3'")
                    .arg(service.m_type.constData(), service.m_host.constData())
                    .arg(service.m_port));
                // NB this is experimental!!!
                TorcEvent event(Torc::ServiceWentAway, data);
                gLocalContext->Notify(event);
            }
        }
    }
}