netnames.h

/*
 * Copyright (C) 2006  Justin Karneges
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301  USA
 *
 */

#ifndef NETNAMES_H
#define NETNAMES_H

#include <QtCore>
#include <QtNetwork>
#include "irisnetglobal.h"

namespace XMPP {

class NameManager;

class IRISNET_EXPORT NetNames
{
public:
        // free any shared data, shutdown internal dns sessions if necessary.
        static void cleanup();

        // return current diagnostic text, clear the buffer.
        static QString diagnosticText();

        // convert idn names
        static QByteArray idnaFromString(const QString &in);
        static QString idnaToString(const QByteArray &in);

        // dns escaping
        static QByteArray escapeDomain(const QByteArray &in);
        static QByteArray unescapeDomain(const QByteArray &in);

private:
        NetNames();
};

class IRISNET_EXPORT NameRecord
{
public:
        enum Type
        {
                A,     
                Aaaa,  
                Mx,    
                Srv,   
                Cname, 
                Ptr,   
                Txt,   
                Hinfo, 
                Ns,    
                Null,  
                Any    
        };

        NameRecord();

        NameRecord(const QByteArray &owner, int ttl);

        NameRecord(const NameRecord &from);

        ~NameRecord();

        NameRecord & operator=(const NameRecord &from);

        bool isNull() const; // don't confuse with Null type

        QByteArray owner() const;

        int ttl() const;

        Type type() const;

        QHostAddress address() const;

        QByteArray name() const;

        int priority() const;

        int weight() const;

        int port() const;

        QList<QByteArray> texts() const;

        QByteArray cpu() const;

        QByteArray os() const;

        QByteArray rawData() const;

        void setOwner(const QByteArray &name);

        void setTTL(int seconds);

        void setAddress(const QHostAddress &a);

        void setMx(const QByteArray &name, int priority);

        void setSrv(const QByteArray &name, int port, int priority, int weight);

        void setCname(const QByteArray &name);

        void setPtr(const QByteArray &name);

        void setTxt(const QList<QByteArray> &texts);

        void setHinfo(const QByteArray &cpu, const QByteArray &os);

        void setNs(const QByteArray &name);

        void setNull(const QByteArray &rawData);

private:
        class Private;
        QSharedDataPointer<Private> d;
};

class IRISNET_EXPORT ServiceInstance
{
public:
        ServiceInstance();
        ServiceInstance(const QString &instance, const QString &type, const QString &domain, const QMap<QString,QByteArray> &attributes);
        ServiceInstance(const ServiceInstance &from);
        ~ServiceInstance();
        ServiceInstance & operator=(const ServiceInstance &from);

        QString instance() const;
        QString type() const;
        QString domain() const;
        QMap<QString,QByteArray> attributes() const;
        QByteArray name() const; // full dns label

private:
        class Private;
        QSharedDataPointer<Private> d;

        friend class NameManager;
};

class IRISNET_EXPORT NameResolver : public QObject
{
        Q_OBJECT
public:
        enum Mode
        {
                Single,       
                LongLived     
        };

        enum Error
        {
                ErrorGeneric,     
                ErrorNoName,      
                ErrorTimeout,     
                ErrorNoLocal,     
                ErrorNoLongLived  
        };

        NameResolver(QObject *parent = 0);

        ~NameResolver();

        void start(const QByteArray &name, NameRecord::Type type = NameRecord::A, Mode mode = Single);

        void stop();

signals:
        void resultsReady(const QList<XMPP::NameRecord> &results);

        void error(XMPP::NameResolver::Error e);

private:
        class Private;
        friend class Private;
        Private *d;

        friend class NameManager;
};

class IRISNET_EXPORT ServiceBrowser : public QObject
{
        Q_OBJECT
public:
        ServiceBrowser(QObject *parent = 0);
        ~ServiceBrowser();

        void start(const QString &type, const QString &domain = "local");
        void stop();

signals:
        void instanceAvailable(const XMPP::ServiceInstance &instance);
        void instanceUnavailable(const XMPP::ServiceInstance &instance);
        void error();

private:
        class Private;
        friend class Private;
        Private *d;

        friend class NameManager;
};

class IRISNET_EXPORT ServiceResolver : public QObject
{
        Q_OBJECT
public:
        ServiceResolver(QObject *parent = 0);
        ~ServiceResolver();

        void startFromInstance(const QByteArray &name);
        void startFromDomain(const QString &domain, const QString &type);
        void startFromPlain(const QString &host, int port); // non-SRV
        void tryNext();
        void stop();

signals:
        void resultsReady(const QHostAddress &address, int port);
        void finished();
        void error(); // SRV lookup failed

private:
        class Private;
        friend class Private;
        Private *d;

        friend class NameManager;
};

class IRISNET_EXPORT ServiceLocalPublisher : public QObject
{
        Q_OBJECT
public:
        enum Error
        {
                ErrorGeneric,  // generic error
                ErrorConflict, // name in use
                ErrorNoLocal   // unable to setup multicast dns
        };

        ServiceLocalPublisher(QObject *parent = 0);
        ~ServiceLocalPublisher();

        void publish(const QString &instance, const QString &type, int port, const QMap<QString,QByteArray> &attributes);
        void updateAttributes(const QMap<QString,QByteArray> &attributes);
        void addRecord(const NameRecord &rec);
        void cancel();

signals:
        void published();
        void error(XMPP::ServiceLocalPublisher::Error e);

private:
        class Private;
        friend class Private;
        Private *d;

        friend class NameManager;
};

}

#endif

---