ArnZeroConf.hpp

Go to the documentation of this file.

// Copyright (C) 2010-2022 Michael Wiklund.
// All rights reserved.
// Contact: arnlib@wiklunden.se
//
// This file is part of the ArnLib - Active Registry Network.
// Parts of ArnLib depend on Qt and/or other libraries that have their own
// licenses. Usage of these other libraries is subject to their respective
// license agreements.
//
// GNU Lesser General Public License Usage
// This file may be used under the terms of the GNU Lesser General Public
// License version 2.1 as published by the Free Software Foundation and
// appearing in the file LICENSE_LGPL.txt included in the packaging of this
// file. In addition, as a special exception, you may use the rights described
// in the Nokia Qt LGPL Exception version 1.1, included in the file
// LGPL_EXCEPTION.txt in this package.
//
// GNU General Public License Usage
// Alternatively, this file may be used under the terms of the GNU General Public
// License version 3.0 as published by the Free Software Foundation and appearing
// in the file LICENSE_GPL.txt included in the packaging of this file.
//
// Other Usage
// Alternatively, this file may be used in accordance with the terms and conditions
// contained in a signed written agreement between you and Michael Wiklund.
//
// 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 Lesser General Public License for more details.
//

#ifndef ARNZEROCONF_HPP
#define ARNZEROCONF_HPP

#include "ArnLib_global.hpp"
#include "XStringMap.hpp"
#include "MQFlags.hpp"
#include <QHostAddress>
#include <QObject>
#include <QStringList>
#include <QString>
#include <QAbstractSocket>
#include <QAtomicInt>

typedef struct _DNSServiceRef_t *DNSServiceRef;
class QSocketNotifier;
class QTimer;
class QHostInfo;


namespace ArnZeroConf {
struct Error {
    enum E {
        Ok        = 0,
        Running   = -1,
        BadReqSeq = -2,
        Timeout   = -3,
        UDnsFail  = -4
    };
    MQ_DECLARE_ENUM( Error)
};

struct State {
    enum E {
        None        = 0x0000,
        Registering = 0x0100,
        Registered  = 0x0001,
        Register    = 0x0101,
        Browsing    = 0x0200,
        Resolving   = 0x0400,
        Resolved    = 0x0004,
        Resolve     = 0x0404,
        LookingUp   = 0x0800,
        Lookuped    = 0x0008,
        Lookup      = 0x0808,
        InProgress  = 0x0f00
    };
    MQ_DECLARE_FLAGS( State)
};
}  // ArnZeroConf::

MQ_DECLARE_OPERATORS_FOR_FLAGS( ArnZeroConf::State)



class ARNLIBSHARED_EXPORT ArnZeroConfB : public QObject
{
    Q_OBJECT
public:
    ArnZeroConfB( QObject* parent = arnNullptr);
    virtual ~ArnZeroConfB();


    QAbstractSocket::SocketType  socketType()  const;


    void  setSocketType( QAbstractSocket::SocketType type);


    QString  serviceType()  const;


    void  setServiceType( const QString& type);


    QString  domain()  const;


    void  setDomain( const QString& domain);


    ArnZeroConf::State  state()  const;


    QString  fullServiceType()  const;

    QByteArray  escapedFullDomain()  const;

protected slots:
    void socketData();
    
protected:

    QStringList  subTypes()  const;


    void  setSubTypes( const QStringList& subTypes);


    void  addSubType( const QString& subType);


    quint16  port()  const;


    void  setPort( quint16 port);


    QString  serviceName()  const;


    void  setServiceName( const QString& name);


    QString  host()  const;


    void  setHost( const QString& host);


    bool  getTxtRecordMap( Arn::XStringMap& xsm);


    void  setTxtRecordMap( const Arn::XStringMap& xsm);


    QHostAddress  hostAddr()  const;


    void  setHostAddr( const QHostAddress &hostAddr);
    

    QByteArray  txtRecord()  const;


    void  setTxtRecord( const QByteArray& txt);


    static int  getNextId();

    void  parseFullDomain( const QByteArray& domainName);

    static QByteArray  escapedName( const QByteArray& name);

    QString  _serviceName;
    QString  _domain;
    QAbstractSocket::SocketType  _socketType;
    QString  _serviceType;
    QString  _host;
    QHostAddress _hostAddr;
    QByteArray  _txtRec;

    ArnZeroConf::State  _state;
    _DNSServiceRef_t*  _sdRef;
    QStringList  _serviceSubTypes;
    int  _iface;
    QString  _txtRecord;

    QSocketNotifier*  _notifier;

    // Source for unique id to all discovered services ...
    static QAtomicInt  _idCount;

private:
    quint16  _port;
};



class ARNLIBSHARED_EXPORT ArnZeroConfRegister : public ArnZeroConfB
{
    friend class ArnZeroConfIntern;
    Q_OBJECT
public:

    ArnZeroConfRegister( QObject* parent = arnNullptr);


    ArnZeroConfRegister( const QString& serviceName, QObject* parent = arnNullptr);


    ArnZeroConfRegister( const QString& serviceName, const QString& serviceType, quint16 port,
                         QObject* parent = arnNullptr);


    virtual ~ArnZeroConfRegister();


    QStringList  subTypes()  const
    {return ArnZeroConfB::subTypes();}


    void  setSubTypes( const QStringList& subtypes)
    {ArnZeroConfB::setSubTypes( subtypes);}


    void  addSubType( const QString& subtype)
    {ArnZeroConfB::addSubType( subtype);}


    quint16  port()  const
    {return ArnZeroConfB::port();}


    void  setPort( quint16 port)
    {ArnZeroConfB::setPort( port);}


    QString  serviceName()  const
    {return ArnZeroConfB::serviceName();}


    QString  currentServiceName()  const;


    void  setServiceName( const QString& name);


    QString  host()  const
    {return ArnZeroConfB::host();}


    void  setHost( const QString& host)
    {ArnZeroConfB::setHost( host);}


    bool  getTxtRecordMap( Arn::XStringMap& xsm)
    {return ArnZeroConfB::getTxtRecordMap( xsm);}


    void  setTxtRecordMap( const Arn::XStringMap& xsm)
    {ArnZeroConfB::setTxtRecordMap( xsm);}


    QByteArray  txtRecord()  const
    {return ArnZeroConfB::txtRecord();}


    void  setTxtRecord( const QByteArray& txt)
    {ArnZeroConfB::setTxtRecord( txt);}


    void  registerService( bool noAutoRename = false);


    void  releaseService();

signals:

    void  registered( const QString& serviceName);


    void  registrationError( int code);

private:
    void  init();

    QString  _currentServiceName;
};



class ARNLIBSHARED_EXPORT ArnZeroConfResolve : public ArnZeroConfB
{
    friend class ArnZeroConfIntern;
    Q_OBJECT
public:

    ArnZeroConfResolve( QObject* parent = arnNullptr);


    ArnZeroConfResolve( const QString& serviceName, QObject* parent = arnNullptr);


    ArnZeroConfResolve( const QString& serviceName, const QString& serviceType, QObject* parent = arnNullptr);


    virtual ~ArnZeroConfResolve();


    int id() const;


    void setId(int id);


    QString  host()  const
    {return ArnZeroConfB::host();}


    quint16  port()  const
    {return ArnZeroConfB::port();}


    QString  serviceName()  const
    {return ArnZeroConfB::serviceName();}


    void  setServiceName( const QString& name)
    {ArnZeroConfB::setServiceName( name);}


    bool  getTxtRecordMap( Arn::XStringMap& xsm)
    {return ArnZeroConfB::getTxtRecordMap( xsm);}


    QByteArray  txtRecord()  const
    {return ArnZeroConfB::txtRecord();}


    void  resolve( bool forceMulticast = false);


    void  releaseResolve();
    
signals:

    void  resolved( int id, const QByteArray& escFullDomain);


    void  resolveError( int id, int code);

private slots:
    void  operationTimeout();

private:
    void  init();

    int  _id;
    QTimer*  _operationTimer;
};



class ARNLIBSHARED_EXPORT ArnZeroConfLookup : public ArnZeroConfB
{
    friend class ArnZeroConfIntern;
    Q_OBJECT
public:

    ArnZeroConfLookup( QObject* parent = arnNullptr);


    ArnZeroConfLookup( const QString& hostName, QObject* parent = arnNullptr);


    virtual ~ArnZeroConfLookup();


    int id() const;


    void setId(int id);


    QString  host()  const
    {return ArnZeroConfB::host();}


    void  setHost( const QString& host)
    {ArnZeroConfB::setHost( host);}


    QHostAddress  hostAddr()  const
    {return ArnZeroConfB::hostAddr();}


    void  lookup( bool forceMulticast = false);
    

    void  releaseLookup();


    static bool  isForceQtDnsLookup();


    static void  setForceQtDnsLookup( bool isForceQtDnsLookup);

signals:

    void  lookuped( int id);


    void  lookupError( int id, int code);

private slots:
    void  operationTimeout();
    void  onIpLookup( const QHostInfo& host);

private:
    void  init();

    int  _id;
    QTimer*  _operationTimer;

    static bool  _isForceQtDnsLookup;
};




class  ARNLIBSHARED_EXPORT ArnZeroConfBrowser : public ArnZeroConfB
{
    friend class ArnZeroConfIntern;
    Q_OBJECT
public:

    ArnZeroConfBrowser( QObject* parent = arnNullptr);


    ArnZeroConfBrowser( const QString& serviceType, QObject* parent = arnNullptr);


    virtual ~ArnZeroConfBrowser();


    void  setSubType( const QString& subtype);


    QString  subType();


    QStringList  activeServiceNames()  const;


    int  serviceNameToId( const QString& name);


    bool  isBrowsing()  const;


    static int  getNextId()
    {return ArnZeroConfB::getNextId();}

public slots:

    void  browse( bool enable = true);


    void  stopBrowse();

signals:

    void  serviceChanged( bool isAdded, int id, const QString& serviceName, const QString& domain);


    void  serviceAdded( int id, const QString& serviceName, const QString& domain);


    void  serviceRemoved( int id, const QString& serviceName, const QString& domain);


    void  browseError( int errorCode);

private:
    void  init();

    QMap<QString,int>  _activeServiceNames;
};

#endif // ARNZEROCONF_HPP